agent-sh 0.14.0 → 0.14.1

package/README.md

@@ -19,7 +19,7 @@ So I built agent-sh. Under the hood it's a normal shell on top of node-pty — y
 ~ $ > draft a commit message     # agent reads your diff and shell history
 ```
 
-agent-sh is built to be agent-agnostic. You can [bring your own coding agent](#bring-your-own-agent) or use the built-in agent `ash` — a lightweight, extensible agent if you'd like to build extensions on top of it.
+agent-sh is built to be agent-agnostic. The recommended path is the built-in agent `ash` — a lightweight agent designed so extensions can plug into the same tool surface. If you'd rather host an existing coding agent (pi, claude-code, opencode), you can [bring your own](#bring-your-own-agent) — with the trade-off that it manages its own separate tools.
 
 ## Quick Start
 
@@ -55,24 +55,9 @@ alias ash="agent-sh"
 
 Once installed, pick a backend below.
 
-### Option A: Bring your own coding agent
+### Option A: Use the built-in agent (ash) — recommended
 
-If you already use a coding agent, host it inside agent-sh — same terminal, same `>` entry point, same shell-context wiring. Three bridges ship in the box:
-
-- **pi** — [pi-mono](https://github.com/badlogic/pi-mono) coding agent
-- **claude-code** — official [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk)
-- **opencode** — [opencode](https://opencode.ai/) via `@opencode-ai/sdk`
-
-```bash
-agent-sh install pi-bridge
-agent-sh --backend pi
-```
-
-See [Bring your own agent](#bring-your-own-agent) below for full details and the other backends.
-
-### Option B: Use the built-in agent (ash)
-
-`ash` is agent-sh's own lightweight agent. It works with any OpenAI-compatible API — pick one of the zero-config paths below, no settings file needed. The built-in providers (openrouter, openai, openai-compatible, deepseek) register on startup; ash activates the first one with a usable key.
+`ash` is agent-sh's own lightweight agent, and the path most users should start with: it shares its tool surface with the rest of the system, so extensions you install (new tools, content transforms, slash commands, themes) compose with it directly. It works with any OpenAI-compatible API — pick one of the zero-config paths below, no settings file needed. The built-in providers (openrouter, openai, openai-compatible, deepseek) register on startup; ash activates the first one with a usable key.
 
 **Quickest path** — store a key once via the auth subcommand:
 
@@ -121,6 +106,10 @@ For richer configuration (multiple providers, extensions), run `agent-sh init` t
 
 `ash` is designed to be extended. Extensions can add tools, content transforms (e.g. render LaTeX or Mermaid), themes, slash commands, or new input modes — see [Extensions](docs/extensions.md) for the full surface.
 
+### Option B: Bring your own coding agent
+
+If you already use pi, claude-code, or opencode, agent-sh can host it as the backend instead — see [Bring your own agent](#bring-your-own-agent) just below for the full setup and the trade-offs.
+
 ## Bring your own agent
 
 The built-in agent (`ash`) is the default, but agent-sh can host a different coding agent as its backend — same terminal, same `>` entry point, same shell-context wiring. Three bridges ship in the box:

package/dist/agent/llm-client.js

@@ -16,6 +16,7 @@ function attributionHeaders(config) {
     return {
         "HTTP-Referer": config.appUrl ?? "https://agent-sh.dev",
         "X-Title": config.appName ?? "agent-sh",
+        "X-OpenRouter-Categories": "cli-agent,programming-app",
     };
 }
 export class LlmClient {

package/dist/agent/types.d.ts

@@ -57,8 +57,8 @@ export interface InteractiveSession<T> {
     render(width: number): string[];
     /** Handle raw input. Call done(result) to finish the session. */
     handleInput(data: string, done: (result: T) => void): void;
-    /** Called when session starts. Receives invalidate() for async re-renders. */
-    onMount?(invalidate: () => void): void;
+    /** done() lets the session resolve itself from outside handleInput. */
+    onMount?(invalidate: () => void, done: (result: T) => void): void;
     /** Called when session ends (cleanup). */
     onUnmount?(): void;
 }

package/dist/cli/args.js

@@ -3,7 +3,9 @@ const HELP_TEXT = `agent-sh — a shell-first terminal where AI is one keystroke
 
 Usage: agent-sh [options]
        agent-sh init [--force]            Scaffold ~/.agent-sh/ (settings, examples, AGENTS.md)
-       agent-sh install <spec> [--force]  Install an extension (bundled name, file:, npm:, github:)
+       agent-sh install <spec> [--force] [--sync-deps]
+                                          Install an extension (bundled name, file:, npm:, github:)
+                                          --sync-deps rewrites a stale agent-sh pin to the host version
        agent-sh uninstall <name>          Remove an installed extension
        agent-sh list                      List installed extensions
        agent-sh auth login [provider]     Store an API key for a built-in provider

package/dist/cli/install.d.ts

@@ -1,5 +1,6 @@
 interface InstallOpts {
     force?: boolean;
+    syncDeps?: boolean;
 }
 export declare function listBundled(): string[];
 /** Heuristic: a backend named "pi" is typically provided by an extension called "pi-bridge". */

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/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();
             });
         },

package/examples/extensions/ashi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",

package/examples/extensions/ashi/src/cli.ts

@@ -70,7 +70,10 @@ async function main(): Promise<void> {
 
   if (sub === "install" || sub === "uninstall" || sub === "list") {
     const { runInstall, runUninstall, runList } = await import("agent-sh/cli/install");
-    if (sub === "install") await runInstall(rest[0] ?? "", { force: rest.includes("--force") });
+    if (sub === "install") await runInstall(rest[0] ?? "", {
+      force: rest.includes("--force"),
+      syncDeps: rest.includes("--sync-deps"),
+    });
     else if (sub === "uninstall") await runUninstall(rest[0] ?? "");
     else runList();
     process.exit(0);

package/examples/extensions/claude-code-bridge/index.ts

@@ -21,6 +21,7 @@ export default function activate(ctx: ExtensionContext): void {
   };
 
   let activeQuery: Query | null = null;
+  let sessionId: string | null = null;
   const listeners: Array<{ event: string; fn: Function }> = [];
 
   // ── Tool display helpers ────────────────────────────────────────
@@ -97,6 +98,7 @@ export default function activate(ctx: ExtensionContext): void {
             allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
             permissionMode: "acceptEdits",
             includePartialMessages: true,
+            ...(sessionId ? { resume: sessionId } : {}),
           },
         });
 
@@ -262,8 +264,11 @@ export default function activate(ctx: ExtensionContext): void {
               // Tool still running — nothing to do, TUI spinner already active
               break;
 
-            case "result":
+            case "result": {
+              const sid = (message as any).session_id;
+              if (typeof sid === "string" && sid) sessionId = sid;
               break;
+            }
           }
         }
 
@@ -291,7 +296,7 @@ export default function activate(ctx: ExtensionContext): void {
     };
 
     const onCancel = () => { activeQuery?.interrupt(); };
-    const onReset = () => { /* each query() is a new session */ };
+    const onReset = () => { sessionId = null; };
 
     bus.on("agent:submit", onSubmit);
     bus.on("agent:cancel-request", onCancel);

package/examples/extensions/claude-code-bridge/package.json

@@ -6,7 +6,7 @@
   "main": "index.ts",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.0",
-    "agent-sh": "^0.9.0",
+    "agent-sh": "^0.14.0",
     "zod": "^4.0.0"
   }
 }

package/examples/extensions/opencode-bridge/index.ts

@@ -13,6 +13,7 @@ import {
   type ToolPart,
   type QuestionRequest,
   type QuestionInfo,
+  type PermissionRequest,
 } from "@opencode-ai/sdk/v2";
 import type { ExtensionContext } from "agent-sh/types";
 import type { InteractiveSession } from "agent-sh/agent/types";
@@ -60,7 +61,8 @@ function parseUnifiedDiff(patch: string): DiffResult | null {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, call } = ctx; const { compositor } = ctx.shell;
+  const { bus, call } = ctx;
+  const compositor = ctx.shell?.compositor;
 
   const cwd = (): string => {
     const v = call("cwd");
@@ -94,6 +96,18 @@ export default function activate(ctx: ExtensionContext): void {
   let turnIdleSeen = false;
   let turnError: string | null = null;
 
+  let pickerOpen = false;
+  const eventQueue: Event[] = [];
+  const drainQueue = (): void => {
+    const events = eventQueue.splice(0);
+    for (const ev of events) handleEvent(ev);
+  };
+
+  // After Ctrl+C, opencode emits a tail of tool / error state for the
+  // aborted turn. Suppress until the next turn so it doesn't restart the
+  // spinner or replay dead tool entries.
+  let cancelledTurn = false;
+
   const listeners: Array<{ event: string; fn: Function }> = [];
 
   function toolKind(name: string): string {
@@ -194,12 +208,24 @@ export default function activate(ctx: ExtensionContext): void {
 
 
   function handleEvent(event: Event): void {
+    if (pickerOpen) { eventQueue.push(event); return; }
     if (!sessionId) return;
     const evType = (event as any).type as string;
     const props = (event as any).properties ?? {};
     const sid = props.sessionID;
     if (typeof sid === "string" && sid !== sessionId) return;
 
+    if (cancelledTurn) {
+      // Only let through what unblocks onSubmit. Clearing the flag earlier
+      // (e.g. on session.error) lets the trailing bash part.updated slip
+      // past and restart the spinner.
+      if (evType === "session.idle" || evType === "session.error") {
+        turnIdleSeen = true;
+        pendingTurnEnd?.();
+      }
+      return;
+    }
+
     switch (evType) {
       // message.part.delta is undocumented in the SDK's Event union but
       // the SSE consumer yields it. Drop chunks for unknown partIDs —
@@ -242,72 +268,141 @@ export default function activate(ctx: ExtensionContext): void {
       case "question.asked": {
         const req = props as QuestionRequest;
         if (!runtime) break;
+        if (!compositor) {
+          runtime.client.question
+            .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
+            .catch(() => { /* best-effort */ });
+          bus.emit("ui:error", {
+            message: `opencode-bridge: rejected interactive question (no shell host): ${req.questions.map((q) => q.question).join("; ")}`,
+          });
+          break;
+        }
+        pickerOpen = true;
         const ui = createToolUI(bus, compositor.surface("agent"));
         ui.custom(createQuestionSession(req.questions)).then(async (result: QuestionResult) => {
-          if (!runtime) return;
-          // Record the question + answer as a synthetic tool entry so the
-          // timeline shows what was asked and what the user picked.
-          const callID = `question-${req.id}`;
-          const detail = req.questions.length === 1
-            ? req.questions[0]!.question
-            : req.questions.map((q, i) => `${q.header || `Q${i + 1}`}: ${q.question}`).join("; ");
-          bus.emit("agent:tool-started", {
-            title: "question",
-            toolCallId: callID,
-            kind: "execute",
-            displayDetail: detail,
-          });
-          if (result.cancelled) {
+          try {
+            if (!runtime) return;
+            // Record the question + answer as a synthetic tool entry so the
+            // timeline shows what was asked and what the user picked.
+            const callID = `question-${req.id}`;
+            const detail = req.questions.length === 1
+              ? req.questions[0]!.question
+              : req.questions.map((q, i) => `${q.header || `Q${i + 1}`}: ${q.question}`).join("; ");
+            bus.emit("agent:tool-started", {
+              title: "question",
+              toolCallId: callID,
+              kind: "execute",
+              displayDetail: detail,
+            });
+            if (result.cancelled) {
+              bus.emitTransform("agent:tool-completed", {
+                toolCallId: callID,
+                exitCode: 1,
+                rawOutput: "cancelled",
+                kind: "execute",
+                resultDisplay: { summary: "cancelled" },
+              });
+              runtime.client.question
+                .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
+                .catch(() => { /* best-effort */ });
+              return;
+            }
+            const summary = result.answers.length === 1
+              ? result.answers[0]!.join(", ")
+              : result.answers
+                  .map((ans, i) => `${req.questions[i]!.header || `Q${i + 1}`}: ${ans.join(", ")}`)
+                  .join("; ");
+            bus.emitTransform("agent:tool-completed", {
+              toolCallId: callID,
+              exitCode: 0,
+              rawOutput: summary,
+              kind: "execute",
+              resultDisplay: { summary },
+            });
+            try {
+              await runtime.client.question.reply({
+                requestID: req.id,
+                answers: result.answers,
+                directory: sessionDirectory ?? undefined,
+              });
+            } catch (err) {
+              bus.emit("agent:error", {
+                message: err instanceof Error ? err.message : String(err),
+              });
+            }
+          } finally {
+            pickerOpen = false;
+            if (result.cancelled) {
+              eventQueue.length = 0;
+              cancelledTurn = true;
+              pendingTurnEnd?.();
+            } else {
+              drainQueue();
+            }
+          }
+        });
+        break;
+      }
+      case "permission.asked": {
+        const req = props as PermissionRequest;
+        if (!runtime) break;
+        const detail = req.patterns.length > 0
+          ? `${req.permission}: ${req.patterns.join(", ")}`
+          : req.permission;
+        const finish = (reply: "once" | "always" | "reject", opts?: { note?: string; skipReply?: boolean }) => {
+          if (reply === "reject") {
+            const callID = `permission-${req.id}`;
+            const summary = opts?.note ? `denied (${opts.note})` : `denied: ${detail}`;
+            bus.emit("agent:tool-started", {
+              title: "permission",
+              toolCallId: callID,
+              kind: "execute",
+              displayDetail: detail,
+            });
             bus.emitTransform("agent:tool-completed", {
               toolCallId: callID,
               exitCode: 1,
-              rawOutput: "cancelled",
+              rawOutput: summary,
               kind: "execute",
-              resultDisplay: { summary: "cancelled" },
+              resultDisplay: { summary },
             });
-            runtime.client.question
-              .reject({ requestID: req.id, directory: sessionDirectory ?? undefined })
-              .catch(() => { /* best-effort */ });
-            return;
           }
-          const summary = result.answers.length === 1
-            ? result.answers[0]!.join(", ")
-            : result.answers
-                .map((ans, i) => `${req.questions[i]!.header || `Q${i + 1}`}: ${ans.join(", ")}`)
-                .join("; ");
-          bus.emitTransform("agent:tool-completed", {
-            toolCallId: callID,
-            exitCode: 0,
-            rawOutput: summary,
-            kind: "execute",
-            resultDisplay: { summary },
+          if (!runtime || opts?.skipReply) return;
+          runtime.client.permission
+            .reply({ requestID: req.id, reply, directory: sessionDirectory ?? undefined })
+            .catch((err) => {
+              bus.emit("agent:error", {
+                message: err instanceof Error ? err.message : String(err),
+              });
+            });
+        };
+        if (!compositor) {
+          finish("reject", { note: "no shell host" });
+          bus.emit("ui:error", {
+            message: `opencode-bridge: rejected permission (no shell host): ${detail}`,
           });
+          break;
+        }
+        pickerOpen = true;
+        const ui = createToolUI(bus, compositor.surface("agent"));
+        ui.custom(createPermissionSession(req, bus)).then((result: PermissionResult) => {
           try {
-            await runtime.client.question.reply({
-              requestID: req.id,
-              answers: result.answers,
-              directory: sessionDirectory ?? undefined,
-            });
-          } catch (err) {
-            bus.emit("agent:error", {
-              message: err instanceof Error ? err.message : String(err),
-            });
+            finish(result.reply, result.cancelled ? { skipReply: true } : undefined);
+          } finally {
+            pickerOpen = false;
+            if (result.cancelled) {
+              // Let onSubmit's finally emit the single agent:processing-done;
+              // a second one here races and stacks prompts.
+              eventQueue.length = 0;
+              cancelledTurn = true;
+              pendingTurnEnd?.();
+            } else {
+              drainQueue();
+            }
           }
         });
         break;
       }
-      // Without a reply the gated tool hangs forever. The bridge has no
-      // interactive approval UI, so auto-approve — mirrors claude-code-
-      // bridge's permissionMode: "acceptEdits". Set permission.edit:
-      // "allow" in opencode.json to skip the round-trip entirely.
-      case "permission.asked": {
-        const requestID = props.id as string | undefined;
-        if (!requestID || !runtime) break;
-        runtime.client.permission
-          .reply({ requestID, reply: "once", directory: sessionDirectory ?? undefined })
-          .catch(() => { /* approval is best-effort */ });
-        break;
-      }
     }
   }
 
@@ -339,6 +434,7 @@ export default function activate(ctx: ExtensionContext): void {
       bus.emit("agent:query", { query: userQuery });
       bus.emit("agent:processing-start", {});
       turnText = "";
+      cancelledTurn = false;
       turnIdleSeen = false;
       turnError = null;
       // Set the idle waiter BEFORE prompt() so a fast session.idle can't
@@ -471,6 +567,7 @@ export default function activate(ctx: ExtensionContext): void {
 // ── Interactive question picker ──────────────────────────────────
 
 type QuestionResult = { answers: string[][]; cancelled: boolean };
+type PermissionResult = { reply: "once" | "always" | "reject"; cancelled?: boolean };
 
 function isKey(data: string, key: string): boolean {
   switch (key) {
@@ -601,3 +698,58 @@ function createQuestionSession(questions: QuestionInfo[]): InteractiveSession<Qu
     },
   };
 }
+
+function createPermissionSession(
+  req: PermissionRequest,
+  bus: { on: (e: "agent:cancel-request", fn: () => void) => void; off: (e: "agent:cancel-request", fn: () => void) => void },
+): InteractiveSession<PermissionResult> {
+  let cancelHandler: (() => void) | null = null;
+  // Cast widens onMount: the vendored agent-sh type still declares the 1-arg signature.
+  const onMount = ((_invalidate: () => void, done: (r: PermissionResult) => void): void => {
+    cancelHandler = () => done({ reply: "reject", cancelled: true });
+    bus.on("agent:cancel-request", cancelHandler);
+  }) as InteractiveSession<PermissionResult>["onMount"];
+  return {
+    onMount,
+    onUnmount() {
+      if (cancelHandler) bus.off("agent:cancel-request", cancelHandler);
+      cancelHandler = null;
+    },
+    render(_width) {
+      const lines: string[] = [];
+      lines.push(` ${p.warning}${p.bold}Permission required: ${req.permission}${p.reset}`);
+
+      const meta = req.metadata ?? {};
+      const cmd = typeof meta.command === "string" ? meta.command : null;
+      const file = typeof meta.file === "string"
+        ? meta.file
+        : typeof meta.path === "string" ? meta.path : null;
+      if (cmd) {
+        for (const line of cmd.split("\n").slice(0, 6)) {
+          lines.push(`   ${p.dim}${line}${p.reset}`);
+        }
+      } else if (file) {
+        lines.push(`   ${p.dim}${file}${p.reset}`);
+      }
+
+      if (req.patterns.length > 0 && !cmd && !file) {
+        for (const pat of req.patterns) {
+          lines.push(`   ${p.dim}${pat}${p.reset}`);
+        }
+      }
+
+      lines.push(` ${p.dim}[y] allow once  [a] allow always  [n] reject${p.reset}`);
+      return lines;
+    },
+
+    handleInput(data, done) {
+      if (isKey(data, "escape") || data === "n" || data === "N") {
+        done({ reply: "reject" });
+      } else if (data === "y" || data === "Y" || isKey(data, "enter")) {
+        done({ reply: "once" });
+      } else if (data === "a" || data === "A") {
+        done({ reply: "always" });
+      }
+    },
+  };
+}

package/examples/extensions/opencode-bridge/package.json

@@ -6,6 +6,6 @@
   "main": "index.ts",
   "dependencies": {
     "@opencode-ai/sdk": "^1.14.41",
-    "agent-sh": "^0.12.0"
+    "agent-sh": "^0.14.0"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core/index.js",