@yeaft/webchat-agent 0.0.233 → 0.0.235

package/crew/control.js

@@ -0,0 +1,364 @@
+/**
+ * Crew — 控制操作
+ * pause, resume, stop, clear, abort, interrupt 等
+ */
+import { join } from 'path';
+import { promises as fs } from 'fs';
+import { sendCrewMessage, sendCrewOutput, sendStatusUpdate, endRoleStreaming } from './ui-messages.js';
+import { saveRoleSessionId, clearRoleSessionId, createRoleQuery } from './role-query.js';
+import { saveSessionMeta, cleanupMessageShards } from './persistence.js';
+import { executeRoute, dispatchToRole } from './routing.js';
+import { cleanupWorktrees } from './worktree.js';
+import { upsertCrewIndex } from './persistence.js';
+import { processHumanQueue } from './human-interaction.js';
+
+/**
+ * 处理控制命令
+ */
+export async function handleCrewControl(msg) {
+  // Lazy import to avoid circular dependency
+  const { crewSessions } = await import('./session.js');
+
+  const { sessionId, action, targetRole } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  switch (action) {
+    case 'pause':
+      await pauseAll(session);
+      break;
+    case 'resume':
+      await resumeSession(session);
+      break;
+    case 'stop_role':
+      if (targetRole) await stopRole(session, targetRole);
+      break;
+    case 'interrupt_role':
+      if (targetRole && msg.content) {
+        await interruptRole(session, targetRole, msg.content, 'human');
+      }
+      break;
+    case 'abort_role':
+      if (targetRole) await abortRole(session, targetRole);
+      break;
+    case 'clear_role':
+      if (targetRole) await clearSingleRole(session, targetRole);
+      break;
+    case 'stop_all':
+      await stopAll(session);
+      break;
+    case 'clear':
+      await clearSession(session);
+      break;
+    default:
+      console.warn(`[Crew] Unknown control action: ${action}`);
+  }
+}
+
+/**
+ * 清空单个角色的对话
+ */
+async function clearSingleRole(session, roleName) {
+  const roleState = session.roleStates.get(roleName);
+
+  if (roleState) {
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    roleState.query = null;
+    roleState.inputStream = null;
+    roleState.turnActive = false;
+    roleState.claudeSessionId = null;
+    roleState.consecutiveErrors = 0;
+    roleState.accumulatedText = '';
+    roleState.lastDispatchContent = null;
+    roleState.lastDispatchFrom = null;
+    roleState.lastDispatchTaskId = null;
+    roleState.lastDispatchTaskTitle = null;
+  }
+
+  await clearRoleSessionId(session.sharedDir, roleName);
+
+  sendCrewMessage({
+    type: 'crew_role_cleared',
+    sessionId: session.id,
+    role: roleName,
+    reason: 'manual'
+  });
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${roleName} 对话已清空` }] }
+  });
+  sendStatusUpdate(session);
+  console.log(`[Crew] Role ${roleName} cleared`);
+}
+
+/**
+ * 暂停所有角色
+ */
+async function pauseAll(session) {
+  session.status = 'paused';
+
+  for (const [roleName, roleState] of session.roleStates) {
+    if (roleState.claudeSessionId) {
+      await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+        .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+    }
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    roleState.wasActive = roleState.turnActive;
+    roleState.turnActive = false;
+    roleState.query = null;
+    roleState.inputStream = null;
+  }
+
+  console.log(`[Crew] Session ${session.id} paused, all active queries aborted`);
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: 'Session 已暂停' }] }
+  });
+  sendStatusUpdate(session);
+
+  await saveSessionMeta(session);
+}
+
+/**
+ * 恢复 session
+ */
+async function resumeSession(session) {
+  if (session.status !== 'paused') return;
+
+  session.status = 'running';
+  console.log(`[Crew] Session ${session.id} resumed`);
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: 'Session 已恢复' }] }
+  });
+  sendStatusUpdate(session);
+
+  if (session.pendingRoutes.length > 0) {
+    const pending = session.pendingRoutes.slice();
+    session.pendingRoutes = [];
+    console.log(`[Crew] Replaying ${pending.length} pending route(s)`);
+    const results = await Promise.allSettled(pending.map(({ fromRole, route }) =>
+      executeRoute(session, fromRole, route)
+    ));
+    for (const r of results) {
+      if (r.status === 'rejected') {
+        console.warn(`[Crew] Pending route replay failed:`, r.reason);
+      }
+    }
+    return;
+  }
+
+  await processHumanQueue(session);
+}
+
+/**
+ * 中断角色当前 turn 并发送新消息
+ */
+async function interruptRole(session, roleName, newContent, fromSource = 'human') {
+  const roleState = session.roleStates.get(roleName);
+  if (!roleState) {
+    console.warn(`[Crew] Cannot interrupt ${roleName}: no roleState`);
+    return;
+  }
+
+  console.log(`[Crew] Interrupting ${roleName}`);
+
+  endRoleStreaming(session, roleName);
+
+  if (roleState.claudeSessionId) {
+    await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+      .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+  }
+
+  if (roleState.abortController) {
+    roleState.abortController.abort();
+  }
+
+  roleState.query = null;
+  roleState.inputStream = null;
+  roleState.turnActive = false;
+  roleState.accumulatedText = '';
+
+  sendCrewMessage({
+    type: 'crew_turn_completed',
+    sessionId: session.id,
+    role: roleName,
+    interrupted: true
+  });
+
+  sendStatusUpdate(session);
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${roleName} 被中断` }] }
+  });
+
+  await dispatchToRole(session, roleName, newContent, fromSource);
+}
+
+/**
+ * 中止角色当前 turn
+ */
+async function abortRole(session, roleName) {
+  const roleState = session.roleStates.get(roleName);
+  if (!roleState) {
+    console.warn(`[Crew] Cannot abort ${roleName}: no roleState`);
+    return;
+  }
+
+  if (!roleState.turnActive) {
+    console.log(`[Crew] ${roleName} is not active, nothing to abort`);
+    return;
+  }
+
+  console.log(`[Crew] Aborting ${roleName}`);
+
+  endRoleStreaming(session, roleName);
+
+  if (roleState.claudeSessionId) {
+    await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+      .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+  }
+
+  if (roleState.abortController) {
+    roleState.abortController.abort();
+  }
+
+  roleState.query = null;
+  roleState.inputStream = null;
+  roleState.turnActive = false;
+  roleState.accumulatedText = '';
+
+  sendCrewMessage({
+    type: 'crew_turn_completed',
+    sessionId: session.id,
+    role: roleName,
+    interrupted: true
+  });
+
+  sendStatusUpdate(session);
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${roleName} 已中止` }] }
+  });
+}
+
+async function stopRole(session, roleName) {
+  const roleState = session.roleStates.get(roleName);
+  if (roleState) {
+    if (roleState.claudeSessionId) {
+      await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+        .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+    }
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    roleState.query = null;
+    roleState.inputStream = null;
+    roleState.turnActive = false;
+    session.roleStates.delete(roleName);
+  }
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${roleName} 已停止` }] }
+  });
+  sendStatusUpdate(session);
+  console.log(`[Crew] Role ${roleName} stopped`);
+}
+
+/**
+ * 终止整个 session
+ */
+async function stopAll(session) {
+  const { crewSessions } = await import('./session.js');
+
+  session.status = 'stopped';
+
+  for (const [roleName, roleState] of session.roleStates) {
+    if (roleState.claudeSessionId) {
+      await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+        .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+    }
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    console.log(`[Crew] Stopping role: ${roleName}`);
+  }
+  session.roleStates.clear();
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: 'Session 已终止' }] }
+  });
+  sendStatusUpdate(session);
+
+  await cleanupWorktrees(session.projectDir);
+
+  await saveSessionMeta(session);
+  await upsertCrewIndex(session);
+
+  crewSessions.delete(session.id);
+  console.log(`[Crew] Session ${session.id} stopped`);
+}
+
+/**
+ * 清空 session
+ */
+async function clearSession(session) {
+  for (const [roleName, roleState] of session.roleStates) {
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    console.log(`[Crew] Clearing role: ${roleName}`);
+  }
+  session.roleStates.clear();
+
+  for (const [roleName] of session.roles) {
+    await clearRoleSessionId(session.sharedDir, roleName);
+  }
+
+  session.messageHistory = [];
+  session.uiMessages = [];
+  session.humanMessageQueue = [];
+  session.waitingHumanContext = null;
+  session.pendingRoutes = [];
+
+  // 清除 feature/task 数据，避免 UI 残留空 task 卡片
+  session.features.clear();
+  session._completedTaskIds = new Set();
+
+  session.round = 0;
+
+  const messagesPath = join(session.sharedDir, 'messages.json');
+  await fs.writeFile(messagesPath, '[]').catch(() => {});
+  await cleanupMessageShards(session.sharedDir);
+
+  session.status = 'running';
+
+  sendCrewMessage({
+    type: 'crew_session_cleared',
+    sessionId: session.id
+  });
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: '会话已清空，所有角色将使用全新对话' }] }
+  });
+  sendStatusUpdate(session);
+
+  await saveSessionMeta(session);
+
+  console.log(`[Crew] Session ${session.id} cleared`);
+}

package/crew/human-interaction.js

@@ -0,0 +1,115 @@
+/**
+ * Crew — 人工交互
+ * handleCrewHumanInput, processHumanQueue
+ */
+import { dispatchToRole } from './routing.js';
+import { sendStatusUpdate } from './ui-messages.js';
+
+/**
+ * 处理人的输入
+ */
+export async function handleCrewHumanInput(msg) {
+  // Lazy import to avoid circular dependency
+  const { crewSessions } = await import('./session.js');
+
+  const { sessionId, content, targetRole, files } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  // Build dispatch content (supports image attachments)
+  function buildHumanContent(prefix, text) {
+    if (files && files.length > 0) {
+      const blocks = [];
+      for (const file of files) {
+        if (file.isImage || file.mimeType?.startsWith('image/')) {
+          blocks.push({
+            type: 'image',
+            source: { type: 'base64', media_type: file.mimeType, data: file.data }
+          });
+        }
+      }
+      blocks.push({ type: 'text', text: `${prefix}\n${text}` });
+      return blocks;
+    }
+    return `${prefix}\n${text}`;
+  }
+
+  // 记录到 uiMessages 用于恢复时重放
+  session.uiMessages.push({
+    role: 'human', roleIcon: '', roleName: '你',
+    type: 'text', content,
+    timestamp: Date.now()
+  });
+
+  // 如果在等待人工介入
+  if (session.status === 'waiting_human') {
+    const waitingContext = session.waitingHumanContext;
+    session.status = 'running';
+    session.waitingHumanContext = null;
+    sendStatusUpdate(session);
+
+    const target = targetRole || waitingContext?.fromRole || session.decisionMaker;
+    await dispatchToRole(session, target, buildHumanContent('人工回复:', content), 'human');
+    return;
+  }
+
+  // 解析 @role 指令
+  const atMatch = content.match(/^@(\S+)\s*([\s\S]*)/);
+  if (atMatch) {
+    const atTarget = atMatch[1];
+    const message = atMatch[2].trim() || content;
+
+    let target = null;
+    for (const [name, role] of session.roles) {
+      if (name === atTarget.toLowerCase()) {
+        target = name;
+        break;
+      }
+      if (role.displayName === atTarget) {
+        target = name;
+        break;
+      }
+    }
+
+    if (target) {
+      await dispatchToRole(session, target, buildHumanContent('人工消息:', message), 'human');
+      return;
+    }
+  }
+
+  // 默认发给决策者
+  const target = targetRole || session.decisionMaker;
+  await dispatchToRole(session, target, buildHumanContent('人工消息:', content), 'human');
+}
+
+/**
+ * 处理排队的人的消息
+ */
+export async function processHumanQueue(session) {
+  if (session.humanMessageQueue.length === 0) return;
+  if (session._processingHumanQueue) return;
+  session._processingHumanQueue = true;
+  try {
+    const msgs = session.humanMessageQueue.splice(0);
+    if (msgs.length === 1) {
+      const humanPrompt = `人工消息:\n${msgs[0].content}`;
+      await dispatchToRole(session, msgs[0].target, humanPrompt, 'human');
+    } else {
+      const byTarget = new Map();
+      for (const m of msgs) {
+        if (!byTarget.has(m.target)) byTarget.set(m.target, []);
+        byTarget.get(m.target).push(m.content);
+      }
+      for (const [target, contents] of byTarget) {
+        const combined = contents.join('\n\n---\n\n');
+        const humanPrompt = `人工消息:\n你有 ${contents.length} 条待处理消息，请一并分析并用多个 ROUTE 块并行分配：\n\n${combined}`;
+        await dispatchToRole(session, target, humanPrompt, 'human');
+      }
+    }
+  } finally {
+    session._processingHumanQueue = false;
+  }
+}