agent.libx.js 0.93.28 → 0.93.30

package/cli/cli.ts

@@ -24,7 +24,7 @@ import { existsSync, readFileSync, appendFileSync, mkdirSync, writeFileSync, rea
 import { homedir, tmpdir } from 'node:os';
 import { grabClipboardImage } from './clipboard';
 import { join, resolve, basename, extname, dirname } from 'node:path';
-import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported } from 'ai.libx.js';
+import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions } from 'ai.libx.js';
 import {
   PermissionPolicy, loadCommands, expandCommand, loadSkills, forComponent, composeHooks, reflectOnRun,
   AgentOptions, exitSessionTool,
@@ -33,7 +33,7 @@ import {
 } from '../src/index';
 import { mountMcpServer, mountMcpServers, type MountedMcp, type McpServerConfig } from '../src/mcp.client';
 import { McpOAuth } from './mcpOAuth';
-import { buildAgent, summarizeCall, type CliOptions } from './core';
+import { buildAgent, summarizeCall, cursorProviderOptions, type CliOptions } from './core';
 import { DuplexAgent } from '../src/duplex';
 import { VoiceIO } from './voice';
 import { loadConfig, type AgentConfig } from './config';
@@ -95,7 +95,7 @@ interface Args {
   duplex: boolean; voiceModel?: string; thinkModel?: string | false; voice: boolean;
   cont: boolean; resume?: string; sessionId?: string; fork?: boolean; outputFormat: 'text' | 'json' | 'stream-json';
   allowedTools?: string[]; disallowedTools?: string[]; appendSystemPrompt?: string; addDirs?: string[];
-  print?: boolean; debug?: boolean;
+  print?: boolean; debug?: boolean; scratch?: boolean;
 }
 /** Parse a numeric flag, failing fast on a missing/NaN/negative value so a typo can't silently disable a kill-switch. */
 function numFlag(raw: string | undefined, flag: string): number {
@@ -141,6 +141,7 @@ export function parseArgs(argv: string[]): Args {
     else if (x === '--ask') a.ask = true;
     else if (x === '--yes' || x === '-y') a.yes = true;
     else if (x === '--vfs' || x === '--sandbox') a.vfs = true;
+    else if (x === '--scratch') a.scratch = true;
     else if (x === '--boddb') a.boddb = val(++i, x);
     else if (x === '--seed') a.seed = true;
     else if (x === '--shell') a.shell = true;
@@ -194,6 +195,7 @@ Flags:
   --no-stream          disable token streaming
                        (default: disk mode — full real filesystem access, like Claude Code)
   --vfs, --sandbox     sandbox mode: work over an in-memory copy of cwd — real disk is NEVER modified
+  --scratch            spill big web outputs to scratch files (kept out of context; peek via Grep/Ask)
   --boddb <dir>        database-backed workspace: files live in a persistent bod-db store at <dir>,
                        surviving across runs — real disk is NEVER modified (DB-native; add --seed below)
   --seed               with --boddb: hydrate the store from cwd on the first run (empty DB) only
@@ -314,14 +316,19 @@ function makeHost(format: 'text' | 'json' | 'stream-json' = 'text', opts?: { str
   const md = format === 'text' && useColor && opts?.stream ? new MarkdownStream({ bold, dim, cyan }, process.stdout.columns ?? 80) : null;
   if (md) process.on('SIGWINCH', () => md.resize(process.stdout.columns ?? 80)); // reflow streamed markdown on resize
   const flushText = () => { if (md && md.pending()) process.stdout.write(md.flush()); };
+  // `thinking_delta` streams to stderr WITHOUT a trailing newline (a continuous dimmed reasoning flow).
+  // Any other output that follows (the answer on stdout, a `· notice`, the next step header) must first
+  // close that open line — else it collides mid-word into the reasoning tail (`· step 2` → `step ya`).
+  let openReasonLine = false;
+  const closeReasonLine = () => { if (openReasonLine) { process.stderr.write('\n'); openReasonLine = false; } };
   return {
     flushText,
     notify(e) {
       spinner.stop(); // real output arriving → clear the spinner first
       if (e.kind === 'text_delta') {
         if (streamJson) process.stdout.write(JSON.stringify({ type: 'text', text: e.message }) + '\n');
-        else if (md) process.stdout.write(md.feed(e.message)); // line-buffered markdown render
-        else (cleanStdout ? process.stderr : process.stdout).write(e.message); // json keeps stdout clean → stderr
+        else if (md) { closeReasonLine(); process.stdout.write(md.feed(e.message)); } // line-buffered markdown render
+        else { if (!cleanStdout) closeReasonLine(); (cleanStdout ? process.stderr : process.stdout).write(e.message); } // json keeps stdout clean → stderr
         return;
       }
       // extended-thinking (reasoning-native models): a dimmed stderr flow in text mode; a typed event in
@@ -333,12 +340,17 @@ function makeHost(format: 'text' | 'json' | 'stream-json' = 'text', opts?: { str
           // stay in order — otherwise late-flushed markdown lands after the thinking it preceded.
           if (md && md.pending()) process.stdout.write(md.flush() + '\n');
           process.stderr.write(dim(e.message));
+          openReasonLine = true; // unterminated reasoning line — next output must close it
         }
         return;
       }
+      // Structural events (tool_use/tool_result/tool_result_image/turn_start) have dedicated renderers
+      // (displayHooks ⚙ chrome, the step header) — never dump their raw `kind` as a `· notice`, or the
+      // result preview gets sandwiched between junk `· tool_use`/`· tool_result` labels.
+      if (!('message' in e)) return;
+      closeReasonLine(); // close an open reasoning line so the notice starts fresh (not glued mid-word)
       if (md && md.pending()) process.stdout.write(md.flush() + '\n'); // finish the in-progress line before a notice
-      const notice = 'message' in e ? e.message : e.kind; // not every HostEvent variant carries `message`
-      err(dim(`  · ${notice}\n`)); // tool-activity notices stay on stderr (human chrome) for every format
+      err(dim(`  · ${e.message}\n`)); // tool-activity notices stay on stderr (human chrome) for every format
     },
     async confirm(prompt) {
       // arrow-select on a TTY; fall back to a typed y/N when piped (selectMenu → null)
@@ -697,6 +709,7 @@ function optsFor(args: Args, ai: ChatLike, cfg: Partial<AgentConfig> = {}, extra
     boddb: args.boddb,
     seed: args.seed,
     realShell: args.shell,  // undefined → core.ts defaults (on for disk, off for sandbox/boddb)
+    scratch: args.scratch,
     appendSystemPrompt: args.appendSystemPrompt,
     addDirs: args.addDirs,
     stream: args.stream,
@@ -1089,7 +1102,10 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   if (duplex) {
     // Workers must not stream into the voice channel — strip the host/stream seam (display hooks stay:
     // worker tool activity prints as dim stderr chrome). `signal` is per-task (duplex.ts owns it).
-    const { host: _host, stream: _stream, signal: _signal, ...wo } = agent.options;
+    // Drop providerOptions too: they're computed for the MAIN agent's model (e.g. cursor's cwd/cursorSession)
+    // and must never leak onto a worker whose model differs — DuplexAgent recomputes them per worker model
+    // via providerOptionsFor below. (A cursor cursorSession leaking onto an anthropic worker is a hard 400.)
+    const { host: _host, stream: _stream, signal: _signal, providerOptions: _po, ...wo } = agent.options;
     workerOptions = wo as AgentOptions;
     if (workerOptions.permissions)
       workerOptions.permissions = new PermissionPolicy({ ...workerOptions.permissions.options, host: undefined, ask: duplexAsk });
@@ -1184,6 +1200,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       ...((args.voiceModel ?? cfg.reflexModel) ? { reflexModel: resolveModelOrNewest((args.voiceModel ?? cfg.reflexModel)!) } : {}),
       actModel: agent.options.model,
       actOptions: workerOptions,
+      providerOptionsFor: (m) => cursorProviderOptions(m, cwd, cfg.mcpServers),
       ...((args.thinkModel ?? cfg.thinkModel) !== undefined ? { thinkModel: (args.thinkModel ?? cfg.thinkModel) === false ? false : resolveModelOrNewest(String(args.thinkModel ?? cfg.thinkModel)) } : {}),
       host,
       ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true, askRelay: true } : {}), // voice: progress asides + worker questions relayed through the conversation
@@ -1268,11 +1285,22 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     const img = grabClipboardImage(dir, String(Date.now()));
     return img ? { display: 'Image', ref: '@' + img.path, path: img.path } : null;
   };
-  // Ctrl-C: cancel the in-flight turn if one's running; otherwise clean up MCP children and exit.
+  // Hard teardown — used by the SIGINT path and the keypress force-quit escalation. Never let the
+  // user get trapped: even if a turn's abort() fails to unwind (wedged stream/tool), this exits.
+  const forceQuit = (code = 130) => {
+    try { voiceIO?.stop(); } catch { /* mic/player may already be down */ }
+    try { disposeCursorSessions(); } catch { /* reap warm cursor helpers, best-effort */ }
+    void closeMcp(mounted);
+    process.exit(code);
+  };
+  // Ctrl-C: cancel the in-flight turn if one's running; a second Ctrl-C while already cancelling
+  // (i.e. the abort didn't unwind) force-quits. No active turn → clean up MCP children and exit.
   process.on('SIGINT', () => {
-    if (activeTurn) { activeTurn.abort(); voiceIO?.interrupt(); return; }
-    voiceIO?.stop(); // kill mic/player children — they outlive the process otherwise
-    void closeMcp(mounted); process.exit(130);
+    if (activeTurn) {
+      if (aborting) { err(red('\n  ⏻ force-quit\n')); forceQuit(); return; } // already cancelling → hard escape
+      activeTurn.abort(); voiceIO?.interrupt(); return;
+    }
+    forceQuit();
   });
   installCancelGuards(mounted);
   const store = new SessionStore(cwd);
@@ -1739,7 +1767,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     commands: { desc: 'pick a custom slash command to run (./.agent/commands)', run: () => pickAndRun('command') },
     skills: { desc: 'pick a skill to run (./.agent/skills)', run: () => pickAndRun('skill') },
     mcp: {
-      desc: 'manage MCP servers — /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [resources [name]]',
+      desc: 'manage MCP servers — /mcp [add <name> <cmd|url>] [login <name>] [remove <name>] [tools [name]] [resources [name]]',
       run: async (a) => {
         const sub = a[0]?.toLowerCase();
         if (sub === 'login') {
@@ -1783,6 +1811,16 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           err(dim(`  removed "${name}"\n`));
           return;
         }
+        if (sub === 'tools') {
+          const filter = a[1];
+          const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
+          if (!targets.length) { err(dim(`  (no ${filter ? `MCP server "${filter}"` : 'MCP servers'} found)\n`)); return; }
+          for (const m of targets) {
+            err(`  ${cyan(m.name)} ${dim(`(${m.tools.length} tools)`)}\n`);
+            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, '')}${t.description ? ' — ' + t.description.split('\n')[0] : ''}\n`));
+          }
+          return;
+        }
         if (sub === 'resources') {
           const filter = a[1];
           const targets = filter ? mounted.filter((m) => m.name === filter) : mounted;
@@ -1802,14 +1840,15 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           if (!mounted.length) { err(dim('  (no MCP servers mounted)\n')); return; }
           for (const m of mounted) {
             const ver = m.serverInfo?.name ? dim(` · ${m.serverInfo.name}${m.serverInfo.version ? ' v' + m.serverInfo.version : ''}`) : '';
-            err(`  ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}\n`);
-            for (const t of m.tools) err(dim(`     - ${t.name.replace(`mcp__${m.name}__`, '')}${t.description ? ' — ' + t.description.split('\n')[0] : ''}\n`));
+            err(`  ${green('✓')} ${cyan(m.name)}${ver} ${dim(`(${m.tools.length} tools)`)}\n`);
           }
+          err(dim('  /mcp tools [name] to list tools · /mcp resources [name] for resources\n'));
         };
         const items: SelectItem[] = [
           { label: 'list', value: 'list', desc: `show mounted servers (${mounted.length})` },
           { label: 'add', value: 'add', desc: 'mount a new MCP server' },
           ...(mounted.length ? [
+            { label: 'tools', value: 'tools', desc: 'list a server\'s tools' },
             { label: 'remove', value: 'remove', desc: 'unmount an MCP server' },
             { label: 'resources', value: 'resources', desc: 'list server resources' },
           ] : []),
@@ -1831,12 +1870,12 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
           const rv = await selectMenu(process.stderr, { title: 'remove server', items: mounted.map((m) => ({ label: m.name, value: m.name })) });
           if (!rv) return;
           a = ['remove', rv];
-        } else if (picked === 'resources') {
-          if (mounted.length === 1) { a = ['resources', mounted[0].name]; }
+        } else if (picked === 'tools' || picked === 'resources') {
+          if (mounted.length === 1) { a = [picked, mounted[0].name]; }
           else {
-            const rv = await selectMenu(process.stderr, { title: 'server resources', items: [{ label: '(all)', value: '' }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
+            const rv = await selectMenu(process.stderr, { title: `server ${picked}`, items: [{ label: '(all)', value: '' }, ...mounted.map((m) => ({ label: m.name, value: m.name }))] });
             if (rv === null) return;
-            a = rv ? ['resources', rv] : ['resources'];
+            a = rv ? [picked, rv] : [picked];
           }
         }
         // fall through to re-run with the assembled args
@@ -1943,8 +1982,16 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       const cancel = k === 'escape' || (key?.ctrl && k === 'c');
       if (cancel) {
         if (stashBuf) { stashBuf = ''; err('\r\x1b[K'); return; } // first Esc clears the stash line
-        if (!aborting) { aborting = true; activeTurn.abort(); voiceIO?.interrupt(); err(yellow('\n  ⎋ cancelling…\n')); }
-        else if (k === 'escape' && !pendingRewind) { pendingRewind = true; err(dim('  ⎋⎋ jumping back to edit…\n')); }
+        if (!aborting) {
+          aborting = true; activeTurn.abort(); voiceIO?.interrupt();
+          err(yellow('\n  ⎋ cancelling…') + dim(' (Ctrl-C again to force-quit)\n'));
+          // Watchdog: if the turn hasn't unwound shortly, the abort is wedged — surface the escape hatch.
+          setTimeout(() => {
+            if (activeTurn) err(red('  ⚠ still cancelling — press Ctrl-C to force-quit\n'));
+          }, 4000).unref?.();
+        } else if (key?.ctrl && k === 'c') {
+          err(red('\n  ⏻ force-quit\n')); forceQuit(); // already cancelling + another Ctrl-C → never trapped
+        } else if (k === 'escape' && !pendingRewind) { pendingRewind = true; err(dim('  ⎋⎋ jumping back to edit…\n')); }
         return;
       }
       // Stash input: type ahead while the turn runs
@@ -2183,6 +2230,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         // (voice children / sockets / MCP handles can keep the process alive otherwise).
         voiceIO?.stop();
         releaseStdin();
+        disposeCursorSessions();
         await closeMcp(mounted);
         process.exit(130);
       }
@@ -2191,6 +2239,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     }
   }
   releaseStdin();
+  disposeCursorSessions(); // reap any warm cursor helper (its stdout pipe would otherwise keep the loop alive → hang on exit)
   await closeMcp(mounted);
 }
 

package/dist/cli.d.ts

@@ -89,6 +89,7 @@ interface Args {
     addDirs?: string[];
     print?: boolean;
     debug?: boolean;
+    scratch?: boolean;
 }
 declare function parseArgs(argv: string[]): Args;
 /** Render a resumed conversation (like CC) so the user sees the context they're continuing: user