agent-sh 0.4.0 → 0.6.0

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

@@ -0,0 +1,263 @@
+/**
+ * Pi bridge — runs pi's full coding agent in-process as agent-sh's backend.
+ *
+ * Uses pi's own AgentSession with its full configuration: model registry,
+ * provider settings, extensions, session management, and tool system.
+ * Agent-sh provides the shell frontend and TUI rendering.
+ *
+ * In addition to pi's built-in tools, this bridge registers `user_shell`
+ * so pi can execute commands in agent-sh's live PTY (visible to the user,
+ * affects shell state like cd/export/source).
+ *
+ * Setup:
+ *   npm install @mariozechner/pi-agent-core @mariozechner/pi-ai @mariozechner/pi-coding-agent
+ *
+ * Usage:
+ *   agent-sh -e examples/extensions/pi-bridge
+ */
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+import {
+  createAgentSessionServices,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  SessionManager,
+} from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { ExtensionContext } from "../../src/types.js";
+import type { EventBus } from "../../src/event-bus.js";
+
+// ── agent-sh context injected via tool promptGuidelines + promptSnippet ──
+
+// ── user_shell as a pi ToolDefinition ─────────────────────────────
+function createUserShellToolDef(bus: EventBus) {
+  // Track agent-sh's live cwd so user_shell always runs in the right place
+  let liveCwd = process.cwd();
+  bus.on("shell:cwd-change", ({ cwd }) => { liveCwd = cwd; });
+
+  const schema = Type.Object({
+    command: Type.String({ description: "Command to execute in user's shell" }),
+    return_output: Type.Optional(
+      Type.Boolean({
+        description:
+          "Whether to return the command output. Default false — output is shown directly to the user.",
+      }),
+    ),
+  });
+
+  return {
+    name: "user_shell",
+    label: "user_shell",
+    description:
+      "Run a command with lasting effects in the user's live shell (cd, export, " +
+      "install packages, start servers) or show output the user wants to see. " +
+      "Output is shown directly to the user. Set return_output=true only " +
+      "if you need to inspect the result.",
+    promptSnippet: "Execute commands in the user's live terminal (PTY).",
+    promptGuidelines: [
+      "You are running inside agent-sh, a terminal wrapper.",
+      "Use your standard tools (bash, file ops) for investigation — output goes to you, not the user.",
+      "Use user_shell to run commands in the user's live shell when they ask to see output or need lasting effects (cd, install, start servers).",
+      "Default to standard tools. Use user_shell when the user is the intended audience for the output or the command has real effects.",
+    ],
+    parameters: schema,
+
+    async execute(_toolCallId, params) {
+      const command = params.command;
+      const returnOutput = params.return_output ?? false;
+
+      const result = await bus.emitPipeAsync("shell:exec-request", {
+        command,
+        output: "",
+        cwd: liveCwd,
+        done: false,
+      });
+
+      const text = returnOutput
+        ? result.output || "(no output)"
+        : "Command executed.";
+
+      return { content: [{ type: "text", text }], details: undefined };
+    },
+  };
+}
+
+// ── Extension entry point ─────────────────────────────────────────
+export default function activate(ctx: ExtensionContext): void {
+  const { bus } = ctx;
+  const cwd = process.cwd();
+
+  const userShellTool = createUserShellToolDef(bus);
+
+  // ── Boot pi session (async — register backend synchronously first) ──
+  let session: any = null;
+  let runtime: any = null;
+  let booting = true;
+
+  const boot = async () => {
+    try {
+      // Pi loads its own config: ~/.pi/agent/settings.json, models, extensions
+      const services = await createAgentSessionServices({ cwd });
+      const sessionManager = SessionManager.inMemory(cwd);
+
+      // createRuntime factory — returns { session, services, ... } as expected
+      // by createAgentSessionRuntime
+      const createRuntime = async (opts: any) => {
+        const result = await createAgentSessionFromServices({
+          services,
+          sessionManager: opts.sessionManager ?? sessionManager,
+          customTools: [userShellTool],
+        });
+        return { ...result, services };
+      };
+
+      runtime = await createAgentSessionRuntime(createRuntime, {
+        cwd,
+        sessionManager,
+      });
+      session = runtime.session;
+
+      // Subscribe to pi events → agent-sh bus
+      let fullResponseText = "";
+
+      session.subscribe((event: AgentEvent) => {
+        switch (event.type) {
+          case "agent_start":
+            fullResponseText = "";
+            break;
+
+          case "message_update": {
+            const ame = (event as any).assistantMessageEvent;
+            if (ame.type === "text_delta") {
+              bus.emitTransform("agent:response-chunk", {
+                blocks: [{ type: "text" as const, text: ame.delta }],
+              });
+              fullResponseText += ame.delta;
+            } else if (ame.type === "thinking_delta") {
+              bus.emit("agent:thinking-chunk", { text: ame.delta });
+            }
+            break;
+          }
+
+          case "tool_execution_start":
+            bus.emit("agent:tool-started", {
+              title: (event as any).toolName,
+              toolCallId: (event as any).toolCallId,
+              kind: (event as any).toolName === "user_shell" || (event as any).toolName === "bash"
+                ? "execute"
+                : "read",
+            });
+            break;
+
+          case "tool_execution_update": {
+            const pr = (event as any).partialResult as
+              | { content?: Array<{ type: string; text?: string }> }
+              | undefined;
+            if (pr?.content) {
+              for (const c of pr.content) {
+                if (c.type === "text" && c.text) {
+                  bus.emit("agent:tool-output-chunk", { chunk: c.text });
+                }
+              }
+            }
+            break;
+          }
+
+          case "tool_execution_end":
+            bus.emit("agent:tool-completed", {
+              toolCallId: (event as any).toolCallId,
+              exitCode: (event as any).isError ? 1 : 0,
+              kind: (event as any).toolName === "user_shell" || (event as any).toolName === "bash"
+                ? "execute"
+                : "read",
+            });
+            break;
+
+          case "agent_end":
+            bus.emitTransform("agent:response-done", {
+              response: fullResponseText,
+            });
+            bus.emit("agent:processing-done", {});
+            break;
+        }
+      });
+
+      // Report model info
+      const model = session.model;
+      bus.emit("agent:info", {
+        name: "pi",
+        version: "0.66",
+        model: model ? `${model.provider}/${model.id}` : undefined,
+      });
+
+      booting = false;
+    } catch (err) {
+      booting = false;
+      bus.emit("ui:error", {
+        message: `pi-bridge: failed to initialize — ${err instanceof Error ? err.message : String(err)}`,
+      });
+    }
+  };
+
+  // ── Bus listeners (wired on start, unwired on kill) ────────────
+  const listeners: Array<{ event: string; fn: Function }> = [];
+
+  const wireListeners = () => {
+    const onSubmit = async ({ query }: any) => {
+      if (!session) {
+        bus.emit("agent:error", {
+          message: booting ? "pi is still starting up..." : "pi session not initialized",
+        });
+        bus.emit("agent:processing-done", {});
+        return;
+      }
+
+      bus.emit("agent:query", { query });
+      bus.emit("agent:processing-start", {});
+
+      try {
+        await session.prompt(query);
+      } catch (err) {
+        bus.emit("agent:error", {
+          message: err instanceof Error ? err.message : String(err),
+        });
+        bus.emit("agent:processing-done", {});
+      }
+    };
+
+    const onCancel = async () => { await session?.abort(); };
+    const onReset = async () => {
+      await runtime?.newSession();
+      session = runtime?.session;
+    };
+
+    bus.on("agent:submit", onSubmit);
+    bus.on("agent:cancel-request", onCancel);
+    bus.on("agent:reset-session", onReset);
+    listeners.push(
+      { event: "agent:submit", fn: onSubmit },
+      { event: "agent:cancel-request", fn: onCancel },
+      { event: "agent:reset-session", fn: onReset },
+    );
+  };
+
+  const unwireListeners = () => {
+    for (const { event, fn } of listeners) bus.off(event as any, fn as any);
+    listeners.length = 0;
+  };
+
+  // ── Register as backend ───────────────────────────────────────
+  bus.emit("agent:register-backend", {
+    name: "pi",
+    start: async () => {
+      await boot();
+      wireListeners();
+    },
+    kill: () => {
+      unwireListeners();
+      runtime?.dispose();
+      session = null;
+      runtime = null;
+      booting = true;
+    },
+  });
+}

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

@@ -0,0 +1,13 @@
+{
+  "name": "agent-sh-pi-bridge",
+  "version": "0.1.0",
+  "description": "Pi coding agent backend for agent-sh",
+  "type": "module",
+  "main": "index.ts",
+  "dependencies": {
+    "@mariozechner/pi-agent-core": "^0.66.0",
+    "@mariozechner/pi-ai": "^0.66.0",
+    "@mariozechner/pi-coding-agent": "^0.66.0",
+    "@sinclair/typebox": "^0.34.0"
+  }
+}

package/examples/extensions/secret-guard.ts

@@ -0,0 +1,100 @@
+/**
+ * Secret guard extension.
+ *
+ * Redacts sensitive patterns (API keys, tokens, passwords) from tool output
+ * — both the streamed terminal display and the content sent back to the LLM.
+ *
+ * Usage:
+ *   agent-sh -e ./examples/extensions/secret-guard.ts
+ *
+ *   # Or install permanently:
+ *   cp examples/extensions/secret-guard.ts ~/.agent-sh/extensions/
+ *
+ * Configuration (~/.agent-sh/settings.json):
+ *   {
+ *     "secret-guard": {
+ *       "extraPatterns": ["CUSTOM_\\w+=\\S+"],
+ *       "redactText": "***REDACTED***"
+ *     }
+ *   }
+ */
+import type { ExtensionContext } from "agent-sh/types";
+
+// Common secret patterns — each matches key=value or key: value formats
+const DEFAULT_PATTERNS = [
+  // API keys and tokens (generic)
+  /(?:api[_-]?key|api[_-]?secret|access[_-]?token|auth[_-]?token|secret[_-]?key|private[_-]?key)\s*[=:]\s*\S+/gi,
+  // AWS
+  /(?:AKIA|ASIA)[A-Z0-9]{16}/g,
+  /(?:aws_secret_access_key|aws_session_token)\s*[=:]\s*\S+/gi,
+  // Bearer tokens
+  /Bearer\s+[A-Za-z0-9\-._~+/]+=*/g,
+  // GitHub tokens
+  /gh[pousr]_[A-Za-z0-9_]{36,}/g,
+  // Anthropic / OpenAI keys
+  /sk-(?:ant-)?[A-Za-z0-9\-_]{10,}/g,
+  // Generic long hex/base64 secrets (env var assignment)
+  /(?:SECRET|TOKEN|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY)\s*[=:]\s*\S+/gi,
+  // Connection strings with passwords
+  /[a-z+]+:\/\/[^:]+:[^@\s]+@/gi,
+];
+
+export default function activate(ctx: ExtensionContext) {
+  const { bus } = ctx;
+  const config = ctx.getExtensionSettings("secret-guard", {
+    extraPatterns: [] as string[],
+    redactText: "***REDACTED***",
+  });
+
+  const patterns = [
+    ...DEFAULT_PATTERNS,
+    ...config.extraPatterns.map((p: string) => new RegExp(p, "gi")),
+  ];
+
+  function redact(text: string): string {
+    let result = text;
+    for (const pattern of patterns) {
+      // Reset lastIndex for stateful regex (global flag)
+      pattern.lastIndex = 0;
+      result = result.replace(pattern, config.redactText);
+    }
+    return result;
+  }
+
+  // Redact the dynamic context (shell history, cwd, etc.) before it's sent
+  // to the LLM. This is the chokepoint — everything the model sees passes
+  // through dynamic-context:build.
+  ctx.advise("dynamic-context:build", (next) => {
+    return redact(next());
+  });
+
+  // Advise tool:execute to wrap both streaming output and final result.
+  // Chunks from child processes arrive at arbitrary byte boundaries, so a
+  // secret like "sk-ant-abc123" could be split across two chunks.  We
+  // line-buffer: accumulate until we see '\n', redact complete lines, flush.
+  ctx.advise("tool:execute", async (next, toolCtx) => {
+    const origOnChunk = toolCtx.onChunk;
+    if (origOnChunk) {
+      let buf = "";
+      toolCtx.onChunk = (chunk: string) => {
+        buf += chunk;
+        const lastNl = buf.lastIndexOf("\n");
+        if (lastNl !== -1) {
+          // Flush all complete lines, redacted
+          origOnChunk(redact(buf.slice(0, lastNl + 1)));
+          buf = buf.slice(lastNl + 1);
+        }
+      };
+
+      const result = await next(toolCtx);
+
+      // Flush any remaining partial line
+      if (buf) origOnChunk(redact(buf));
+
+      return { ...result, content: redact(result.content) };
+    }
+
+    const result = await next(toolCtx);
+    return { ...result, content: redact(result.content) };
+  });
+}

package/examples/extensions/subagents.ts

@@ -0,0 +1,87 @@
+/**
+ * Subagent extension — lets the main agent spawn focused sub-agents.
+ *
+ * The main agent gets a `spawn_agent` tool that creates a fresh agent
+ * with its own context. The LLM decides how to specialize — no
+ * predefined categories, no registry, no config.
+ *
+ * Usage:
+ *   agent-sh -e ./examples/extensions/subagents.ts
+ */
+import type { ExtensionContext } from "../../src/types.js";
+import { runSubagent } from "../../src/agent/subagent.js";
+
+export default function activate(ctx: ExtensionContext): void {
+  const { bus, llmClient, contextManager } = ctx;
+  if (!llmClient) return;
+
+  const allToolNames = () => ctx.getTools().map(t => t.name);
+
+  ctx.registerTool({
+    name: "spawn_agent",
+    description:
+      "Spawn a subagent with its own fresh context to handle a focused task. " +
+      "Use this to delegate work that needs investigation or multiple tool calls, " +
+      "without polluting your main conversation context. " +
+      "The subagent runs to completion and returns its result.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "Clear description of what the subagent should do",
+        },
+        tools: {
+          type: "array",
+          items: { type: "string" },
+          description: `Tool names the subagent can use. Available: ${allToolNames().join(", ")}`,
+        },
+      },
+      required: ["task"],
+    },
+
+    showOutput: false,
+
+    getDisplayInfo: () => ({
+      kind: "execute",
+    }),
+
+    async execute(args) {
+      const task = args.task as string;
+      const toolNames = args.tools as string[] | undefined;
+
+      const allTools = ctx.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))
+        : allTools.filter(t => t.name !== "spawn_agent");
+
+      const systemPrompt =
+        `You are a focused subagent. Complete the task and return a clear, concise result.\n` +
+        `Working directory: ${contextManager.getCwd()}`;
+
+      try {
+        const result = await runSubagent({
+          llmClient,
+          tools,
+          systemPrompt,
+          task,
+          bus,
+          maxIterations: 25,
+        });
+
+        return {
+          content: result || "(no response)",
+          exitCode: 0,
+          isError: false,
+        };
+      } catch (err) {
+        return {
+          content: `Subagent error: ${err instanceof Error ? err.message : String(err)}`,
+          exitCode: 1,
+          isError: true,
+        };
+      }
+    },
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-sh",
-  "version": "0.4.0",
-  "description": "A shell-first terminal where any ACP-compatible AI agent is one keystroke away",
+  "version": "0.6.0",
+  "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
   "types": "dist/core.d.ts",
@@ -39,8 +39,6 @@
     "dev": "tsx src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
-    "pi": "node dist/index.js --agent pi-acp",
-    "claude": "node dist/index.js --agent claude-agent-acp",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -67,10 +65,10 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "^0.18.1",
     "cli-highlight": "^2.1.11",
     "marked": "^17.0.6",
     "node-pty": "^1.2.0-beta.12",
+    "openai": "^6.34.0",
     "tsx": "^4.19.0"
   },
   "devDependencies": {

package/dist/acp-client.d.ts

@@ -1,105 +0,0 @@
-import type { EventBus } from "./event-bus.js";
-import type { ContextManager } from "./context-manager.js";
-import type { AgentShellConfig } from "./types.js";
-export declare class AcpClient {
-    private agentProcess;
-    private connection;
-    private sessionId;
-    private bus;
-    private contextManager;
-    private config;
-    private promptInProgress;
-    private currentResponseText;
-    private lastResponseText;
-    private terminalSessions;
-    private terminalDonePromises;
-    private terminalCounter;
-    private fileWatcher;
-    private pendingToolCalls;
-    private autoCancelled;
-    private pendingToolCounter;
-    private agentInfo;
-    private modes;
-    private currentModeId;
-    constructor(opts: {
-        bus: EventBus;
-        contextManager: ContextManager;
-        config: AgentShellConfig;
-    });
-    start(): Promise<void>;
-    /**
-     * Send a user query to the agent.
-     */
-    private firstPromptSent;
-    private static readonly SESSION_ORIENTATION;
-    sendPrompt(query: string, opts?: {
-        modeInstruction?: string;
-        modeLabel?: string;
-    }): Promise<void>;
-    /**
-     * Silently cancel the prompt after a shell tool completes.
-     * Unlike user-initiated cancel(), this doesn't show "(cancelled)" —
-     * the tool already ran, we just skip the unnecessary LLM follow-up.
-     */
-    private autoCancel;
-    /**
-     * Cancel the current prompt and force-recover shell mode.
-     */
-    cancel(): Promise<void>;
-    /**
-     * Start a new ACP session, clearing agent-side conversation history.
-     */
-    resetSession(): Promise<void>;
-    /**
-     * Get the text of the last agent response (for /copy).
-     */
-    getLastResponseText(): string;
-    /**
-     * Get agent information for display.
-     */
-    getAgentInfo(): {
-        name: string;
-        version: string;
-    } | null;
-    getModel(): string | undefined;
-    /**
-     * Get the current mode (e.g. thinking level).
-     */
-    getCurrentMode(): {
-        id: string;
-        name: string;
-    } | null;
-    /**
-     * Check if agent is connected.
-     */
-    isConnected(): boolean;
-    /**
-     * Parse modes from a session response and notify listeners.
-     */
-    private updateModes;
-    /**
-     * Cycle to the next session mode.
-     */
-    private cycleMode;
-    private log;
-    /**
-     * Create the Client handler that responds to agent requests.
-     */
-    private createClientHandler;
-    private handleSessionUpdate;
-    private handleRequestPermission;
-    private handleCreateTerminal;
-    private handleTerminalOutput;
-    private handleWaitForTerminalExit;
-    private handleKillTerminal;
-    private handleReleaseTerminal;
-    private handleReadTextFile;
-    private handleWriteTextFile;
-    /**
-     * After the agent finishes, check all tracked files for changes
-     * made via the agent's own tools (not through fs/writeTextFile)
-     * and show interactive diff previews.
-     */
-    private showPendingFileChanges;
-    kill(): void;
-}