@yeaft/webchat-agent 0.1.76 → 0.1.78

package/cli.js

@@ -223,6 +223,7 @@ function upgradeWindows(latestVersion) {
 
   writeFileSync(batPath, batLines.join('\r\n'));
   const child = spawn('cmd.exe', ['/c', batPath], {
+    detached: true,
     stdio: 'ignore',
     windowsHide: true,
   });

package/connection/upgrade-worker-template.js

@@ -76,7 +76,7 @@ try {
   log('Temp dir: ' + tmpDir);
 
   const packOutput = execFileSync('npm', ['pack', PKG, '--pack-destination', tmpDir], {
-    shell: true, encoding: 'utf8', cwd: tmpDir, timeout: 120000
+    shell: process.platform === 'win32', encoding: 'utf8', cwd: tmpDir, timeout: 120000
   }).trim();
   const tgzName = packOutput.split('\n').pop().trim();
   const tgzPath = path.join(tmpDir, tgzName);
@@ -100,7 +100,7 @@ try {
   log('Installing dependencies...');
   try {
     execFileSync('npm', ['install', '--omit=dev'], {
-      shell: true, cwd: TARGET, encoding: 'utf8', timeout: 120000
+      shell: process.platform === 'win32', cwd: TARGET, encoding: 'utf8', timeout: 120000
     });
     log('Dependencies installed');
   } catch (depErr) {

package/connection/upgrade.js

@@ -46,7 +46,7 @@ export async function handleUpgradeAgent() {
     const pkgName = ctx.pkgName || '@yeaft/webchat-agent';
     // Check latest version (async to avoid blocking heartbeat)
     const latestVersion = await new Promise((resolve, reject) => {
-      execFile('npm', ['view', pkgName, 'version'], { stdio: 'pipe', shell: true }, (err, stdout) => {
+      execFile('npm', ['view', pkgName, 'version'], { stdio: 'pipe', shell: process.platform === 'win32' }, (err, stdout) => {
         if (err) reject(err); else resolve(stdout.toString().trim());
       });
     });
@@ -74,7 +74,7 @@ export async function handleUpgradeAgent() {
 
     // 判断全局安装 vs 局部安装
     const isGlobalInstall = await new Promise((resolve) => {
-      execFile('npm', ['prefix', '-g'], { shell: true }, (err, stdout) => {
+      execFile('npm', ['prefix', '-g'], { shell: process.platform === 'win32' }, (err, stdout) => {
         if (err) { resolve(false); return; }
         const globalPrefix = stdout.toString().trim().replace(/\\/g, '/');
         resolve(installDir === globalPrefix || installDir === globalPrefix + '/lib');
@@ -94,7 +94,7 @@ export async function handleUpgradeAgent() {
     const isPm2 = !!process.env.pm_id;
     if (isPm2) {
       try {
-        execFileSync('pm2', ['delete', PM2_APP_NAME], { shell: true, stdio: 'pipe' });
+        execFileSync('pm2', ['delete', PM2_APP_NAME], { shell: process.platform === 'win32', stdio: 'pipe' });
         console.log(`[Agent] PM2 app deleted to prevent auto-restart during upgrade`);
       } catch {
         console.log(`[Agent] PM2 delete skipped (app may not be registered)`);
@@ -201,8 +201,9 @@ function spawnWindowsUpgradeScript(pkgName, installDir, isGlobalInstall, latestV
 
   writeFileSync(batPath, batLines.join('\r\n'));
   const child = spawn('cmd.exe', ['/c', batPath], {
+    detached: true,
     stdio: 'ignore',
-    windowsHide: true
+    windowsHide: true,
   });
   child.unref();
   console.log(`[Agent] Spawned upgrade script (PID wait for ${pid}, pm2=${isPm2}, dir=${installDir}): ${batPath}`);

package/crew/control.js

@@ -66,6 +66,11 @@ export async function handleCrewControl(msg) {
 async function clearSingleRole(session, roleName) {
   const roleState = session.roleStates.get(roleName);
 
+  // P0-1: 清除该角色在 humanMessageQueue 中的待处理消息，防止幽灵 ROUTE 执行
+  if (session.humanMessageQueue.length > 0) {
+    session.humanMessageQueue = session.humanMessageQueue.filter(m => m.target !== roleName);
+  }
+
   if (roleState) {
     // 保存工作摘要到 task file（与 context_exceeded clear 一致）
     if (roleState.accumulatedText) {
@@ -73,9 +78,21 @@ async function clearSingleRole(session, roleName) {
         console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
     }
 
+    // P1-3: abort 并等待 query iterator 退出，避免 abort+dispatch 竞态
     if (roleState.abortController) {
       roleState.abortController.abort();
     }
+    // 等待 query 完成（iterator 会因 AbortError 退出）
+    if (roleState.query) {
+      try {
+        // Drain the iterator — it will throw AbortError and exit
+        // eslint-disable-next-line no-empty
+        for await (const _ of roleState.query) {}
+      } catch {
+        // Expected: AbortError or other cleanup errors
+      }
+    }
+
     roleState.query = null;
     roleState.inputStream = null;
     roleState.turnActive = false;
@@ -86,6 +103,10 @@ async function clearSingleRole(session, roleName) {
     roleState.lastDispatchFrom = null;
     roleState.lastDispatchTaskId = null;
     roleState.lastDispatchTaskTitle = null;
+    // P0-3: 重置 UI 相关状态，防止显示过时信息
+    roleState.currentTask = null;
+    roleState.currentTool = null;
+    roleState.lastTurnText = '';
   }
 
   await clearRoleSessionId(session.sharedDir, roleName);
@@ -168,12 +189,12 @@ async function resumeSession(session) {
     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);
+    // P1-5: 串行执行 pending routes，防止多个 route 指向同一角色时并发 dispatch
+    for (const { fromRole, route } of pending) {
+      try {
+        await executeRoute(session, fromRole, route);
+      } catch (err) {
+        console.warn(`[Crew] Pending route replay failed:`, err);
       }
     }
     return;
@@ -338,6 +359,9 @@ async function stopAll(session) {
  * 清空 session
  */
 async function clearSession(session) {
+  // P1-2: 先重置 _processingHumanQueue，防止后续消息处理被阻塞
+  session._processingHumanQueue = false;
+
   for (const [roleName, roleState] of session.roleStates) {
     if (roleState.abortController) {
       roleState.abortController.abort();
@@ -350,6 +374,7 @@ async function clearSession(session) {
     await clearRoleSessionId(session.sharedDir, roleName);
   }
 
+  // P1-1: humanMessageQueue 在这里清空，确保不会有幽灵消息在 clear 后被处理
   session.messageHistory = [];
   session.uiMessages = [];
   session.humanMessageQueue = [];

package/crew/human-interaction.js

@@ -86,10 +86,31 @@ export async function handleCrewHumanInput(msg) {
           const { createRoleQuery } = await import('./role-query.js');
           roleState = await createRoleQuery(session, target);
         }
-        roleState.inputStream.enqueue({
-          type: 'user',
-          message: { role: 'user', content: message }
-        });
+        // P1-4: 守卫 stream.enqueue
+        try {
+          if (roleState.inputStream && !roleState.inputStream.isDone) {
+            roleState.inputStream.enqueue({
+              type: 'user',
+              message: { role: 'user', content: message }
+            });
+          } else {
+            console.warn(`[Crew] Skill dispatch: stream closed for ${target}, recreating`);
+            const { createRoleQuery } = await import('./role-query.js');
+            roleState = await createRoleQuery(session, target);
+            roleState.inputStream.enqueue({
+              type: 'user',
+              message: { role: 'user', content: message }
+            });
+          }
+        } catch (enqueueErr) {
+          console.error(`[Crew] Skill dispatch enqueue failed for ${target}:`, enqueueErr.message);
+          const { createRoleQuery } = await import('./role-query.js');
+          roleState = await createRoleQuery(session, target);
+          roleState.inputStream.enqueue({
+            type: 'user',
+            message: { role: 'user', content: message }
+          });
+        }
         sendStatusUpdate(session);
         console.log(`[Crew] Skill command dispatched to ${target}: ${message}`);
         return;

package/crew/role-query.js

@@ -84,10 +84,48 @@ export function classifyRoleError(error) {
 // Role Query Management
 // =====================================================================
 
+// P1-6: Per-role mutex to prevent concurrent createRoleQuery calls creating orphan processes
+const _roleQueryLocks = new Map();
+
 /**
  * 为角色创建持久 query 实例
  */
 export async function createRoleQuery(session, roleName) {
+  const lockKey = `${session.id}:${roleName}`;
+
+  // P1-6: 如果该角色已有 pending 的 createRoleQuery，等待它完成
+  if (_roleQueryLocks.has(lockKey)) {
+    console.log(`[Crew] Waiting for existing createRoleQuery lock on ${roleName}`);
+    try {
+      await _roleQueryLocks.get(lockKey);
+    } catch {
+      // Previous attempt failed, proceed with new creation
+    }
+    // 锁释放后，检查是否已经有可用的 query
+    const existing = session.roleStates.get(roleName);
+    if (existing?.query && existing?.inputStream && !existing.inputStream.isDone) {
+      console.log(`[Crew] Reusing existing query for ${roleName} after lock release`);
+      return existing;
+    }
+  }
+
+  const promise = _createRoleQueryInner(session, roleName);
+  _roleQueryLocks.set(lockKey, promise);
+  try {
+    const result = await promise;
+    return result;
+  } finally {
+    // 只删除自己的 lock（如果后续调用覆盖了，不误删）
+    if (_roleQueryLocks.get(lockKey) === promise) {
+      _roleQueryLocks.delete(lockKey);
+    }
+  }
+}
+
+/**
+ * createRoleQuery 内部实现
+ */
+async function _createRoleQueryInner(session, roleName) {
   const role = session.roles.get(roleName);
   if (!role) throw new Error(`Role not found: ${roleName}`);
 

package/crew/routing.js

@@ -227,17 +227,48 @@ export async function dispatchToRole(session, roleName, content, fromSource, tas
     roleState = await createRoleQuery(session, roleName);
   }
 
-  // 发送
+  // P1-4: 守卫 stream.enqueue — stream 可能已被 abort 关闭
   roleState.lastDispatchContent = content;
   roleState.lastDispatchFrom = fromSource;
   roleState.lastDispatchTaskId = taskId || null;
   roleState.lastDispatchTaskTitle = taskTitle || null;
   roleState.turnActive = true;
   roleState.accumulatedText = '';
-  roleState.inputStream.enqueue({
-    type: 'user',
-    message: { role: 'user', content }
-  });
+  try {
+    if (roleState.inputStream && !roleState.inputStream.isDone) {
+      roleState.inputStream.enqueue({
+        type: 'user',
+        message: { role: 'user', content }
+      });
+    } else {
+      console.warn(`[Crew] Cannot enqueue to ${roleName}: stream closed or missing, recreating`);
+      roleState = await createRoleQuery(session, roleName);
+      roleState.lastDispatchContent = content;
+      roleState.lastDispatchFrom = fromSource;
+      roleState.lastDispatchTaskId = taskId || null;
+      roleState.lastDispatchTaskTitle = taskTitle || null;
+      roleState.turnActive = true;
+      roleState.accumulatedText = '';
+      roleState.inputStream.enqueue({
+        type: 'user',
+        message: { role: 'user', content }
+      });
+    }
+  } catch (enqueueErr) {
+    console.error(`[Crew] Failed to enqueue to ${roleName}:`, enqueueErr.message);
+    // Recreate query and retry once
+    roleState = await createRoleQuery(session, roleName);
+    roleState.lastDispatchContent = content;
+    roleState.lastDispatchFrom = fromSource;
+    roleState.lastDispatchTaskId = taskId || null;
+    roleState.lastDispatchTaskTitle = taskTitle || null;
+    roleState.turnActive = true;
+    roleState.accumulatedText = '';
+    roleState.inputStream.enqueue({
+      type: 'user',
+      message: { role: 'user', content }
+    });
+  }
 
   sendStatusUpdate(session);
   console.log(`[Crew] Dispatched to ${roleName} from ${fromSource}${taskId ? ` (task: ${taskId})` : ''}`);

package/package.json

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