@yeaft/webchat-agent 1.0.338 → 1.0.340

package/index.js

@@ -14,7 +14,12 @@ import { getDefaultAgentName, getDefaultYeaftDir, resolveRuntimeIdentity, getCon
 import { loadNodePty } from './terminal.js';
 import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
-import { ensureManagedCliTools, summarizeManagedCliResults } from './yeaft/managed-cli.js';
+import {
+  ensureManagedCliTools,
+  prepareManagedCliToolEnvironment,
+  runAfterManagedCliRuntimeCleanup,
+  summarizeManagedCliResults,
+} from './yeaft/managed-cli.js';
 
 const execAsync = promisify(exec);
 
@@ -310,30 +315,32 @@ async function ensureYeaftSkills() {
 }
 
 // 优雅退出
-async function cleanup() {
-  // 清理所有终端
-  for (const [, term] of ctx.terminals) {
-    if (term.pty) {
-      try { term.pty.kill(); } catch {}
+function cleanup() {
+  return runAfterManagedCliRuntimeCleanup(async () => {
+    // 清理所有终端
+    for (const [, term] of ctx.terminals) {
+      if (term.pty) {
+        try { term.pty.kill(); } catch {}
+      }
+      if (term.timer) clearTimeout(term.timer);
     }
-    if (term.timer) clearTimeout(term.timer);
-  }
-  ctx.terminals.clear();
+    ctx.terminals.clear();
 
-  for (const [, state] of ctx.conversations) {
-    if (state.abortController) {
-      state.abortController.abort();
-    }
-    if (state.inputStream) {
-      state.inputStream.done();
+    for (const [, state] of ctx.conversations) {
+      if (state.abortController) {
+        state.abortController.abort();
+      }
+      if (state.inputStream) {
+        state.inputStream.done();
+      }
     }
-  }
-  ctx.conversations.clear();
-  try {
-    const { shutdownWorkCenter } = await import('./yeaft/work-center/bridge.js');
-    await shutdownWorkCenter();
-  } catch {}
-  if (ctx.ws) ctx.ws.close();
+    ctx.conversations.clear();
+    try {
+      const { shutdownWorkCenter } = await import('./yeaft/work-center/bridge.js');
+      await shutdownWorkCenter();
+    } catch {}
+    if (ctx.ws) ctx.ws.close();
+  });
 }
 
 process.on('SIGINT', async () => {
@@ -362,6 +369,16 @@ process.on('SIGTERM', async () => {
     });
   }
   ctx.managedCliReady = managedCliReady;
+  try {
+    const rgEnvironment = await prepareManagedCliToolEnvironment(managedCliReady, 'rg', {
+      yeaftDir: YEAFT_DIR,
+    });
+    if (rgEnvironment.activated) {
+      console.log(`[Startup] managed rg available to child processes: ${rgEnvironment.command}`);
+    }
+  } catch (error) {
+    console.warn(`[Startup] managed rg environment setup failed; using built-in fallback: ${error?.message || error}`);
+  }
   ctx.agentCapabilities = await detectCapabilities();
   // Prime the models.dev community catalog so the Yeaft engine's *synchronous*
   // hot path (engine.js / config.js / cli.js all read context-window inline)

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.338"}
+{"version":"1.0.340"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.338",
+  "version": "1.0.340",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/cli.js

@@ -40,7 +40,12 @@ import { loadSessionConfig, resolveSessionConfig } from './sessions/session-conf
 import { validateSessionId } from './sessions/ids.js';
 import { createJsonlWriter, JsonlInput, runStreamTurn, runStreamSessionTurn } from './stdio-protocol.js';
 import { createCliSessionRunner } from './cli-session-runner.js';
-import { ensureManagedCliTools, summarizeManagedCliResults } from './managed-cli.js';
+import {
+  cleanupManagedCliRuntimePaths,
+  ensureManagedCliTools,
+  prepareManagedCliToolEnvironment,
+  summarizeManagedCliResults,
+} from './managed-cli.js';
 
 // ─── Argument parsing ──────────────────────────────────────────
 
@@ -1033,6 +1038,26 @@ async function runOnce(config, args) {
 
 // ─── Main ──────────────────────────────────────────────────────
 
+function installManagedCliSignalCleanup() {
+  if (process.platform === 'win32') return () => {};
+  const signals = ['SIGINT', 'SIGTERM'];
+  const handlers = new Map();
+  const dispose = () => {
+    for (const [signal, handler] of handlers) process.off(signal, handler);
+    handlers.clear();
+  };
+  for (const signal of signals) {
+    const handler = () => {
+      cleanupManagedCliRuntimePaths();
+      dispose();
+      process.kill(process.pid, signal);
+    };
+    handlers.set(signal, handler);
+    process.once(signal, handler);
+  }
+  return dispose;
+}
+
 async function main() {
   const args = parseArgs(process.argv);
 
@@ -1071,7 +1096,7 @@ async function main() {
     return;
   }
 
-  const prepareManagedCli = () => {
+  const prepareManagedCli = async () => {
     args.managedCliReady = ensureManagedCliTools({ yeaftDir: config.dir });
     args.managedCliReady.then(results => {
       if (results.some(result => result.status === 'installed')) {
@@ -1080,11 +1105,18 @@ async function main() {
     }).catch(error => {
       console.error(`[Yeaft] managed CLI setup failed; using built-in fallbacks: ${error?.message || error}`);
     });
+    try {
+      await prepareManagedCliToolEnvironment(args.managedCliReady, 'rg', {
+        yeaftDir: config.dir,
+      });
+    } catch (error) {
+      console.error(`[Yeaft] managed rg environment setup failed; using built-in fallback: ${error?.message || error}`);
+    }
   };
 
   // Handle interactive mode
   if (args.interactive) {
-    prepareManagedCli();
+    await prepareManagedCli();
     await runREPL(config, args);
     return;
   }
@@ -1096,7 +1128,7 @@ async function main() {
     if (!args.prompt && args.inputFormat !== 'stream-json' && process.stdin.isTTY) {
       throw new Error('stream-json output requires a prompt, piped stdin, or --input-format stream-json');
     }
-    prepareManagedCli();
+    await prepareManagedCli();
     await runStreamJson(config, args);
     return;
   }
@@ -1106,7 +1138,7 @@ async function main() {
 
   // Handle prompt (from args or stdin)
   if (args.prompt) {
-    prepareManagedCli();
+    await prepareManagedCli();
     await runOnce(config, args);
     return;
   }
@@ -1119,7 +1151,7 @@ async function main() {
     }
     args.prompt = input.trim();
     if (args.prompt) {
-      prepareManagedCli();
+      await prepareManagedCli();
       await runOnce(config, args);
       return;
     }
@@ -1159,8 +1191,14 @@ async function main() {
 
 const isDirectRun = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (isDirectRun) {
+  const disposeSignalCleanup = installManagedCliSignalCleanup();
+  const cleanupManagedCli = () => {
+    disposeSignalCleanup();
+    cleanupManagedCliRuntimePaths();
+  };
   main().catch(err => {
     console.error(err);
+    cleanupManagedCli();
     process.exit(1);
-  });
+  }).finally(cleanupManagedCli);
 }

package/yeaft/engine.js

@@ -3437,24 +3437,28 @@ export class Engine {
 
       // If new user input was appended while this loop was streaming and
       // there are no tools to force another loop, splice it now and continue
-      // instead of ending the thread. This preserves token streaming and
-      // still only mutates messages at a clean loop boundary.
-      const appendedAfterAssistant = this.#drainPendingUserMessages(drainPendingUserMessages);
-      if (appendedAfterAssistant.length > 0) {
-        for (const item of appendedAfterAssistant) {
-          this.#persistAppendedUserMessage(item, runtimeSessionId);
-          conversationMessages.push({ role: 'user', content: item.content });
-          yield {
-            type: 'user_append',
-            turnId: queryTurnId,
-            loopNumber: turnNumber,
-            threadId,
-            preview: String(item.preview || '').slice(0, 200),
-            internal: Boolean(item.internal),
-          };
+      // instead of ending the thread. A tool response must execute first: an
+      // append between assistant(toolCalls) and its tool results would break
+      // the provider protocol and discard the entire tool batch. The regular
+      // pre-stream drain on the next iteration appends input after those results.
+      if (toolCalls.length === 0) {
+        const appendedAfterAssistant = this.#drainPendingUserMessages(drainPendingUserMessages);
+        if (appendedAfterAssistant.length > 0) {
+          for (const item of appendedAfterAssistant) {
+            this.#persistAppendedUserMessage(item, runtimeSessionId);
+            conversationMessages.push({ role: 'user', content: item.content });
+            yield {
+              type: 'user_append',
+              turnId: queryTurnId,
+              loopNumber: turnNumber,
+              threadId,
+              preview: String(item.preview || '').slice(0, 200),
+              internal: Boolean(item.internal),
+            };
+          }
+          yield { type: 'turn_end', turnNumber, stopReason: 'user_append_continue', threadId };
+          continue;
         }
-        yield { type: 'turn_end', turnNumber, stopReason: 'user_append_continue', threadId };
-        continue;
       }
 
       // If no tool calls, we're done — UNLESS we still own a pending

package/yeaft/managed-cli.js

@@ -3,10 +3,12 @@ import { spawnSync } from 'node:child_process';
 import {
   accessSync,
   chmodSync,
+  copyFileSync,
   constants,
   existsSync,
   lstatSync,
   mkdirSync,
+  mkdtempSync,
   readFileSync,
   realpathSync,
   renameSync,
@@ -15,7 +17,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { basename, delimiter, dirname, join, resolve } from 'node:path';
 import { gunzipSync, inflateRawSync } from 'node:zlib';
 
@@ -28,6 +30,8 @@ const LOCK_STALE_MS = 2 * 60 * 1000;
 const LOCK_WAIT_MS = 15_000;
 const STATE_FILE = 'managed-cli.json';
 const installFlights = new Map();
+const runtimePathDirectories = new Set();
+let runtimePathCleanupRegistered = false;
 
 const TOOL_SPECS = Object.freeze({
   rg: {
@@ -78,8 +82,11 @@ export function managedCliBinDir(yeaftDir = DEFAULT_ROOT) {
   return join(resolve(yeaftDir), 'bin');
 }
 
-export function prependManagedCliBinToPath(yeaftDir = DEFAULT_ROOT, env = process.env, platform = process.platform) {
-  const binDir = managedCliBinDir(yeaftDir);
+function prependDirectoryToPath(
+  binDir,
+  env = process.env,
+  platform = process.platform,
+) {
   const current = typeof env.PATH === 'string'
     ? env.PATH
     : (typeof env.Path === 'string' ? env.Path : '');
@@ -93,6 +100,10 @@ export function prependManagedCliBinToPath(yeaftDir = DEFAULT_ROOT, env = proces
   return binDir;
 }
 
+export function prependManagedCliBinToPath(yeaftDir = DEFAULT_ROOT, env = process.env, platform = process.platform) {
+  return prependDirectoryToPath(managedCliBinDir(yeaftDir), env, platform);
+}
+
 function canExecute(path, platform) {
   try {
     accessSync(path, platform === 'win32' ? constants.F_OK : constants.X_OK);
@@ -155,10 +166,12 @@ function inspectManagedBinary(name, { yeaftDir, platform, arch }) {
     return { path, exists: true, valid: false };
   }
   try {
+    const binarySha256 = hashFile(path);
     return {
       path,
       exists: true,
-      valid: hashFile(path) === installation.binarySha256,
+      valid: binarySha256 === installation.binarySha256,
+      binarySha256,
     };
   } catch {
     return { path, exists: true, valid: false };
@@ -608,6 +621,91 @@ export function managedCliToolReady(ready, name) {
   return ready?.toolReady?.[name] || ready || Promise.resolve([]);
 }
 
+function removeRuntimePathDirectory(path) {
+  try { chmodSync(path, 0o700); } catch {}
+  try { rmSync(path, { recursive: true, force: true }); } catch {}
+  if (!existsSync(path)) runtimePathDirectories.delete(path);
+}
+
+export function cleanupManagedCliRuntimePaths() {
+  for (const directory of [...runtimePathDirectories]) {
+    removeRuntimePathDirectory(directory);
+  }
+}
+
+/**
+ * Run shutdown work only after managed CLI runtime paths are synchronously
+ * cleaned. The returned task may remain pending without delaying that cleanup.
+ */
+export function runAfterManagedCliRuntimeCleanup(task) {
+  cleanupManagedCliRuntimePaths();
+  return task();
+}
+
+function registerRuntimePathDirectory(path) {
+  runtimePathDirectories.add(path);
+  if (runtimePathCleanupRegistered) return;
+  runtimePathCleanupRegistered = true;
+  process.once('exit', cleanupManagedCliRuntimePaths);
+}
+
+function createIsolatedManagedCommand(name, managed, platform) {
+  const binDir = mkdtempSync(join(tmpdir(), 'yeaft-managed-cli-'));
+  const command = join(binDir, executableName(name, platform));
+  const temporary = `${command}.tmp`;
+  try {
+    copyFileSync(managed.path, temporary, constants.COPYFILE_EXCL);
+    if (platform !== 'win32') chmodSync(temporary, 0o500);
+    if (hashFile(temporary) !== managed.binarySha256) {
+      throw new Error(`managed ${name} changed while preparing its runtime command`);
+    }
+    renameSync(temporary, command);
+    const verification = spawnSync(command, ['--version'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      windowsHide: true,
+    });
+    if (verification.error || verification.status !== 0
+      || !versionOutputMatches(name, TOOL_SPECS[name].version, verification.stdout)) {
+      throw new Error(`isolated managed ${name} failed its version check`);
+    }
+    if (platform !== 'win32') chmodSync(binDir, 0o500);
+    registerRuntimePathDirectory(binDir);
+    return { binDir, command };
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    removeRuntimePathDirectory(binDir);
+    throw error;
+  }
+}
+
+/**
+ * Wait for one managed command and expose it to child processes through an
+ * isolated PATH directory. The directory contains only the checksum-verified
+ * command, so unrelated files in the shared managed bin directory stay hidden.
+ */
+export async function prepareManagedCliToolEnvironment(
+  ready,
+  name,
+  options = {},
+) {
+  const yeaftDir = resolve(options.yeaftDir || DEFAULT_ROOT);
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const env = options.env || process.env;
+  await managedCliToolReady(ready, name);
+
+  const managed = inspectManagedBinary(name, { yeaftDir, platform, arch });
+  if (!managed.valid) {
+    const command = resolveExternalCommand(name, { yeaftDir, platform, env });
+    return { name, activated: false, command };
+  }
+
+  const isolated = createIsolatedManagedCommand(name, managed, platform);
+  prependDirectoryToPath(isolated.binDir, env, platform);
+  return { name, activated: true, ...isolated };
+}
+
 export function summarizeManagedCliResults(results) {
   return (results || []).map(result => {
     const detail = result.path || result.reason || `${result.platform || ''}-${result.arch || ''}`;