@yeaft/webchat-agent 0.0.38 → 0.0.41

package/crew.js

@@ -0,0 +1,1025 @@
+/**
+ * Crew Mode - Multi-Agent Orchestrator
+ *
+ * 管理多个 AI 角色的协作：每个角色是一个独立的持久 query 实例，
+ * 编排器负责解析路由、分发消息、管理生命周期。
+ *
+ * 支持：
+ * - 动态添加/移除角色（群聊加人）
+ * - 角色级 CLAUDE.md + memory.md（利用 Claude Code 的 CLAUDE.md 自动向上查找机制）
+ * - 共享级 .crew/CLAUDE.md（所有角色自动继承）
+ * - Session resume（每个角色的 claudeSessionId 持久化）
+ * - 自动路由 + 人工混合
+ */
+
+import { query, Stream } from './sdk/index.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import ctx from './context.js';
+
+// =====================================================================
+// Data Structures
+// =====================================================================
+
+/** @type {Map<string, CrewSession>} */
+const crewSessions = new Map();
+
+// 导出供 connection.js 使用
+export { crewSessions };
+
+// =====================================================================
+// Session Lifecycle
+// =====================================================================
+
+/**
+ * 创建 Crew Session
+ * 支持带角色创建或空 session（后续动态添加角色）
+ */
+export async function createCrewSession(msg) {
+  const {
+    sessionId,
+    projectDir,
+    sharedDir: sharedDirRel,
+    goal,
+    roles = [],     // [{ name, displayName, icon, description, claudeMd, model, budget, isDecisionMaker }]
+    maxRounds = 20,
+    userId,
+    username
+  } = msg;
+
+  // 解析共享目录（相对路径相对于 projectDir）
+  const sharedDir = sharedDirRel?.startsWith('/')
+    ? sharedDirRel
+    : join(projectDir, sharedDirRel || '.crew');
+
+  // 初始化共享区
+  await initSharedDir(sharedDir, goal, roles, projectDir);
+
+  // 找到决策者
+  const decisionMaker = roles.find(r => r.isDecisionMaker)?.name || roles[0]?.name || null;
+
+  const session = {
+    id: sessionId,
+    projectDir,
+    sharedDir,
+    goal,
+    roles: new Map(roles.map(r => [r.name, r])),
+    roleStates: new Map(),
+    decisionMaker,
+    status: 'running',       // running | paused | waiting_human | completed | stopped
+    round: 0,
+    maxRounds,
+    costUsd: 0,
+    messageHistory: [],      // 群聊消息历史
+    humanMessageQueue: [],   // 人的消息排队
+    waitingHumanContext: null, // { fromRole, reason, message }
+    userId,
+    username,
+    createdAt: Date.now()
+  };
+
+  crewSessions.set(sessionId, session);
+
+  // 通知 server
+  sendCrewMessage({
+    type: 'crew_session_created',
+    sessionId,
+    projectDir,
+    sharedDir,
+    goal,
+    roles: roles.map(r => ({
+      name: r.name,
+      displayName: r.displayName,
+      icon: r.icon,
+      description: r.description,
+      isDecisionMaker: r.isDecisionMaker || false,
+      model: r.model
+    })),
+    decisionMaker,
+    maxRounds,
+    userId,
+    username
+  });
+
+  // 发送状态
+  sendStatusUpdate(session);
+
+  // 如果有预设角色，启动第一个
+  if (roles.length > 0) {
+    const firstRole = roles.find(r => r.name === 'pm') || roles[0];
+    if (firstRole) {
+      const initialPrompt = buildInitialTask(goal, firstRole, roles);
+      await dispatchToRole(session, firstRole.name, initialPrompt, 'system');
+    }
+  }
+
+  return session;
+}
+
+// =====================================================================
+// Dynamic Role Management
+// =====================================================================
+
+/**
+ * 向现有 session 动态添加角色
+ */
+export async function addRoleToSession(msg) {
+  const { sessionId, role } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  if (session.roles.has(role.name)) {
+    console.warn(`[Crew] Role already exists: ${role.name}`);
+    return;
+  }
+
+  // 添加角色到 session
+  session.roles.set(role.name, role);
+
+  // 如果还没有决策者且新角色是决策者，更新
+  if (role.isDecisionMaker) {
+    session.decisionMaker = role.name;
+  }
+  // 如果没有任何决策者，第一个角色作为决策者
+  if (!session.decisionMaker) {
+    session.decisionMaker = role.name;
+  }
+
+  // 初始化角色目录（CLAUDE.md + memory.md）
+  await initRoleDir(session.sharedDir, role);
+
+  // 更新共享 CLAUDE.md（增量添加新角色信息）
+  await updateSharedClaudeMd(session);
+
+  console.log(`[Crew] Role added: ${role.name} (${role.displayName}) to session ${sessionId}`);
+
+  // 通知 Web 端
+  sendCrewMessage({
+    type: 'crew_role_added',
+    sessionId,
+    role: {
+      name: role.name,
+      displayName: role.displayName,
+      icon: role.icon,
+      description: role.description,
+      isDecisionMaker: role.isDecisionMaker || false,
+      model: role.model
+    },
+    decisionMaker: session.decisionMaker
+  });
+
+  // 发送系统消息
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${role.icon} ${role.displayName} 加入了群聊` }] }
+  });
+
+  sendStatusUpdate(session);
+}
+
+/**
+ * 从 session 移除角色
+ */
+export async function removeRoleFromSession(msg) {
+  const { sessionId, roleName } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  const role = session.roles.get(roleName);
+  if (!role) {
+    console.warn(`[Crew] Role not found: ${roleName}`);
+    return;
+  }
+
+  // 停止角色的 query（如果正在运行）
+  const roleState = session.roleStates.get(roleName);
+  if (roleState) {
+    // 保存 sessionId 到文件（以便未来恢复）
+    if (roleState.claudeSessionId) {
+      await saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId);
+    }
+    if (roleState.abortController) {
+      roleState.abortController.abort();
+    }
+    session.roleStates.delete(roleName);
+  }
+
+  // 从 roles 中移除
+  session.roles.delete(roleName);
+
+  // 如果移除的是决策者，重新选择
+  if (session.decisionMaker === roleName) {
+    const remaining = Array.from(session.roles.values());
+    const newDM = remaining.find(r => r.isDecisionMaker) || remaining[0];
+    session.decisionMaker = newDM?.name || null;
+  }
+
+  // 更新 CLAUDE.md
+  await updateSharedClaudeMd(session);
+
+  // Memory 文件保留（不删除，角色可能重新加入）
+
+  console.log(`[Crew] Role removed: ${roleName} from session ${sessionId}`);
+
+  sendCrewMessage({
+    type: 'crew_role_removed',
+    sessionId,
+    roleName,
+    decisionMaker: session.decisionMaker
+  });
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: `${role.icon} ${role.displayName} 离开了群聊` }] }
+  });
+
+  sendStatusUpdate(session);
+}
+
+// =====================================================================
+// Shared Directory & Memory
+// =====================================================================
+
+/**
+ * 初始化共享目录
+ * 结构:
+ *   .crew/
+ *   ├── CLAUDE.md         ← 共享级（团队目标、成员、共享记忆）
+ *   ├── context/          ← 文档产出
+ *   ├── sessions/         ← sessionId 持久化
+ *   └── roles/
+ *       └── {roleName}/
+ *           └── CLAUDE.md ← 角色定义 + 个人记忆
+ */
+async function initSharedDir(sharedDir, goal, roles, projectDir) {
+  await fs.mkdir(sharedDir, { recursive: true });
+  await fs.mkdir(join(sharedDir, 'context'), { recursive: true });
+  await fs.mkdir(join(sharedDir, 'sessions'), { recursive: true });
+  await fs.mkdir(join(sharedDir, 'roles'), { recursive: true });
+
+  // 初始化每个角色的目录
+  for (const role of roles) {
+    await initRoleDir(sharedDir, role);
+  }
+
+  // 生成 .crew/CLAUDE.md（共享级）
+  await writeSharedClaudeMd(sharedDir, goal, roles, projectDir);
+}
+
+/**
+ * 初始化角色目录: .crew/roles/{roleName}/CLAUDE.md
+ */
+async function initRoleDir(sharedDir, role) {
+  const roleDir = join(sharedDir, 'roles', role.name);
+  await fs.mkdir(roleDir, { recursive: true });
+
+  // 角色 CLAUDE.md（仅首次创建，后续角色自己维护记忆内容）
+  const claudeMdPath = join(roleDir, 'CLAUDE.md');
+  try {
+    await fs.access(claudeMdPath);
+    // 已存在，不覆盖（保留角色自己写入的记忆）
+  } catch {
+    await writeRoleClaudeMd(sharedDir, role);
+  }
+}
+
+/**
+ * 写入 .crew/CLAUDE.md — 共享级（所有角色自动继承）
+ * 记忆直接写在 CLAUDE.md 中，Claude Code 会自动加载
+ */
+async function writeSharedClaudeMd(sharedDir, goal, roles, projectDir) {
+  const claudeMd = `# 项目目标
+${goal}
+
+# 项目代码路径
+${projectDir}
+所有代码操作请使用此绝对路径。
+
+# 团队成员
+${roles.length > 0 ? roles.map(r => `- ${r.icon} ${r.displayName}(${r.name}): ${r.description}${r.isDecisionMaker ? ' (决策者)' : ''}`).join('\n') : '_暂无成员_'}
+
+# 工作约定
+- 文档产出写入 context/ 目录
+- 重要决策记录在 context/decisions.md
+- 代码修改使用项目代码路径的绝对路径
+
+# 共享记忆
+_团队共同维护，记录重要的共识、决策和信息。_
+`;
+
+  await fs.writeFile(join(sharedDir, 'CLAUDE.md'), claudeMd);
+}
+
+/**
+ * 写入 .crew/roles/{roleName}/CLAUDE.md — 角色级
+ * 记忆直接追加在此文件中，Claude Code 自动加载
+ */
+async function writeRoleClaudeMd(sharedDir, role) {
+  const roleDir = join(sharedDir, 'roles', role.name);
+
+  const claudeMd = `# 角色: ${role.icon} ${role.displayName}
+${role.claudeMd || role.description}
+
+# 个人记忆
+_在这里记录重要的信息、决策、进展和待办事项。_
+`;
+
+  await fs.writeFile(join(roleDir, 'CLAUDE.md'), claudeMd);
+}
+
+/**
+ * 角色变动时更新 .crew/CLAUDE.md
+ */
+async function updateSharedClaudeMd(session) {
+  const roles = Array.from(session.roles.values());
+  await writeSharedClaudeMd(session.sharedDir, session.goal, roles, session.projectDir);
+}
+
+// =====================================================================
+// Session Persistence
+// =====================================================================
+
+/**
+ * 保存角色的 claudeSessionId 到文件
+ */
+async function saveRoleSessionId(sharedDir, roleName, claudeSessionId) {
+  const sessionsDir = join(sharedDir, 'sessions');
+  await fs.mkdir(sessionsDir, { recursive: true });
+  const filePath = join(sessionsDir, `${roleName}.json`);
+  await fs.writeFile(filePath, JSON.stringify({
+    claudeSessionId,
+    savedAt: Date.now()
+  }));
+  console.log(`[Crew] Saved sessionId for ${roleName}: ${claudeSessionId}`);
+}
+
+/**
+ * 从文件加载角色的 claudeSessionId
+ */
+async function loadRoleSessionId(sharedDir, roleName) {
+  const filePath = join(sharedDir, 'sessions', `${roleName}.json`);
+  try {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return data.claudeSessionId || null;
+  } catch {
+    return null;
+  }
+}
+
+// =====================================================================
+// Role Query Management
+// =====================================================================
+
+/**
+ * 为角色创建持久 query 实例
+ * 支持 resume：如果角色之前有保存的 sessionId，自动恢复上下文
+ */
+async function createRoleQuery(session, roleName) {
+  const role = session.roles.get(roleName);
+  if (!role) throw new Error(`Role not found: ${roleName}`);
+
+  const inputStream = new Stream();
+  const abortController = new AbortController();
+
+  const systemPrompt = buildRoleSystemPrompt(role, session);
+
+  // 尝试加载之前保存的 sessionId
+  const savedSessionId = await loadRoleSessionId(session.sharedDir, roleName);
+
+  // ★ cwd 设为角色目录，Claude Code 自动加载：
+  //   1. .crew/roles/{roleName}/CLAUDE.md（角色定义+个人记忆）
+  //   2. .crew/CLAUDE.md（共享目标+团队信息+共享记忆）
+  //   3. {projectDir}/CLAUDE.md（项目级，如果有的话）
+  const roleCwd = join(session.sharedDir, 'roles', roleName);
+
+  const queryOptions = {
+    cwd: roleCwd,
+    permissionMode: 'bypassPermissions',
+    abort: abortController.signal,
+    model: role.model || 'sonnet',
+    appendSystemPrompt: systemPrompt
+  };
+
+  // 如果有保存的 sessionId，使用 resume 恢复上下文
+  if (savedSessionId) {
+    queryOptions.resume = savedSessionId;
+    console.log(`[Crew] Resuming ${roleName} with sessionId: ${savedSessionId}`);
+  }
+
+  const roleQuery = query({
+    prompt: inputStream,
+    options: queryOptions
+  });
+
+  const roleState = {
+    query: roleQuery,
+    inputStream,
+    abortController,
+    accumulatedText: '',
+    turnActive: false,
+    claudeSessionId: savedSessionId
+  };
+
+  session.roleStates.set(roleName, roleState);
+
+  // 异步处理角色输出
+  processRoleOutput(session, roleName, roleQuery, roleState);
+
+  return roleState;
+}
+
+/**
+ * 构建角色的 system prompt（精简版）
+ * Memory 和工作区信息已通过 CLAUDE.md 自动加载，此处只补充路由规则
+ */
+function buildRoleSystemPrompt(role, session) {
+  const allRoles = Array.from(session.roles.values());
+  const otherRoles = allRoles.filter(r => r.name !== role.name);
+
+  let prompt = `# 团队协作
+你正在一个 AI 团队中工作。项目目标是: ${session.goal}
+
+团队成员:
+${allRoles.map(r => `- ${r.icon} ${r.displayName}: ${r.description}${r.isDecisionMaker ? ' (决策者)' : ''}`).join('\n')}`;
+
+  if (otherRoles.length > 0) {
+    prompt += `\n\n# 路由规则
+当你完成当前任务并需要将结果传递给其他角色时，在你的回复最末尾添加一个 ROUTE 块：
+
+\`\`\`
+---ROUTE---
+to: <角色name>
+summary: <简要说明要传递什么>
+---END_ROUTE---
+\`\`\`
+
+可用的路由目标:
+${otherRoles.map(r => `- ${r.name}: ${r.displayName}`).join('\n')}
+- human: 人工（只在决策者也无法决定时使用）
+
+注意：
+- 如果你的工作还没完成，不需要添加 ROUTE 块
+- 如果你遇到不确定的问题，@ 决策者 "${session.decisionMaker}"，而不是直接 @ human
+- 如果你是决策者且遇到需要人类判断的问题，才 @ human
+- 每次回复最多只能有一个 ROUTE 块
+- ROUTE 块必须在回复的最末尾`;
+  }
+
+  // 决策者额外 prompt
+  if (role.isDecisionMaker) {
+    prompt += `\n\n# 决策者职责
+你是团队的决策者。其他角色遇到不确定的情况会请求你的决策。
+- 如果你有足够的信息做出决策，直接决定并 @相关角色执行
+- 如果你需要更多信息，@具体角色请求补充
+- 如果问题超出你的能力范围或需要业务判断，@human 请人类决定
+- 你可以随时审查其他角色的工作并给出反馈`;
+  }
+
+  return prompt;
+}
+
+/**
+ * 构建初始任务 prompt
+ */
+function buildInitialTask(goal, firstRole, allRoles) {
+  return `项目启动！
+
+目标: ${goal}
+
+你是第一个开始工作的角色。请分析目标，开始你的工作。
+完成后，通过 ROUTE 块将结果传递给下一个合适的角色。
+
+团队中可用的角色:
+${allRoles.map(r => `- ${r.icon} ${r.name}: ${r.displayName} - ${r.description}`).join('\n')}`;
+}
+
+// =====================================================================
+// Role Output Processing
+// =====================================================================
+
+/**
+ * 处理角色的流式输出
+ */
+async function processRoleOutput(session, roleName, roleQuery, roleState) {
+  try {
+    for await (const message of roleQuery) {
+      // 检查 session 是否已停止
+      if (session.status === 'stopped') break;
+
+      if (message.type === 'system' && message.subtype === 'init') {
+        roleState.claudeSessionId = message.session_id;
+        console.log(`[Crew] ${roleName} session: ${message.session_id}`);
+        continue;
+      }
+
+      if (message.type === 'assistant') {
+        // 转发流式输出到 Web
+        sendCrewOutput(session, roleName, 'text', message);
+
+        // 累积文本用于路由解析
+        const content = message.message?.content;
+        if (content) {
+          if (typeof content === 'string') {
+            roleState.accumulatedText += content;
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.type === 'text') {
+                roleState.accumulatedText += block.text;
+              } else if (block.type === 'tool_use') {
+                // 转发 tool use
+                sendCrewOutput(session, roleName, 'tool_use', message);
+              }
+            }
+          }
+        }
+      } else if (message.type === 'user') {
+        // tool results
+        sendCrewOutput(session, roleName, 'tool_result', message);
+      } else if (message.type === 'result') {
+        // ★ Turn 完成！
+        console.log(`[Crew] ${roleName} turn completed`);
+
+        // 更新费用
+        if (message.total_cost_usd) {
+          session.costUsd += message.total_cost_usd;
+        }
+
+        // ★ 持久化 sessionId（每次 turn 完成后保存，用于后续 resume）
+        if (roleState.claudeSessionId) {
+          saveRoleSessionId(session.sharedDir, roleName, roleState.claudeSessionId)
+            .catch(e => console.warn(`[Crew] Failed to save sessionId for ${roleName}:`, e.message));
+        }
+
+        // 解析路由
+        const route = parseRoute(roleState.accumulatedText);
+        roleState.accumulatedText = '';
+        roleState.turnActive = false;
+
+        // 通知 turn 完成
+        sendCrewMessage({
+          type: 'crew_turn_completed',
+          sessionId: session.id,
+          role: roleName
+        });
+
+        // 发送状态更新
+        sendStatusUpdate(session);
+
+        // 执行路由
+        if (route) {
+          await executeRoute(session, roleName, route);
+        } else {
+          // 没有路由，角色完成了当前工作但没有指定下一步
+          // 检查是否有人的消息在排队
+          await processHumanQueue(session);
+        }
+      }
+    }
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.log(`[Crew] ${roleName} aborted`);
+    } else {
+      console.error(`[Crew] ${roleName} error:`, error.message);
+      // 通知决策者
+      if (roleName !== session.decisionMaker) {
+        const errorMsg = `角色 ${roleName} 发生错误: ${error.message}`;
+        await dispatchToRole(session, session.decisionMaker, errorMsg, roleName);
+      } else {
+        // 决策者自己出错了，通知人
+        sendCrewMessage({
+          type: 'crew_human_needed',
+          sessionId: session.id,
+          fromRole: roleName,
+          reason: 'error',
+          message: `决策者 ${roleName} 发生错误: ${error.message}`
+        });
+        session.status = 'waiting_human';
+        sendStatusUpdate(session);
+      }
+    }
+  }
+}
+
+// =====================================================================
+// Route Parsing & Execution
+// =====================================================================
+
+/**
+ * 从累积文本中解析 ROUTE 块
+ */
+function parseRoute(text) {
+  // 主格式
+  const match = text.match(/---ROUTE---\s*\n\s*to:\s*(.+?)\s*\n\s*summary:\s*(.+?)\s*\n\s*---END_ROUTE---/s);
+  if (match) {
+    return {
+      to: match[1].trim().toLowerCase(),
+      summary: match[2].trim()
+    };
+  }
+
+  // 备用格式（更宽松）
+  const altMatch = text.match(/---ROUTE---\s*\n([\s\S]*?)---END_ROUTE---/);
+  if (altMatch) {
+    const block = altMatch[1];
+    const toMatch = block.match(/to:\s*(.+)/i);
+    const summaryMatch = block.match(/summary:\s*(.+)/i);
+    if (toMatch) {
+      return {
+        to: toMatch[1].trim().toLowerCase(),
+        summary: summaryMatch ? summaryMatch[1].trim() : ''
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 执行路由
+ */
+async function executeRoute(session, fromRole, route) {
+  const { to, summary } = route;
+
+  // 增加轮次计数
+  session.round++;
+
+  // 检查最大轮次
+  if (session.round >= session.maxRounds) {
+    console.log(`[Crew] Max rounds (${session.maxRounds}) reached`);
+    session.status = 'completed';
+    sendCrewMessage({
+      type: 'crew_status',
+      sessionId: session.id,
+      status: 'max_rounds_reached',
+      round: session.round,
+      maxRounds: session.maxRounds
+    });
+    sendStatusUpdate(session);
+    return;
+  }
+
+  // 发送路由消息（UI 显示 → @xxx）
+  sendCrewOutput(session, fromRole, 'route', null, { routeTo: to, routeSummary: summary });
+
+  // 路由到 human
+  if (to === 'human') {
+    session.status = 'waiting_human';
+    session.waitingHumanContext = {
+      fromRole,
+      reason: 'requested',
+      message: summary
+    };
+    sendCrewMessage({
+      type: 'crew_human_needed',
+      sessionId: session.id,
+      fromRole,
+      reason: 'requested',
+      message: summary
+    });
+    sendStatusUpdate(session);
+    return;
+  }
+
+  // 路由到指定角色
+  if (session.roles.has(to)) {
+    // 先检查是否有人的消息在排队
+    if (session.humanMessageQueue.length > 0) {
+      // 人的消息优先
+      await processHumanQueue(session);
+    } else {
+      const taskPrompt = buildRoutePrompt(fromRole, summary, session);
+      await dispatchToRole(session, to, taskPrompt, fromRole);
+    }
+  } else {
+    console.warn(`[Crew] Unknown route target: ${to}`);
+    // 转给决策者
+    const errorMsg = `路由目标 "${to}" 不存在。来自 ${fromRole} 的消息: ${summary}`;
+    await dispatchToRole(session, session.decisionMaker, errorMsg, 'system');
+  }
+}
+
+/**
+ * 构建路由转发的 prompt
+ */
+function buildRoutePrompt(fromRole, summary, session) {
+  const fromRoleConfig = session.roles.get(fromRole);
+  const fromName = fromRoleConfig ? `${fromRoleConfig.icon} ${fromRoleConfig.displayName}` : fromRole;
+  return `来自 ${fromName} 的消息:\n${summary}\n\n请开始你的工作。完成后通过 ROUTE 块传递给下一个角色。`;
+}
+
+// =====================================================================
+// Message Dispatching
+// =====================================================================
+
+/**
+ * 向角色发送消息
+ */
+async function dispatchToRole(session, roleName, content, fromSource) {
+  if (session.status === 'paused' || session.status === 'stopped') {
+    console.log(`[Crew] Session ${session.status}, skipping dispatch to ${roleName}`);
+    return;
+  }
+
+  let roleState = session.roleStates.get(roleName);
+
+  // 如果角色没有 query 实例，创建一个（支持 resume）
+  if (!roleState || !roleState.query || !roleState.inputStream) {
+    roleState = await createRoleQuery(session, roleName);
+  }
+
+  // 记录消息历史
+  session.messageHistory.push({
+    from: fromSource,
+    to: roleName,
+    content: typeof content === 'string' ? content.substring(0, 200) : '...',
+    timestamp: Date.now()
+  });
+
+  // 发送
+  roleState.turnActive = true;
+  roleState.accumulatedText = '';
+  roleState.inputStream.enqueue({
+    type: 'user',
+    message: { role: 'user', content }
+  });
+
+  console.log(`[Crew] Dispatched to ${roleName} from ${fromSource}`);
+}
+
+// =====================================================================
+// Human Interaction
+// =====================================================================
+
+/**
+ * 处理人的输入
+ */
+export async function handleCrewHumanInput(msg) {
+  const { sessionId, content, targetRole } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  // 注意：不在这里发送人的消息到 Web（前端已本地添加，避免重复）
+
+  // 如果在等待人工介入
+  if (session.status === 'waiting_human') {
+    const waitingContext = session.waitingHumanContext;
+    session.status = 'running';
+    session.waitingHumanContext = null;
+    sendStatusUpdate(session);
+
+    // 发给请求人工介入的角色，或指定的目标角色
+    const target = targetRole || waitingContext?.fromRole || session.decisionMaker;
+    const humanPrompt = `人工回复:\n${content}`;
+    await dispatchToRole(session, target, humanPrompt, 'human');
+    return;
+  }
+
+  // 解析 @role 指令
+  const atMatch = content.match(/^@(\w+)\s*([\s\S]*)/);
+  if (atMatch) {
+    const target = atMatch[1].toLowerCase();
+    const message = atMatch[2].trim() || content;
+
+    if (session.roles.has(target)) {
+      // 检查目标角色是否正在忙
+      const targetState = session.roleStates.get(target);
+      if (targetState?.turnActive) {
+        // 排队
+        session.humanMessageQueue.push({ target, content: message, timestamp: Date.now() });
+        console.log(`[Crew] Human message queued for ${target} (busy)`);
+        return;
+      }
+      const humanPrompt = `人工消息:\n${message}`;
+      await dispatchToRole(session, target, humanPrompt, 'human');
+      return;
+    }
+  }
+
+  // 没有 @ 指定目标，发给决策者或当前活跃角色
+  const activeRole = findActiveRole(session);
+  const target = targetRole || activeRole || session.decisionMaker;
+
+  // 检查目标是否忙
+  const targetState = session.roleStates.get(target);
+  if (targetState?.turnActive) {
+    session.humanMessageQueue.push({ target, content, timestamp: Date.now() });
+    console.log(`[Crew] Human message queued for ${target} (busy)`);
+    return;
+  }
+
+  const humanPrompt = `人工消息:\n${content}`;
+  await dispatchToRole(session, target, humanPrompt, 'human');
+}
+
+/**
+ * 处理排队的人的消息
+ */
+async function processHumanQueue(session) {
+  if (session.humanMessageQueue.length === 0) return;
+
+  const msg = session.humanMessageQueue.shift();
+  const humanPrompt = `人工消息:\n${msg.content}`;
+  await dispatchToRole(session, msg.target, humanPrompt, 'human');
+}
+
+/**
+ * 找到当前活跃的角色（最近一个 turnActive 的）
+ */
+function findActiveRole(session) {
+  for (const [name, state] of session.roleStates) {
+    if (state.turnActive) return name;
+  }
+  return null;
+}
+
+// =====================================================================
+// Control Operations
+// =====================================================================
+
+/**
+ * 处理控制命令
+ */
+export async function handleCrewControl(msg) {
+  const { sessionId, action, targetRole } = msg;
+  const session = crewSessions.get(sessionId);
+  if (!session) {
+    console.warn(`[Crew] Session not found: ${sessionId}`);
+    return;
+  }
+
+  switch (action) {
+    case 'pause':
+      pauseAll(session);
+      break;
+    case 'resume':
+      await resumeSession(session);
+      break;
+    case 'stop_role':
+      if (targetRole) await stopRole(session, targetRole);
+      break;
+    case 'stop_all':
+      await stopAll(session);
+      break;
+    default:
+      console.warn(`[Crew] Unknown control action: ${action}`);
+  }
+}
+
+/**
+ * 暂停所有角色
+ */
+function pauseAll(session) {
+  session.status = 'paused';
+  console.log(`[Crew] Session ${session.id} paused`);
+
+  sendCrewOutput(session, 'system', 'system', {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text: 'Session 已暂停' }] }
+  });
+  sendStatusUpdate(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);
+
+  // 恢复后检查是否有排队的人的消息
+  await processHumanQueue(session);
+}
+
+/**
+ * 停止单个角色
+ */
+async function stopRole(session, roleName) {
+  const roleState = session.roleStates.get(roleName);
+  if (roleState) {
+    // 保存 sessionId
+    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) {
+  session.status = 'stopped';
+
+  // 保存所有角色的 sessionId
+  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);
+
+  // 从活跃 sessions 中移除
+  crewSessions.delete(session.id);
+  console.log(`[Crew] Session ${session.id} stopped`);
+}
+
+// =====================================================================
+// Message Helpers
+// =====================================================================
+
+/**
+ * 发送 crew 消息到 server（透传到 Web）
+ */
+function sendCrewMessage(msg) {
+  if (ctx.sendToServer) {
+    ctx.sendToServer(msg);
+  }
+}
+
+/**
+ * 发送角色输出到 Web
+ */
+function sendCrewOutput(session, roleName, outputType, rawMessage, extra = {}) {
+  const role = session.roles.get(roleName);
+
+  sendCrewMessage({
+    type: 'crew_output',
+    sessionId: session.id,
+    role: roleName,
+    roleIcon: role?.icon || (roleName === 'human' ? 'H' : roleName === 'system' ? 'S' : 'A'),
+    roleName: role?.displayName || roleName,
+    outputType,  // 'text' | 'tool_use' | 'tool_result' | 'route' | 'system'
+    data: rawMessage,
+    ...extra
+  });
+}
+
+/**
+ * 发送 session 状态更新
+ */
+function sendStatusUpdate(session) {
+  const currentRole = findActiveRole(session);
+
+  sendCrewMessage({
+    type: 'crew_status',
+    sessionId: session.id,
+    status: session.status,
+    currentRole,
+    round: session.round,
+    maxRounds: session.maxRounds,
+    costUsd: session.costUsd,
+    roles: Array.from(session.roles.values()).map(r => ({
+      name: r.name,
+      displayName: r.displayName,
+      icon: r.icon,
+      description: r.description,
+      isDecisionMaker: r.isDecisionMaker || false,
+      model: r.model
+    })),
+    activeRoles: Array.from(session.roleStates.entries())
+      .filter(([, s]) => s.turnActive)
+      .map(([name]) => name)
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.0.38",
+  "version": "0.0.41",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",
@@ -32,20 +32,9 @@
     "url": "https://github.com/yeaft/claude-web-chat/issues"
   },
   "files": [
-    "cli.js",
-    "service.js",
-    "index.js",
-    "context.js",
-    "connection.js",
-    "conversation.js",
-    "claude.js",
-    "terminal.js",
-    "proxy.js",
-    "workbench.js",
-    "history.js",
-    "encryption.js",
+    "*.js",
     "sdk/",
-    "scripts/agent-tray.ps1"
+    "scripts/"
   ],
   "license": "MIT",
   "author": "Yeaft",

package/scripts/create-startup-shortcut.ps1

@@ -0,0 +1,18 @@
+# 创建开机自启动快捷方式
+$AgentDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$StartupFolder = [Environment]::GetFolderPath('Startup')
+$ShortcutPath = Join-Path $StartupFolder "Claude Agent.lnk"
+
+$WshShell = New-Object -ComObject WScript.Shell
+$Shortcut = $WshShell.CreateShortcut($ShortcutPath)
+$Shortcut.TargetPath = "powershell.exe"
+$Shortcut.Arguments = "-WindowStyle Hidden -ExecutionPolicy Bypass -File `"$AgentDir\start-with-tray.ps1`""
+$Shortcut.WorkingDirectory = $AgentDir
+$Shortcut.Description = "Claude Agent with Tray"
+$Shortcut.WindowStyle = 7  # Minimized
+$Shortcut.Save()
+
+Write-Host "Startup shortcut created at:" -ForegroundColor Green
+Write-Host "  $ShortcutPath" -ForegroundColor Cyan
+Write-Host ""
+Write-Host "The agent will now start automatically when you log in." -ForegroundColor Green

package/scripts/ecosystem.config.cjs

@@ -0,0 +1,46 @@
+// 加载 .env 文件
+const fs = require('fs');
+const path = require('path');
+
+function loadEnv() {
+  const agentDir = path.join(__dirname, '..');
+  const envPath = path.join(agentDir, '.env');
+  const env = { NODE_ENV: 'production' };
+
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const match = line.match(/^\s*([^#][^=]*)\s*=\s*(.*)$/);
+      if (match) {
+        const key = match[1].trim();
+        let value = match[2].trim();
+        // 移除引号
+        value = value.replace(/^["']|["']$/g, '');
+        env[key] = value;
+      }
+    }
+  }
+  return env;
+}
+
+module.exports = {
+  apps: [{
+    name: 'claude-agent',
+    script: 'cli.js',
+    cwd: path.join(__dirname, '..'),
+    // 从 .env 文件加载环境变量
+    env: loadEnv(),
+    // 自动重启配置
+    autorestart: true,
+    watch: false,
+    max_restarts: 10,
+    restart_delay: 5000,
+    // 日志配置
+    log_date_format: 'YYYY-MM-DD HH:mm:ss',
+    error_file: 'logs/error.log',
+    out_file: 'logs/out.log',
+    merge_logs: true,
+    // 内存超限自动重启
+    max_memory_restart: '500M',
+  }]
+};

package/scripts/pm2-start.ps1

@@ -0,0 +1,59 @@
+# Claude Agent PM2 托管启动脚本
+# 用法: .\pm2-start.ps1
+
+$ErrorActionPreference = "Stop"
+$AgentDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+# 切换到 agent 目录
+Set-Location $AgentDir
+
+# 检查 pm2 是否安装
+$pm2Path = Get-Command pm2 -ErrorAction SilentlyContinue
+if (-not $pm2Path) {
+    Write-Host "Installing pm2 globally..." -ForegroundColor Yellow
+    npm install -g pm2
+    # Windows 上需要安装 pm2-windows-startup
+    npm install -g pm2-windows-startup
+}
+
+# 安装依赖 (每次都检查确保完整)
+Write-Host "Checking dependencies..." -ForegroundColor Yellow
+npm install --silent
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "Failed to install dependencies!" -ForegroundColor Red
+    exit 1
+}
+
+# 检查 .env 文件
+if (-not (Test-Path ".env")) {
+    Write-Host "No .env file found. Creating from .env.example..." -ForegroundColor Yellow
+    if (Test-Path ".env.example") {
+        Copy-Item ".env.example" ".env"
+        Write-Host "Please edit .env with your configuration, then run this script again." -ForegroundColor Red
+        exit 1
+    } else {
+        Write-Host "No .env.example found!" -ForegroundColor Red
+        exit 1
+    }
+}
+
+# 启动 pm2
+Write-Host ""
+Write-Host "Starting Claude Agent with pm2..." -ForegroundColor Green
+pm2 start ecosystem.config.cjs
+
+Write-Host ""
+Write-Host "Agent started!" -ForegroundColor Green
+Write-Host ""
+Write-Host "Management commands:" -ForegroundColor Cyan
+Write-Host "  pm2 status              - Check status"
+Write-Host "  pm2 logs claude-agent   - View logs (follow mode)"
+Write-Host "  pm2 logs claude-agent --lines 100  - View last 100 lines"
+Write-Host "  pm2 stop claude-agent   - Stop agent"
+Write-Host "  pm2 restart claude-agent - Restart agent"
+Write-Host "  pm2 delete claude-agent - Remove from pm2"
+Write-Host ""
+Write-Host "To enable startup on Windows boot:" -ForegroundColor Yellow
+Write-Host "  1. pm2 save"
+Write-Host "  2. pm2-startup install"
+Write-Host ""

package/scripts/start-with-tray.ps1

@@ -0,0 +1,36 @@
+# 启动 Claude Agent (pm2 托管) + 托盘图标
+$AgentDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $AgentDir
+
+# 检查 pm2
+$pm2 = Get-Command pm2 -ErrorAction SilentlyContinue
+if (-not $pm2) {
+    Write-Host "Installing pm2..." -ForegroundColor Yellow
+    npm install -g pm2
+}
+
+# 检查并安装 pm2-logrotate
+$logrotateInstalled = pm2 list 2>$null | Select-String "pm2-logrotate"
+if (-not $logrotateInstalled) {
+    Write-Host "Installing pm2-logrotate..." -ForegroundColor Yellow
+    pm2 install pm2-logrotate
+    # 配置 logrotate
+    pm2 set pm2-logrotate:max_size 10M
+    pm2 set pm2-logrotate:retain 7
+    pm2 set pm2-logrotate:compress true
+    Write-Host "pm2-logrotate configured (max 10MB, keep 7 files)" -ForegroundColor Cyan
+}
+
+# 先停止已有进程，确保干净启动
+Write-Host "Checking existing processes..." -ForegroundColor Gray
+pm2 delete claude-agent 2>$null | Out-Null
+
+# 启动 agent
+Write-Host "Starting Claude Agent..." -ForegroundColor Green
+pm2 start ecosystem.config.cjs
+
+# 启动托盘（隐藏窗口）
+Write-Host "Starting tray icon..." -ForegroundColor Green
+Start-Process powershell -ArgumentList "-WindowStyle Hidden -File `"$AgentDir\agent-tray.ps1`"" -WindowStyle Hidden
+
+Write-Host "Done! Check the system tray." -ForegroundColor Green