@yeaft/webchat-agent 0.1.51 → 0.1.55

package/claude.js

@@ -1,6 +1,7 @@
 import { query, Stream } from './sdk/index.js';
 import ctx from './context.js';
 import { sendConversationList, sendOutput, sendError, handleAskUserQuestion } from './conversation.js';
+import { buildVCrewSystemPrompt } from './vcrew.js';
 
 /**
  * Start a Claude SDK query for a conversation
@@ -9,11 +10,13 @@ import { sendConversationList, sendOutput, sendError, handleAskUserQuestion } fr
 export async function startClaudeQuery(conversationId, workDir, resumeSessionId) {
   // 如果已存在，先保存 per-session 设置，再关闭
   let savedDisallowedTools = null;
+  let savedVcrewConfig = null;
   let savedUserId = undefined;
   let savedUsername = undefined;
   if (ctx.conversations.has(conversationId)) {
     const existing = ctx.conversations.get(conversationId);
     savedDisallowedTools = existing.disallowedTools ?? null;
+    savedVcrewConfig = existing.vcrewConfig ?? null;
     savedUserId = existing.userId;
     savedUsername = existing.username;
     if (existing.abortController) {
@@ -51,6 +54,8 @@ export async function startClaudeQuery(conversationId, workDir, resumeSessionId)
     backgroundTasks: new Map(),
     // Per-session 工具禁用设置
     disallowedTools: savedDisallowedTools,
+    // Virtual Crew config (for appendSystemPrompt injection)
+    vcrewConfig: savedVcrewConfig,
     // 保留用户信息（从旧 state 恢复）
     userId: savedUserId,
     username: savedUsername,
@@ -80,6 +85,12 @@ export async function startClaudeQuery(conversationId, workDir, resumeSessionId)
     console.log(`[SDK] Disallowed tools: ${effectiveDisallowedTools.join(', ')}`);
   }
 
+  // Virtual Crew: inject appendSystemPrompt with role descriptions and workflow
+  if (savedVcrewConfig) {
+    options.appendSystemPrompt = buildVCrewSystemPrompt(savedVcrewConfig);
+    console.log(`[SDK] VCrew appendSystemPrompt injected (teamType: ${savedVcrewConfig.teamType})`);
+  }
+
   // Validate session ID is a valid UUID before using it
   const isValidUUID = (id) => {
     if (!id) return false;

package/conversation.js

@@ -2,6 +2,10 @@ import ctx from './context.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
 import { crewSessions, loadCrewIndex } from './crew.js';
+import { vcrewSessions, saveVCrewIndex, removeVCrewSession, loadVCrewIndex, validateVCrewConfig } from './vcrew.js';
+
+// Restore persisted vcrew sessions on module load (agent startup)
+loadVCrewIndex();
 
 // 不支持的斜杠命令（真正需要交互式 CLI 的命令）
 const UNSUPPORTED_SLASH_COMMANDS = ['/help', '/bug', '/login', '/logout', '/terminal-setup', '/vim', '/config'];
@@ -34,11 +38,11 @@ export function parseSlashCommand(message) {
   return { type: null, message };
 }
 
-// 发送 conversation 列表（含活跃 crew sessions + 索引中已停止的 crew sessions）
+// 发送 conversation 列表（含活跃 crew sessions + 索引中已停止的 crew sessions + vcrew sessions）
 export async function sendConversationList() {
   const list = [];
   for (const [id, state] of ctx.conversations) {
-    list.push({
+    const entry = {
       id,
       workDir: state.workDir,
       claudeSessionId: state.claudeSessionId,
@@ -46,7 +50,13 @@ export async function sendConversationList() {
       processing: !!state.turnActive,
       userId: state.userId,
       username: state.username
-    });
+    };
+    // vcrew conversations are stored in ctx.conversations but also tracked in vcrewSessions
+    if (vcrewSessions.has(id)) {
+      entry.type = 'virtualCrew';
+      entry.vcrewRoles = vcrewSessions.get(id).roles;
+    }
+    list.push(entry);
   }
   // 追加活跃 crew sessions
   const activeCrewIds = new Set();
@@ -108,8 +118,21 @@ export async function createConversation(msg) {
   const { conversationId, workDir, userId, username, disallowedTools } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
 
+  // Validate and sanitize vcrewConfig if provided
+  let vcrewConfig = null;
+  if (msg.vcrewConfig) {
+    const result = validateVCrewConfig(msg.vcrewConfig);
+    if (!result.valid) {
+      console.warn(`[createConversation] Invalid vcrewConfig: ${result.error}`);
+      sendError(conversationId, `Invalid vcrewConfig: ${result.error}`);
+      return;
+    }
+    vcrewConfig = result.config;
+  }
+
   console.log(`Creating conversation: ${conversationId} in ${effectiveWorkDir} (lazy start)`);
   if (username) console.log(`  User: ${username} (${userId})`);
+  if (vcrewConfig) console.log(`  VCrew: teamType=${vcrewConfig.teamType}, roles=${vcrewConfig.roles?.length}`);
 
   // 只创建 conversation 状态，不启动 Claude 进程
   // Claude 进程会在用户发送第一条消息时启动 (见 handleUserInput)
@@ -126,6 +149,7 @@ export async function createConversation(msg) {
     userId,
     username,
     disallowedTools: disallowedTools || null,  // null = 使用全局默认
+    vcrewConfig: vcrewConfig || null,
     usage: {
       inputTokens: 0,
       outputTokens: 0,
@@ -135,13 +159,28 @@ export async function createConversation(msg) {
     }
   });
 
+  // Register in vcrewSessions for type inference in sendConversationList
+  if (vcrewConfig) {
+    vcrewSessions.set(conversationId, {
+      roles: vcrewConfig.roles,
+      teamType: vcrewConfig.teamType,
+      language: vcrewConfig.language,
+      projectDir: effectiveWorkDir,
+      createdAt: Date.now(),
+      userId,
+      username,
+    });
+    saveVCrewIndex();
+  }
+
   ctx.sendToServer({
     type: 'conversation_created',
     conversationId,
     workDir: effectiveWorkDir,
     userId,
     username,
-    disallowedTools: disallowedTools || null
+    disallowedTools: disallowedTools || null,
+    vcrewConfig: vcrewConfig || null
   });
 
   // 立即发送 agent 级别的 MCP servers 列表（从 ~/.claude.json 读取的）
@@ -193,6 +232,12 @@ export async function resumeConversation(msg) {
 
   // 只创建 conversation 状态并保存 claudeSessionId，不启动 Claude 进程
   // Claude 进程会在用户发送第一条消息时启动 (见 handleUserInput)
+  // Restore vcrewConfig from persisted vcrewSessions if available
+  const vcrewEntry = vcrewSessions.get(conversationId);
+  const vcrewConfig = vcrewEntry
+    ? { roles: vcrewEntry.roles, teamType: vcrewEntry.teamType, language: vcrewEntry.language }
+    : null;
+
   ctx.conversations.set(conversationId, {
     query: null,
     inputStream: null,
@@ -206,6 +251,7 @@ export async function resumeConversation(msg) {
     userId,
     username,
     disallowedTools: disallowedTools || null,  // null = 使用全局默认
+    vcrewConfig,
     usage: {
       inputTokens: 0,
       outputTokens: 0,
@@ -271,6 +317,11 @@ export function deleteConversation(msg) {
     ctx.conversations.delete(conversationId);
   }
 
+  // Clean up vcrew session if applicable
+  if (vcrewSessions.has(conversationId)) {
+    removeVCrewSession(conversationId);
+  }
+
   ctx.sendToServer({
     type: 'conversation_deleted',
     conversationId

package/crew-i18n.js

@@ -129,6 +129,16 @@ ${isDevTeam ? '3' : '2'}. **任务完成** - 所有任务已完成，给出完
 止损触发时立即执行并通知决策者。遇到无法执行的情况立即反馈。`,
       strategist: () => '', // DM
 
+      // dev team
+      developer: (dm) => `代码完成后，必须同时发两个 ROUTE 块分别交给审查者和测试者（缺一不可）。
+UI/交互方案不确定时找设计师确认。需求不明确时找决策者 "${dm}" 确认。`,
+      reviewer_dev: (dm) => `审查完成后：评分 ≥ 9分通过，ROUTE 给决策者 "${dm}" 报告通过。评分 < 9分打回给开发者修改。
+遇到架构层面的问题找决策者 "${dm}" 讨论。`,
+      tester_dev: (dm) => `测试完成后：全部通过则 ROUTE 给决策者 "${dm}" 报告通过。发现 bug 则编写复现测试，ROUTE 给开发者修复。
+遇到测试环境问题找决策者 "${dm}" 协调。`,
+      designer_dev: (dm) => `设计完成后交给决策者 "${dm}" 审阅，通过后交给开发者实现。
+收到开发者的 UI 问题反馈时评估并调整设计方案。需求不明确找决策者 "${dm}" 确认。`,
+
       // video team
       scriptwriter: (dm) => `脚本完成后，建议 ROUTE 给决策者 "${dm}" 审核。
 收到修改意见后调整脚本重新提交。叙事方向不确定时找决策者确认。`,
@@ -361,6 +371,16 @@ Continuously monitor existing positions and proactively alert on anomalies.`,
 Execute stop-losses immediately when triggered and notify the decision maker. Report any execution difficulties immediately.`,
       strategist: () => '',
 
+      // dev team
+      developer: (dm) => `After code is complete, you must send two ROUTE blocks simultaneously to reviewer and tester (both required).
+Check with designer for UI/interaction questions. Check with decision maker "${dm}" for unclear requirements.`,
+      reviewer_dev: (dm) => `After review: score >= 9 passes, ROUTE to decision maker "${dm}" to report approval. Score < 9: send back to developer with issues.
+Discuss architecture-level concerns with decision maker "${dm}".`,
+      tester_dev: (dm) => `After testing: all pass, ROUTE to decision maker "${dm}" to report approval. Bug found: write reproduction test, ROUTE to developer for fixing.
+Coordinate test environment issues with decision maker "${dm}".`,
+      designer_dev: (dm) => `After design is complete, hand to decision maker "${dm}" for review, then to developer for implementation.
+Evaluate and adjust design based on developer UI feedback. Check with decision maker "${dm}" for unclear requirements.`,
+
       // video team
       scriptwriter: (dm) => `After completing the script, consider ROUTEing to the decision maker "${dm}" for review.
 Adjust and resubmit after receiving revision notes. Check with the decision maker when narrative direction is uncertain.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.51",
+  "version": "0.1.55",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/vcrew.js

@@ -0,0 +1,305 @@
+/**
+ * Virtual Crew — lightweight multi-role collaboration within a single conversation.
+ *
+ * Manages vcrewSessions (in-memory + persisted to disk) and builds the
+ * appendSystemPrompt that instructs Claude to role-play multiple characters.
+ */
+
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+
+const VCREW_INDEX_PATH = join(process.env.HOME, '.claude', 'vcrew-sessions.json');
+
+// In-memory map: conversationId -> { roles, teamType, language, projectDir, createdAt, userId, username }
+export const vcrewSessions = new Map();
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+
+export function saveVCrewIndex() {
+  const data = [];
+  for (const [id, session] of vcrewSessions) {
+    data.push({ id, ...session });
+  }
+  try {
+    writeFileSync(VCREW_INDEX_PATH, JSON.stringify(data, null, 2));
+  } catch (e) {
+    console.warn('[vcrew] Failed to save index:', e.message);
+  }
+}
+
+export function loadVCrewIndex() {
+  if (!existsSync(VCREW_INDEX_PATH)) return;
+  try {
+    const data = JSON.parse(readFileSync(VCREW_INDEX_PATH, 'utf-8'));
+    for (const entry of data) {
+      const { id, ...session } = entry;
+      vcrewSessions.set(id, session);
+    }
+    console.log(`[vcrew] Loaded ${vcrewSessions.size} sessions from index`);
+  } catch (e) {
+    console.warn('[vcrew] Failed to load index:', e.message);
+  }
+}
+
+export function removeVCrewSession(conversationId) {
+  vcrewSessions.delete(conversationId);
+  saveVCrewIndex();
+}
+
+// ---------------------------------------------------------------------------
+// Input validation
+// ---------------------------------------------------------------------------
+
+const ALLOWED_TEAM_TYPES = ['dev', 'writing', 'trading', 'video', 'custom'];
+const MAX_ROLE_NAME_LEN = 64;
+const MAX_DISPLAY_NAME_LEN = 128;
+const MAX_CLAUDE_MD_LEN = 4096;
+const MAX_ROLES = 10;
+
+/**
+ * Validate and sanitize vcrewConfig from the client.
+ * Returns { valid: true, config: sanitizedConfig } or { valid: false, error: string }.
+ *
+ * @param {*} config - raw vcrewConfig from client message
+ * @returns {{ valid: boolean, config?: object, error?: string }}
+ */
+export function validateVCrewConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return { valid: false, error: 'vcrewConfig must be an object' };
+  }
+
+  // teamType
+  const teamType = config.teamType;
+  if (typeof teamType !== 'string' || !ALLOWED_TEAM_TYPES.includes(teamType)) {
+    return { valid: false, error: `teamType must be one of: ${ALLOWED_TEAM_TYPES.join(', ')}` };
+  }
+
+  // language
+  const language = config.language;
+  if (language !== 'zh-CN' && language !== 'en') {
+    return { valid: false, error: 'language must be "zh-CN" or "en"' };
+  }
+
+  // roles
+  if (!Array.isArray(config.roles) || config.roles.length === 0) {
+    return { valid: false, error: 'roles must be a non-empty array' };
+  }
+  if (config.roles.length > MAX_ROLES) {
+    return { valid: false, error: `roles must have at most ${MAX_ROLES} entries` };
+  }
+
+  const sanitizedRoles = [];
+  const seenNames = new Set();
+
+  for (let i = 0; i < config.roles.length; i++) {
+    const r = config.roles[i];
+    if (!r || typeof r !== 'object') {
+      return { valid: false, error: `roles[${i}] must be an object` };
+    }
+
+    // name: required string, alphanumeric + hyphens/underscores
+    if (typeof r.name !== 'string' || r.name.length === 0 || r.name.length > MAX_ROLE_NAME_LEN) {
+      return { valid: false, error: `roles[${i}].name must be a non-empty string (max ${MAX_ROLE_NAME_LEN} chars)` };
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(r.name)) {
+      return { valid: false, error: `roles[${i}].name must contain only alphanumeric, hyphens, or underscores` };
+    }
+    if (seenNames.has(r.name)) {
+      return { valid: false, error: `roles[${i}].name "${r.name}" is duplicated` };
+    }
+    seenNames.add(r.name);
+
+    // displayName: required string
+    if (typeof r.displayName !== 'string' || r.displayName.length === 0 || r.displayName.length > MAX_DISPLAY_NAME_LEN) {
+      return { valid: false, error: `roles[${i}].displayName must be a non-empty string (max ${MAX_DISPLAY_NAME_LEN} chars)` };
+    }
+
+    sanitizedRoles.push({
+      name: r.name,
+      displayName: r.displayName.substring(0, MAX_DISPLAY_NAME_LEN),
+      icon: typeof r.icon === 'string' ? r.icon.substring(0, 8) : '',
+      description: typeof r.description === 'string' ? r.description.substring(0, 500) : '',
+      claudeMd: typeof r.claudeMd === 'string' ? r.claudeMd.substring(0, MAX_CLAUDE_MD_LEN) : '',
+    });
+  }
+
+  return {
+    valid: true,
+    config: {
+      roles: sanitizedRoles,
+      teamType,
+      language,
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// System prompt construction
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the appendSystemPrompt that tells Claude about the virtual crew roles
+ * and how to switch between them.
+ *
+ * @param {{ roles: Array, teamType: string, language: string }} config
+ * @returns {string}
+ */
+export function buildVCrewSystemPrompt(config) {
+  const { roles, teamType, language } = config;
+  const isZh = language === 'zh-CN';
+
+  // Build role list
+  const roleList = roles.map(r => {
+    const desc = r.claudeMd || r.description || '';
+    const icon = r.icon ? `${r.icon} ` : '';
+    return `### ${icon}${r.displayName} (${r.name})\n${desc}`;
+  }).join('\n\n');
+
+  // Build workflow
+  const workflow = getWorkflow(teamType, roles, isZh);
+
+  const prompt = isZh
+    ? buildZhPrompt(roleList, workflow)
+    : buildEnPrompt(roleList, workflow);
+
+  return prompt.trim();
+}
+
+function buildZhPrompt(roleList, workflow) {
+  return `
+# 多角色协作模式
+
+你正在以多角色协作方式完成任务。你将依次扮演不同角色，每个角色有独立的视角、人格和专业能力。
+
+## 可用角色
+
+${roleList}
+
+## 角色切换规则
+
+切换角色时，输出以下信号（必须独占一行，前后不能有其他内容）：
+
+---ROLE: {角色name}---
+
+切换后，你必须完全以该角色的视角和人格思考、说话和行动。不要混用其他角色的口吻。
+
+**重要**：
+- 第一条输出必须先切换到起始角色（通常是 PM）
+- 每次切换时先用 1-2 句话说明为什么要切换（作为上一个角色的收尾）
+- 切换后立即以新角色身份开始工作
+- 信号格式必须严格匹配：三个短横线 + ROLE: + 空格 + 角色name + 三个短横线
+
+## 工作流程
+
+${workflow}
+
+## 交接规范
+
+每次角色切换时，上一个角色必须留下清晰的交接信息：
+- 完成了什么
+- 未完成的部分（如有）
+- 对下一个角色的具体要求或注意事项
+
+## 输出格式
+
+- 代码修改使用工具（Read, Edit, Write 等），不要在聊天中贴大段代码
+- 每个角色专注做自己的事，不要代替其他角色
+- Review 和 Test 角色如果发现问题，必须切回 Dev 修复后再继续
+
+## 语言
+
+使用中文交流。代码注释可以用英文。
+`;
+}
+
+function buildEnPrompt(roleList, workflow) {
+  return `
+# Multi-Role Collaboration Mode
+
+You are working in multi-role collaboration mode. You will take on different roles sequentially, each with its own perspective, personality, and expertise.
+
+## Available Roles
+
+${roleList}
+
+## Role Switching Rules
+
+When switching roles, output the following signal (must be on its own line, nothing else before or after):
+
+---ROLE: {role_name}---
+
+After switching, you must fully think, speak, and act from that role's perspective and personality. Do not mix tones from other roles.
+
+**Important**:
+- Your first output must switch to the starting role (usually PM)
+- Before each switch, briefly explain why you're switching (as closure for the current role)
+- After switching, immediately begin working as the new role
+- Signal format must strictly match: three hyphens + ROLE: + space + role_name + three hyphens
+
+## Workflow
+
+${workflow}
+
+## Handoff Convention
+
+Each role switch must include clear handoff information from the previous role:
+- What was completed
+- What remains (if any)
+- Specific requirements or notes for the next role
+
+## Output Format
+
+- Use tools (Read, Edit, Write, etc.) for code changes, don't paste large code blocks in chat
+- Each role focuses on its own responsibility, don't do other roles' jobs
+- If Review or Test finds issues, must switch back to Dev to fix before continuing
+
+## Language
+
+Communicate in English. Code comments in English.
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Workflow generation per team type
+// ---------------------------------------------------------------------------
+
+function getWorkflow(teamType, roles, isZh) {
+  const roleNames = roles.map(r => r.name);
+
+  if (teamType === 'dev') {
+    return buildDevWorkflow(roleNames, isZh);
+  }
+
+  // Generic fallback for other team types
+  return isZh ? '按角色顺序依次完成任务。' : 'Complete tasks by following the role sequence.';
+}
+
+function buildDevWorkflow(roleNames, isZh) {
+  const hasPm = roleNames.includes('pm');
+  const hasDev = roleNames.includes('dev');
+  const hasReviewer = roleNames.includes('reviewer');
+  const hasTester = roleNames.includes('tester');
+  const hasDesigner = roleNames.includes('designer');
+
+  const steps = [];
+
+  if (isZh) {
+    if (hasPm) steps.push(`${steps.length + 1}. **PM** 分析需求，拆分任务，确定验收标准`);
+    if (hasDesigner) steps.push(`${steps.length + 1}. **设计师** 确认交互方案（如涉及 UI）`);
+    if (hasDev) steps.push(`${steps.length + 1}. **开发者** 实现代码（使用工具读写文件）`);
+    if (hasReviewer) steps.push(`${steps.length + 1}. **审查者** Code Review（不通过 → 返回开发者修复）`);
+    if (hasTester) steps.push(`${steps.length + 1}. **测试者** 运行测试 & 验证（有 bug → 返回开发者修复）`);
+    if (hasPm) steps.push(`${steps.length + 1}. **PM** 验收总结`);
+  } else {
+    if (hasPm) steps.push(`${steps.length + 1}. **PM** analyzes requirements, breaks down tasks, defines acceptance criteria`);
+    if (hasDesigner) steps.push(`${steps.length + 1}. **Designer** confirms interaction design (if UI involved)`);
+    if (hasDev) steps.push(`${steps.length + 1}. **Dev** implements code (using tools to read/write files)`);
+    if (hasReviewer) steps.push(`${steps.length + 1}. **Reviewer** code review (if fails → back to Dev)`);
+    if (hasTester) steps.push(`${steps.length + 1}. **Tester** runs tests & verifies (if bugs → back to Dev)`);
+    if (hasPm) steps.push(`${steps.length + 1}. **PM** acceptance & summary`);
+  }
+
+  return steps.join('\n');
+}