agent-sh 0.14.0 → 0.14.2

package/dist/cli/install.js

@@ -75,6 +75,84 @@ function readPackageJson(target) {
         return null;
     return JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
 }
+function hostAgentShVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function satisfies(version, spec) {
+    if (spec === version || spec === "*" || spec === "latest")
+        return true;
+    const [vMaj, vMin, vPatch] = version.split(/[.-]/, 3).map(Number);
+    if ([vMaj, vMin, vPatch].some(Number.isNaN))
+        return true;
+    const m = spec.match(/^([\^~]?)(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return true;
+    const op = m[1];
+    const sMaj = Number(m[2]);
+    const sMin = Number(m[3]);
+    const sPatch = Number(m[4]);
+    if (op === "")
+        return vMaj === sMaj && vMin === sMin && vPatch === sPatch;
+    if (op === "~")
+        return vMaj === sMaj && vMin === sMin && vPatch >= sPatch;
+    // ^x.y.z: zero-major treats minor as the breaking boundary (npm rule).
+    if (sMaj > 0)
+        return vMaj === sMaj && (vMin > sMin || (vMin === sMin && vPatch >= sPatch));
+    if (sMin > 0)
+        return vMaj === 0 && vMin === sMin && vPatch >= sPatch;
+    return vMaj === 0 && vMin === 0 && vPatch === sPatch;
+}
+/** Warn when the extension's `agent-sh` pin can't admit the host version;
+ *  only rewrite when --sync-deps is set. */
+function syncAgentShVersion(target, syncDeps) {
+    const hostVersion = hostAgentShVersion();
+    if (!hostVersion)
+        return;
+    // Prerelease hosts aren't on npm; rewriting would leave npm install unable to resolve.
+    if (hostVersion.includes("-"))
+        return;
+    const pkgJson = path.join(target, "package.json");
+    if (!fs.existsSync(pkgJson))
+        return;
+    const raw = fs.readFileSync(pkgJson, "utf-8");
+    const pkg = JSON.parse(raw);
+    const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+    const name = path.basename(target);
+    let changed = false;
+    let warned = false;
+    for (const section of sections) {
+        const deps = pkg[section];
+        if (!deps || typeof deps !== "object")
+            continue;
+        const d = deps;
+        const current = d["agent-sh"];
+        if (typeof current !== "string")
+            continue;
+        if (current.startsWith("file:"))
+            continue;
+        if (satisfies(hostVersion, current))
+            continue;
+        if (syncDeps) {
+            console.log(`agent-sh: rewriting ${name} agent-sh ${current} -> ${hostVersion}.`);
+            d["agent-sh"] = hostVersion;
+            changed = true;
+        }
+        else if (!warned) {
+            console.warn(`agent-sh: ${name} pins agent-sh ${current}, which doesn't admit host ${hostVersion}. ` +
+                `npm install will land an older agent-sh inside the extension and drift from the running host. ` +
+                `Re-run with --sync-deps to rewrite the pin to ${hostVersion}, or update the bridge's source pin.`);
+            warned = true;
+        }
+    }
+    if (changed)
+        fs.writeFileSync(pkgJson, `${JSON.stringify(pkg, null, 2)}\n`);
+}
 /** Relative `file:` deps in bundled extensions (e.g. `"agent-sh": "file:../../.."`)
  *  point at the wrong location after the source is copied into ~/.agent-sh/extensions/.
  *  Resolve them against the original source dir so npm install in the target succeeds. */
@@ -165,7 +243,7 @@ function linkBins(target, pkg) {
 }
 export async function runInstall(spec, opts = {}) {
     if (!spec) {
-        console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force]\n\n" +
+        console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force] [--sync-deps]\n\n" +
             "Bundled extensions:\n" +
             listBundled()
                 .map((n) => `  ${n}`)
@@ -191,9 +269,15 @@ export async function runInstall(spec, opts = {}) {
     }
     let linkedBins = [];
     if (resolved.isDirectory) {
-        fs.cpSync(resolved.sourcePath, target, { recursive: true });
+        fs.cpSync(resolved.sourcePath, target, {
+            recursive: true,
+            // Skip source node_modules: maybeNpmInstall short-circuits on
+            // existing node_modules, silently leaving the bridge's deps stale.
+            filter: (src) => path.basename(src) !== "node_modules",
+        });
         try {
             rewriteFileDeps(target, resolved.sourcePath);
+            syncAgentShVersion(target, opts.syncDeps ?? false);
             const pkg = readPackageJson(target);
             if (pkg) {
                 maybeNpmInstall(target, pkg);

package/dist/cli/subcommands.js

@@ -3,7 +3,10 @@ import { runInstall, runUninstall, runList } from "./install.js";
 import { runAuth } from "./auth/cli.js";
 const SUBCOMMANDS = {
     init: (args) => runInit({ force: args.includes("--force") }),
-    install: (args) => runInstall(args[0] ?? "", { force: args.includes("--force") }),
+    install: (args) => runInstall(args[0] ?? "", {
+        force: args.includes("--force"),
+        syncDeps: args.includes("--sync-deps"),
+    }),
     uninstall: (args) => runUninstall(args[0] ?? ""),
     list: () => runList(),
     auth: (args) => runAuth(args),

package/dist/core/index.d.ts

@@ -17,7 +17,7 @@ export type { AgentContext, AgentConfig, AgentSurface, AgentConfigSurface, Agent
 export type { ShellContext, ShellConfig, ShellSurface, ShellConfigSurface, ExtensionContext, RemoteSession, RemoteSessionOptions, RenderSurface, InputModeConfig, TerminalSession, BlockTransformOptions, FencedBlockTransformOptions, AppConfig } from "../shell/host-types.js";
 export { palette, setPalette, resetPalette } from "../utils/palette.js";
 export type { ColorPalette } from "../utils/palette.js";
-export type { AgentBackend, ToolDefinition } from "../agent/types.js";
+export type { AgentBackend, ToolDefinition, ImageContent } from "../agent/types.js";
 export { runSubagent, type SubagentOptions } from "../agent/subagent.js";
 export { LlmClient } from "../agent/llm-client.js";
 export { HistoryFile, InMemoryHistory, NoopHistory, type HistoryAdapter } from "../agent/history-file.js";

package/dist/core/settings.d.ts

@@ -13,6 +13,8 @@ export interface ModelCapabilityConfig {
     maxTokens?: number;
     /** Echo reasoning_content back on assistant turns. Required by DeepSeek. */
     echoReasoning?: boolean;
+    /** Content modalities the model supports (e.g. ["text", "image"]). */
+    modalities?: ("text" | "image")[];
 }
 /** Provider profile — a named LLM configuration. */
 export interface ProviderConfig {
@@ -163,6 +165,7 @@ export interface ResolvedProvider {
         contextWindow?: number;
         maxTokens?: number;
         echoReasoning?: boolean;
+        modalities?: ("text" | "image")[];
     }>;
     /** Borrow another registered provider's reasoning request shape by id. */
     reasoningShape?: string;

package/dist/core/settings.js

@@ -150,8 +150,8 @@ export function resolveProvider(name) {
         }
         else {
             modelIds.push(m.id);
-            if (m.reasoning !== undefined || m.contextWindow !== undefined || m.maxTokens !== undefined || m.echoReasoning !== undefined) {
-                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning });
+            if (m.reasoning !== undefined || m.contextWindow !== undefined || m.maxTokens !== undefined || m.echoReasoning !== undefined || m.modalities !== undefined) {
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow, maxTokens: m.maxTokens, echoReasoning: m.echoReasoning, modalities: m.modalities });
             }
         }
     }

package/dist/shell/index.d.ts

@@ -5,6 +5,7 @@
  */
 import "./events.js";
 import type { ExtensionContext } from "./host-types.js";
+import { type Terminal } from "./terminal.js";
 export interface ShellActivateOptions {
     cols: number;
     rows: number;
@@ -16,6 +17,11 @@ export interface ShellActivateOptions {
         info: string;
         model?: string;
     };
+    /**
+     * Host-side I/O endpoint. Defaults to processTerminal() so the CLI
+     * works unchanged; headless callers (web hubs, tests) supply their own.
+     */
+    terminal?: Terminal;
 }
 export interface ShellHandle {
     /** Terminate the PTY. */

package/dist/shell/index.js

@@ -5,12 +5,13 @@
  */
 import "./events.js"; // augments BusEvents with shell-owned events
 import { Shell } from "./shell.js";
-import { DefaultCompositor, StdoutSurface } from "../utils/compositor.js";
+import { DefaultCompositor } from "../utils/compositor.js";
 import { TerminalBuffer } from "../utils/terminal-buffer.js";
 import { setPalette } from "../utils/palette.js";
 import * as streamTransform from "../utils/stream-transform.js";
 import activateShellContext from "./shell-context.js";
 import activateTuiRenderer from "./tui-renderer.js";
+import { processTerminal, surfaceFromTerminal } from "./terminal.js";
 /**
  * Register shell-owned handlers extensions can `ctx.call`, and attach
  * the shell surface to ctx. Must run before `loadExtensions` so user
@@ -77,10 +78,11 @@ export function registerShellHandlers(ctx) {
  * `src/cli/index.ts`) uses to drive lifecycle from process-level events.
  */
 export function activateShell(ctx, opts) {
-    const stdoutSurface = new StdoutSurface();
-    ctx.shell.compositor.setDefault("agent", stdoutSurface);
-    ctx.shell.compositor.setDefault("query", stdoutSurface);
-    ctx.shell.compositor.setDefault("status", stdoutSurface);
+    const terminal = opts.terminal ?? processTerminal();
+    const surface = surfaceFromTerminal(terminal);
+    ctx.shell.compositor.setDefault("agent", surface);
+    ctx.shell.compositor.setDefault("query", surface);
+    ctx.shell.compositor.setDefault("status", surface);
     const shell = new Shell({
         bus: ctx.bus,
         handlers: { define: ctx.define, call: ctx.call },
@@ -90,13 +92,11 @@ export function activateShell(ctx, opts) {
         cwd: opts.cwd,
         instanceId: ctx.instanceId,
         onShowAgentInfo: opts.onShowAgentInfo,
+        terminal,
     });
-    const onResize = () => {
-        shell.resize(process.stdout.columns || 80, process.stdout.rows || 24);
-    };
-    process.stdout.on("resize", onResize);
+    const offResize = terminal.onResize((cols, rows) => shell.resize(cols, rows));
     ctx.onDispose(() => {
-        process.stdout.off("resize", onResize);
+        offResize();
         shell.kill();
     });
     return {

package/dist/shell/shell.d.ts

@@ -1,5 +1,6 @@
 import type { EventBus } from "../core/event-bus.js";
 import { type InputContext } from "./input-handler.js";
+import { type Terminal } from "./terminal.js";
 export interface ShellHandlers {
     define: (name: string, fn: (...args: any[]) => any) => void;
     call: (name: string, ...args: any[]) => any;
@@ -19,6 +20,8 @@ export declare class Shell implements InputContext {
     private handlers;
     private inputHandler;
     private outputParser;
+    private terminal;
+    private inputDispose;
     private hardMuteScopes;
     private softMuteScopes;
     private unmuteScopes;
@@ -38,6 +41,7 @@ export declare class Shell implements InputContext {
         shell: string;
         cwd: string;
         instanceId: string;
+        terminal?: Terminal;
     });
     /** Compositing-layer claim — overrides any unmute. */
     acquireHardMute(reason: string): ShellScope;

package/dist/shell/shell.js

@@ -5,6 +5,7 @@ import { InputHandler } from "./input-handler.js";
 import { OutputParser } from "./output-parser.js";
 import { getSettings } from "../core/settings.js";
 import { clearOpost } from "../utils/tty.js";
+import { processTerminal } from "./terminal.js";
 import { pickStrategy, FALLBACK_STRATEGY, SUPPORTED_SHELL_NAMES, } from "./strategies/index.js";
 export class Shell {
     ptyProcess;
@@ -12,6 +13,8 @@ export class Shell {
     handlers;
     inputHandler;
     outputParser;
+    terminal;
+    inputDispose = null;
     // hardMute is unconditional (overlay compositing); softMute is overridable
     // by unmute (terminal_keys, permission UI). Gate: hard wins; otherwise
     // muted iff softMute held without an unmute.
@@ -23,6 +26,7 @@ export class Shell {
     strategy;
     tmpDir;
     constructor(opts) {
+        this.terminal = opts.terminal ?? processTerminal();
         // Build environment — filter out undefined values (node-pty's native
         // posix_spawnp fails if any env value is undefined)
         const env = {};
@@ -58,18 +62,10 @@ export class Shell {
         this.tmpDir = spawnConfig.tmpDir;
         Object.assign(env, spawnConfig.envOverrides);
         const shellArgs = spawnConfig.args;
-        // Pause stdin before spawning PTY to avoid TTY contention on macOS.
-        // The PTY will become the controlling terminal for the child shell.
-        const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
-        if (process.stdin.isTTY) {
-            try {
-                process.stdin.setRawMode(false);
-                process.stdin.pause();
-            }
-            catch {
-                // Ignore
-            }
-        }
+        // The PTY will become the controlling terminal for the child shell;
+        // suspend the host terminal's input around spawn to avoid TTY contention
+        // on macOS. Headless terminals make this a no-op.
+        const suspended = this.terminal.suspendInput?.();
         this.ptyProcess = pty.spawn(shellBin, shellArgs, {
             name: "xterm-256color",
             cols: opts.cols,
@@ -77,18 +73,7 @@ export class Shell {
             cwd: opts.cwd,
             env,
         });
-        // Restore stdin after PTY is created
-        if (process.stdin.isTTY) {
-            try {
-                process.stdin.resume();
-                if (wasRaw) {
-                    process.stdin.setRawMode(true);
-                }
-            }
-            catch {
-                // Ignore - will be set up later in index.ts
-            }
-        }
+        suspended?.resume();
         clearOpost();
         this.bus = opts.bus;
         this.handlers = opts.handlers;
@@ -259,15 +244,14 @@ export class Shell {
                 this.pendingEchoSkips--;
                 const rest = data.slice(nlIdx + 1);
                 if (rest)
-                    process.stdout.write(rest);
+                    this.terminal.write(rest);
                 return;
             }
-            process.stdout.write(data);
+            this.terminal.write(data);
         });
     }
     setupInput() {
-        process.stdin.on("data", (data) => {
-            const str = data.toString("utf-8");
+        this.inputDispose = this.terminal.onInput((str) => {
             this.inputHandler.handleInput(str);
         });
     }
@@ -304,7 +288,7 @@ export class Shell {
         this.bus.onPipeAsync("shell:exec-request", async (payload) => {
             const visible = this.acquireUnmute("exec-request");
             this.skipNextLine();
-            process.stdout.write("\r\n");
+            this.terminal.write("\r\n");
             this.bus.emit("shell:agent-exec-start", {});
             try {
                 const output = await new Promise((resolve, reject) => {
@@ -347,6 +331,8 @@ export class Shell {
         this.ptyProcess.onExit(callback);
     }
     kill() {
+        this.inputDispose?.();
+        this.inputDispose = null;
         this.ptyProcess.kill();
         if (this.tmpDir) {
             fs.rmSync(this.tmpDir, { recursive: true, force: true });

package/dist/shell/terminal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Terminal — the user-facing I/O endpoint that a Shell talks to.
+ *
+ * Shell wraps a *pseudo*-terminal (the PTY the child shell sees). This
+ * interface is the *real* terminal (or its substitute) on the other end:
+ * bytes in, bytes out, dimensions, resize notifications. The default
+ * factory wires it to process.stdin/stdout for the CLI; headless hosts
+ * (multi-session web hubs, tests) supply their own.
+ */
+import type { RenderSurface } from "../utils/compositor.js";
+export interface Terminal {
+    write(data: string): void;
+    onInput(cb: (data: string) => void): () => void;
+    onResize(cb: (cols: number, rows: number) => void): () => void;
+    cols(): number;
+    rows(): number;
+    /**
+     * Called around PTY spawn to avoid TTY contention: the child PTY becomes
+     * the controlling tty for the spawned shell. No-op when the terminal
+     * isn't a real tty.
+     */
+    suspendInput?(): {
+        resume(): void;
+    };
+}
+/** Default Terminal: wraps process.stdin/stdout. */
+export declare function processTerminal(): Terminal;
+/**
+ * Adapt a Terminal to a RenderSurface (the compositor's sink type). Adds
+ * the OPOST-cleared `\n` → `\r\n` translation that StdoutSurface applies,
+ * since the PTY has OPOST disabled.
+ */
+export declare function surfaceFromTerminal(terminal: Terminal): RenderSurface;

package/dist/shell/terminal.js

@@ -0,0 +1,62 @@
+/** Default Terminal: wraps process.stdin/stdout. */
+export function processTerminal() {
+    return {
+        write(data) {
+            if (process.stdout.writable) {
+                try {
+                    process.stdout.write(data);
+                }
+                catch { /* ignore */ }
+            }
+        },
+        onInput(cb) {
+            const handler = (b) => cb(b.toString("utf-8"));
+            process.stdin.on("data", handler);
+            return () => { process.stdin.off("data", handler); };
+        },
+        onResize(cb) {
+            const handler = () => cb(process.stdout.columns || 80, process.stdout.rows || 24);
+            process.stdout.on("resize", handler);
+            return () => { process.stdout.off("resize", handler); };
+        },
+        cols() { return process.stdout.columns || 80; },
+        rows() { return process.stdout.rows || 24; },
+        suspendInput() {
+            const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+            if (process.stdin.isTTY) {
+                try {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                }
+                catch { /* ignore */ }
+            }
+            return {
+                resume() {
+                    if (process.stdin.isTTY) {
+                        try {
+                            process.stdin.resume();
+                            if (wasRaw)
+                                process.stdin.setRawMode(true);
+                        }
+                        catch { /* ignore */ }
+                    }
+                },
+            };
+        },
+    };
+}
+/**
+ * Adapt a Terminal to a RenderSurface (the compositor's sink type). Adds
+ * the OPOST-cleared `\n` → `\r\n` translation that StdoutSurface applies,
+ * since the PTY has OPOST disabled.
+ */
+export function surfaceFromTerminal(terminal) {
+    const write = (text) => terminal.write(text.replace(/(?<!\r)\n/g, "\r\n"));
+    return {
+        write,
+        writeLine: (line) => write(line + "\n"),
+        get columns() { return terminal.cols(); },
+        get rows() { return terminal.rows(); },
+        onResize: (cb) => terminal.onResize(cb),
+    };
+}

package/dist/utils/tool-interactive.js

@@ -14,7 +14,6 @@ export function createToolUI(bus, surface) {
                     if (finished)
                         return;
                     finished = true;
-                    clearLines(surface, prevLineCount);
                     bus.offPipe("input:intercept", interceptor);
                     bus.emit("shell:stdout-hide", {});
                     bus.emit("tool:interactive-end", {});
@@ -45,7 +44,10 @@ export function createToolUI(bus, surface) {
                 bus.emit("tool:interactive-start", {});
                 bus.emit("shell:stdout-show", {});
                 bus.onPipe("input:intercept", interceptor);
-                session.onMount?.(() => render());
+                // Drop to a fresh row in case the cursor was mid-line; uncounted
+                // so clearLines on dismiss stops at the gap, not above it.
+                surface.write("\n");
+                session.onMount?.(() => render(), done);
                 render();
             });
         },