agent-sh 0.12.26 → 0.13.0

package/examples/extensions/interactive-prompts.ts

@@ -1,10 +1,9 @@
 /**
  * Interactive permission prompts extension.
  *
- * Adds permission gates for tool calls and file writes.
- * Without this extension, agent-sh runs in yolo mode (auto-approve).
- *
- * Uses the interactive UI primitive for compositor-aware, themed rendering.
+ * Gates the four built-in side-effect tools (bash, pwsh, write_file,
+ * edit_file) via tool advisors. Without this extension, agent-sh runs in
+ * yolo mode — tools execute without confirmation.
  *
  * Usage:
  *   agent-sh -e ./examples/extensions/interactive-prompts.ts
@@ -12,19 +11,22 @@
  *   # Or copy to ~/.agent-sh/extensions/ for permanent use:
  *   cp examples/extensions/interactive-prompts.ts ~/.agent-sh/extensions/
  */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { renderDiff } from "agent-sh/utils/diff-renderer.js";
 import { renderBoxFrame } from "agent-sh/utils/box-frame.js";
 import { palette as p } from "agent-sh/utils/palette.js";
-import type { ExtensionContext } from "agent-sh/types";
+import { computeDiff, computeEditDiff, computeInputDiff, type DiffResult } from "agent-sh/utils/diff.js";
+import type { AgentContext } from "agent-sh/types";
 import type { ToolUI } from "agent-sh/agent/types.js";
 
-export default function activate(ctx: ExtensionContext) {
+const GATED_TOOLS = ["bash", "pwsh", "write_file", "edit_file"] as const;
+
+export default function activate(ctx: AgentContext) {
   let autoApproveWrites = false;
 
-  // Advise the TUI diff renderer to add permission prompt framing.
-  // This replaces the default plain diff box with one that has a warning
-  // border and key hints, so only one diff box is shown (not two).
-  ctx.advise("tui:render-diff", (next, filePath: string, diff: any, width: number) => {
+  // Frame pre-execute diff previews as a permission prompt.
+  ctx.advise("tui:render-diff", (_next, filePath: string, diff: DiffResult, width: number) => {
     const boxW = Math.min(84, width);
     const contentW = boxW - 4;
     const MAX_DISPLAY = 25;
@@ -54,94 +56,137 @@ export default function activate(ctx: ExtensionContext) {
     });
   });
 
-  const { bus } = ctx;
+  for (const name of GATED_TOOLS) {
+    ctx.agent.adviseTool(name, async (next, args, onChunk, toolCtx) => {
+      const ui = toolCtx?.ui;
+      if (!ui) return next(args, onChunk, toolCtx);
 
-  bus.onPipeAsync("permission:request", async (payload) => {
-    const ui = payload.ui as ToolUI | undefined;
-    if (!ui) return payload;
+      const isFileWrite = name === "write_file" || name === "edit_file";
+      let diffPreRendered = false;
 
-    switch (payload.kind) {
-      case "tool-call":
-        return handleToolCall(payload, ui);
-      case "file-write": {
-        if (autoApproveWrites) {
-          return { ...payload, decision: { outcome: "approved" } };
-        }
-        const result = await handleFileWrite(payload, ui);
-        if ((result.decision as any).autoApprove) {
-          autoApproveWrites = true;
+      ctx.bus.emit("shell:stdout-show", {});
+      try {
+        if (isFileWrite) {
+          if (autoApproveWrites) {
+            // Skip prompt; tool's own post-execute diff renders as usual.
+            return next(args, onChunk, toolCtx);
+          }
+          await renderPreviewDiff(ctx, name, args);
+          diffPreRendered = true;
+
+          const answer = await promptWrite(ui);
+          if (answer === "reject") {
+            return { content: "Permission denied by user.", exitCode: 1, isError: true };
+          }
+          if (answer === "approve_all") autoApproveWrites = true;
+        } else {
+          const answer = await promptCommand(ui, name, args);
+          if (answer === "deny") {
+            return { content: "Permission denied by user.", exitCode: 1, isError: true };
+          }
         }
-        return result;
+      } finally {
+        ctx.bus.emit("shell:stdout-hide", {});
       }
-      default:
-        return payload;
-    }
-  });
+
+      const result = await next(args, onChunk, toolCtx);
+      if (diffPreRendered && result.display?.body?.kind === "diff") {
+        // Strip the redundant post-execute diff body since we already showed it.
+        return { ...result, display: { ...result.display, body: undefined } };
+      }
+      return result;
+    });
+  }
 }
 
-async function handleToolCall(payload: any, ui: ToolUI) {
-  const options = payload.metadata.options;
+async function renderPreviewDiff(
+  ctx: AgentContext,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const rawPath = args.path;
+  if (typeof rawPath !== "string") return;
+  const absPath = path.resolve(process.cwd(), rawPath);
 
-  const answer = await ui.custom<"approve" | "approve_all" | "deny">({
+  let diff: DiffResult | undefined;
+  if (toolName === "edit_file" && typeof args.old_text === "string" && typeof args.new_text === "string") {
+    const normalizedOld = (args.old_text as string).replace(/\r\n/g, "\n");
+    const normalizedNew = (args.new_text as string).replace(/\r\n/g, "\n");
+    try {
+      const oldFileContent = await fs.readFile(absPath, "utf-8");
+      diff = computeEditDiff(
+        oldFileContent, normalizedOld, normalizedNew,
+        args.replace_all === true,
+      );
+    } catch {
+      diff = computeInputDiff(normalizedOld, normalizedNew);
+    }
+  } else if (toolName === "write_file" && typeof args.content === "string") {
+    let oldContent: string | null = null;
+    try { oldContent = await fs.readFile(absPath, "utf-8"); } catch { /* new file */ }
+    diff = computeDiff(oldContent, args.content as string);
+  }
+  if (!diff || diff.isIdentical) return;
+
+  const cwd = process.cwd();
+  const home = process.env.HOME ?? "";
+  let displayPath = absPath;
+  if (absPath.startsWith(cwd + "/")) displayPath = absPath.slice(cwd.length + 1);
+  else if (home && absPath.startsWith(home + "/")) displayPath = "~/" + absPath.slice(home.length + 1);
+
+  ctx.call("tui:show-diff", displayPath, diff);
+}
+
+async function promptWrite(ui: ToolUI): Promise<"approve" | "approve_all" | "reject"> {
+  return ui.custom<"approve" | "approve_all" | "reject">({
     render(width) {
       const boxW = Math.min(84, width);
-      return renderBoxFrame(
-        [`${p.bold}⚠ ${payload.title}${p.reset}`],
-        {
-          width: boxW,
-          style: "rounded",
-          borderColor: p.warning,
-          title: "Permission required",
-          footer: [`  ${p.dim}[y]es / [n]o / [a]llow all${p.reset}`],
-        },
-      );
+      return renderBoxFrame([], {
+        width: boxW,
+        style: "rounded",
+        borderColor: p.warning,
+        footer: [`  ${p.bold}[y] Apply  [n] Skip  [a] Don't ask again${p.reset}`],
+      });
     },
     handleInput(data, done) {
       const ch = data.toLowerCase();
       if (ch === "y") done("approve");
       else if (ch === "a") done("approve_all");
-      else if (ch === "n" || ch === "\x1b") done("deny");
+      else if (ch === "n" || ch === "\x1b") done("reject");
     },
   });
-
-  if (answer === "approve" || answer === "approve_all") {
-    const kind = answer === "approve_all" ? "allow_always" : "allow_once";
-    const option = options?.find((o: any) => o.kind === kind)
-      ?? options?.find((o: any) => o.kind === "allow_once" || o.kind === "allow_always");
-    if (option) {
-      return { ...payload, decision: { outcome: "selected", optionId: option.optionId } };
-    }
-    return { ...payload, decision: { outcome: "approved" } };
-  }
-  return { ...payload, decision: { outcome: "cancelled" } };
 }
 
-async function handleFileWrite(payload: any, ui: ToolUI) {
-  const answer = await ui.custom<"approve" | "approve_all" | "reject">({
+async function promptCommand(
+  ui: ToolUI,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<"approve" | "deny"> {
+  const command = typeof args.command === "string" ? args.command : "";
+  const description = typeof args.description === "string" ? args.description : "";
+  const title = description ? `${toolName}: ${description}` : toolName;
+  const body = command
+    ? `${p.bold}${title}${p.reset}\n${p.dim}${truncate(command, 200)}${p.reset}`
+    : `${p.bold}${title}${p.reset}`;
+  return ui.custom<"approve" | "deny">({
     render(width) {
       const boxW = Math.min(84, width);
-      // Just show the prompt actions — the diff itself was already rendered
-      // by our advise on "tui:render-diff".
-      return renderBoxFrame([], {
+      return renderBoxFrame(body.split("\n"), {
         width: boxW,
         style: "rounded",
         borderColor: p.warning,
-        footer: [`  ${p.bold}[y] Apply  [n] Skip  [a] Don't ask again${p.reset}`],
+        title: "Permission required",
+        footer: [`  ${p.dim}[y]es / [n]o${p.reset}`],
       });
     },
     handleInput(data, done) {
       const ch = data.toLowerCase();
       if (ch === "y") done("approve");
-      else if (ch === "a") done("approve_all");
-      else if (ch === "n" || ch === "\x1b") done("reject");
+      else if (ch === "n" || ch === "\x1b") done("deny");
     },
   });
+}
 
-  if (answer === "approve") {
-    return { ...payload, decision: { outcome: "approved" } };
-  }
-  if (answer === "approve_all") {
-    return { ...payload, decision: { outcome: "approved", autoApprove: true } };
-  }
-  return { ...payload, decision: { outcome: "cancelled" } };
+function truncate(s: string, max: number): string {
+  return s.length <= max ? s : s.slice(0, max - 1) + "…";
 }

package/examples/extensions/latex-images.ts

@@ -19,7 +19,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { ExtensionContext } from "agent-sh/types";
+import type { ShellContext } from "agent-sh/types";
 
 // Settings loaded in activate() via ctx.getExtensionSettings
 let config = { dpi: 300, fgColor: "d4d4d4" };
@@ -98,7 +98,7 @@ function renderEquation(equation: string): Buffer | null {
 
 // ── Extension entry point ────────────────────────────────────────
 
-export default function activate(ctx: ExtensionContext) {
+export default function activate(ctx: ShellContext) {
   const { bus } = ctx;
 
   // Load settings: ~/.agent-sh/settings.json → "latex-images": { dpi, fgColor }
@@ -116,7 +116,7 @@ export default function activate(ctx: ExtensionContext) {
   }
 
   // Handle inline $$...$$ display math
-  ctx.createBlockTransform({
+  ctx.shell.createBlockTransform({
     open: "$$",
     close: "$$",
     transform(latex) {

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

@@ -60,7 +60,7 @@ function parseUnifiedDiff(patch: string): DiffResult | null {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, call, compositor } = ctx;
+  const { bus, call } = ctx; const { compositor } = ctx.shell;
 
   const cwd = (): string => {
     const v = call("cwd");

package/examples/extensions/overlay-agent.ts

@@ -20,7 +20,7 @@
  *   - terminal-buffer.ts → terminal_read / terminal_keys tools
  *   - user-shell.ts      → user_shell tool (run new shell commands)
  */
-import type { ExtensionContext, RemoteSession } from "agent-sh/types";
+import type { AgentContext, ShellContext, RemoteSession } from "agent-sh/types";
 import type { RenderSurface } from "agent-sh/utils/compositor";
 import { FloatingPanel } from "agent-sh/utils/floating-panel";
 import { formatScreenContext, type TerminalBuffer } from "agent-sh/utils/terminal-buffer";
@@ -66,8 +66,10 @@ function createPanelSurface(panel: FloatingPanel): RenderSurface {
   };
 }
 
-export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerInstruction, createRemoteSession } = ctx;
+export default function activate(ctx: AgentContext & ShellContext): void {
+  const { bus } = ctx;
+  const { registerInstruction } = ctx.agent;
+  const { createRemoteSession } = ctx.shell;
   const terminalBuffer: TerminalBuffer | null = ctx.call("terminal-buffer");
 
   const panel = new FloatingPanel(bus, {
@@ -79,13 +81,13 @@ export default function activate(ctx: ExtensionContext): void {
   const panelSurface = createPanelSurface(panel);
   let session: RemoteSession | null = null;
 
-  ctx.registerContextProducer("interactive-session", () =>
+  ctx.agent.registerContextProducer("interactive-session", () =>
     session?.active ? "interactive-session: true" : null,
   );
 
   // Inject the live screen for TUI / REPL programs. At a plain shell prompt
   // `<shell_events>` already covers the visible scrollback — skip to dedupe.
-  ctx.registerContextProducer("terminal-screen", () => {
+  ctx.agent.registerContextProducer("terminal-screen", () => {
     if (!session?.active || !terminalBuffer?.altScreen) return null;
     return formatScreenContext(terminalBuffer.readScreen(), 80);
   });
@@ -104,8 +106,18 @@ export default function activate(ctx: ExtensionContext): void {
         surface: panelSurface,
       });
     }
-    panel.setActive();
-    session.submit(query);
+    if (query.startsWith("/")) {
+      // Sync commands (/model, /help) render via ui:info and leave us in
+      // input phase; ones that fan out to agent:submit flip the phase via
+      // the agent:processing-start listener below.
+      const spaceIdx = query.indexOf(" ");
+      const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
+      const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
+      bus.emit("command:execute", { name, args });
+    } else {
+      panel.setActive();
+      session.submit(query);
+    }
   });
 
   panel.handlers.advise("panel:show", (_next) => {
@@ -114,9 +126,9 @@ export default function activate(ctx: ExtensionContext): void {
     }
   });
 
-  // Keep the session alive while the agent is still working, even after
-  // dismiss — so output keeps buffering and tools keep executing.
-  panel.handlers.advise("panel:dismiss", (next) => {
+  // While the agent is still working, keep the session open so output and
+  // tool calls survive a hide. Once it's idle, close to release redirects.
+  panel.handlers.advise("panel:hide", (next) => {
     next();
     if (session && !panel.processing) {
       session.close();
@@ -124,6 +136,19 @@ export default function activate(ctx: ExtensionContext): void {
     }
   });
 
+  panel.handlers.advise("panel:reset", (next) => {
+    next();
+    if (session) {
+      session.close();
+      session = null;
+    }
+  });
+
+  // Picks up turns triggered indirectly (e.g. /skill:foo → agent:submit).
+  bus.on("agent:processing-start", () => {
+    if (panel.active && !panel.processing) panel.setActive();
+  });
+
   bus.on("agent:processing-done", () => {
     if (panel.active) panel.setDone();
   });

package/examples/extensions/peer-mesh.ts

@@ -190,7 +190,7 @@ class PeerServer {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerCommand, registerTool, registerInstruction, define } = ctx;
+  const { bus, registerCommand, define } = ctx; const { registerTool, registerInstruction } = ctx.agent;
   const getCwd = () => ctx.call("cwd") as string;
   const startTime = Date.now();
 

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

@@ -391,7 +391,6 @@ export default function activate(ctx: ExtensionContext): void {
         return;
       }
       session.setThinkingLevel(level);
-      bus.emit("ui:info", { message: `Thinking: ${level}` });
       bus.emit("config:changed", {});
     };
 

package/examples/extensions/questionnaire.ts

@@ -55,7 +55,8 @@ interface QuestionnaireResult {
 
 // ── Extension ────────────────────────────────────────────────────
 
-export default function activate({ registerTool, registerInstruction }: ExtensionContext) {
+export default function activate(ctx: ExtensionContext) {
+  const { registerTool, registerInstruction } = ctx.agent;
   registerInstruction("questionnaire", [
     "# When to use the questionnaire tool",
     "ALWAYS use the `questionnaire` tool instead of asking the user a question in plain text when:",

package/examples/extensions/rtk-proxy.ts

@@ -20,7 +20,7 @@
  *   cp examples/extensions/rtk-proxy.ts ~/.agent-sh/extensions/
  */
 import { execSync } from "node:child_process";
-import type { ExtensionContext } from "agent-sh/types";
+import type { AgentContext } from "agent-sh/types";
 
 const DEFAULT_PREFIXES = new Set([
   "git", "gh",
@@ -73,7 +73,7 @@ function rewriteForRtk(cmd: string, prefixes: Set<string>, flag: string): string
   return `RTK_TELEMETRY_DISABLED=1 rtk ${flag}${cmd}`;
 }
 
-export default function activate(ctx: ExtensionContext) {
+export default function activate(ctx: AgentContext) {
   const config = ctx.getExtensionSettings("rtk-proxy", {
     enabled: true,
     ultraCompact: false,
@@ -95,7 +95,7 @@ export default function activate(ctx: ExtensionContext) {
   for (const p of config.excludePrefixes) prefixes.delete(p);
   const flag = config.ultraCompact ? "--ultra-compact " : "";
 
-  ctx.registerInstruction("rtk-proxy",
+  ctx.agent.registerInstruction("rtk-proxy",
     "The rtk-proxy extension transparently rewrites bash commands like " +
     "`git status`, `cargo test`, `pytest` to their rtk-compressed equivalents " +
     "before execution. Output will be condensed (errors/failures first, " +

package/examples/extensions/solarized-theme.ts

@@ -9,10 +9,10 @@
  *   # Or copy to ~/.agent-sh/extensions/ for permanent use:
  *   cp examples/extensions/solarized-theme.ts ~/.agent-sh/extensions/
  */
-import type { ExtensionContext } from "agent-sh/types";
+import type { ShellContext } from "agent-sh/types";
 
-export default function activate({ setPalette }: ExtensionContext) {
-  setPalette({
+export default function activate(ctx: ShellContext) {
+  ctx.shell.setPalette({
     accent:  "\x1b[38;2;38;139;210m",   // blue (#268bd2)
     success: "\x1b[38;2;133;153;0m",    // green (#859900)
     warning: "\x1b[38;2;181;137;0m",    // yellow (#b58900)

package/examples/extensions/subagents.ts

@@ -8,22 +8,22 @@
  * Usage:
  *   agent-sh -e ./examples/extensions/subagents.ts
  */
-import type { ExtensionContext } from "agent-sh/types";
+import type { AgentContext } from "agent-sh/types";
 import { runSubagent } from "agent-sh/agent/subagent";
 
-export default function activate(ctx: ExtensionContext): void {
+export default function activate(ctx: AgentContext): void {
   const { bus, llmClient } = ctx;
   if (!llmClient) return;
 
-  const allToolNames = () => ctx.getTools().map(t => t.name);
+  const allToolNames = () => ctx.agent.getTools().map(t => t.name);
 
-  ctx.registerInstruction("subagent-guide", [
+  ctx.agent.registerInstruction("subagent-guide", [
     "You have a spawn_agent tool for delegating work to a subagent with its own context.",
     "The subagent inherits your session history, so write a short directive (what to do), not a briefing (what happened).",
     "Use it for tasks that need multiple tool calls you don't need to see — research, exploration, independent implementation.",
   ].join("\n"));
 
-  ctx.registerTool({
+  ctx.agent.registerTool({
     name: "spawn_agent",
     description:
       "Spawn a subagent with its own fresh context to handle a focused task. " +
@@ -63,7 +63,7 @@ export default function activate(ctx: ExtensionContext): void {
       const task = args.task as string;
       const toolNames = args.tools as string[] | undefined;
 
-      const allTools = ctx.getTools();
+      const allTools = ctx.agent.getTools();
       // Filter to requested tools, or give all tools (minus spawn_agent to prevent recursion)
       const tools = toolNames
         ? allTools.filter(t => toolNames.includes(t.name))