agent-sh 0.10.0 → 0.10.1

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

@@ -5,9 +5,12 @@
  * 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).
+ * The bridge is a pure protocol translator between pi's event stream and
+ * agent-sh's bus events. Pi brings its own tools for command execution,
+ * file ops, etc. PTY-access tools (`terminal_read`, `terminal_keys`,
+ * `user_shell`) are intentionally NOT bundled here — if you want pi to
+ * observe or mutate the user's live terminal, load a companion extension
+ * that registers those tools in pi's ToolDefinition format.
  *
  * Setup:
  *   npm install @mariozechner/pi-agent-core @mariozechner/pi-ai @mariozechner/pi-coding-agent
@@ -22,157 +25,13 @@ import {
   createAgentSessionRuntime,
   SessionManager,
 } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
 import type { ExtensionContext } from "agent-sh/types";
-import type { EventBus } from "agent-sh/event-bus";
-
-// ── Helpers ──────────────────────────────────────────────────────
-function interpretEscapes(str: string): string {
-  return str.replace(/\\(x[0-9a-fA-F]{2}|r|n|t|\\|0)/g, (_, seq: string) => {
-    if (seq === "r") return "\r";
-    if (seq === "n") return "\n";
-    if (seq === "t") return "\t";
-    if (seq === "\\") return "\\";
-    if (seq === "0") return "\0";
-    if (seq.startsWith("x")) return String.fromCharCode(parseInt(seq.slice(1), 16));
-    return seq;
-  });
-}
-
-function settle(ms = 100): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// ── 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 };
-    },
-  };
-}
-
-// ── terminal_read as a pi ToolDefinition ─────────────────────────
-function createTerminalReadToolDef(ctx: ExtensionContext) {
-  return {
-    name: "terminal_read",
-    label: "terminal_read",
-    description:
-      "Read the current terminal screen contents. Returns clean text (ANSI stripped) " +
-      "with cursor position and whether an alternate-screen program (vim, htop, less) is active.",
-    promptSnippet: "Read the terminal screen to see what the user sees.",
-    promptGuidelines: [
-      "Use terminal_read to see the current terminal screen before sending keystrokes.",
-      "Check altScreen to know if a full-screen program (vim, htop) is running.",
-    ],
-    parameters: Type.Object({}),
-    async execute() {
-      const tb = ctx.terminalBuffer;
-      if (!tb) return { content: [{ type: "text", text: "terminal buffer not available" }], details: undefined };
-      const { text, altScreen, cursorX, cursorY } = tb.readScreen();
-      const info = [
-        altScreen ? "mode: alternate screen" : "mode: normal",
-        `cursor: row=${cursorY} col=${cursorX}`,
-      ].join(", ");
-      return { content: [{ type: "text", text: `[${info}]\n\n${text}` }], details: undefined };
-    },
-  };
-}
-
-// ── terminal_keys as a pi ToolDefinition ─────────────────────────
-function createTerminalKeysToolDef(bus: EventBus, ctx: ExtensionContext) {
-  return {
-    name: "terminal_keys",
-    label: "terminal_keys",
-    description:
-      "Send keystrokes to the user's live terminal as if the user typed them. " +
-      "Use escape sequences: \\x1b for Escape, \\r for Enter, \\t for Tab, " +
-      "\\x03 for Ctrl+C, \\x1b[A/B/C/D for arrow keys, \\x7f for Backspace. " +
-      "Example: \\x1b:q!\\r to quit vim. Always call terminal_read after.",
-    promptSnippet: "Send keystrokes to interactive programs in the terminal.",
-    promptGuidelines: [
-      "Use terminal_keys to type into interactive programs (vim, htop, less).",
-      "Always call terminal_read after sending keys to verify the result.",
-    ],
-    parameters: Type.Object({
-      keys: Type.String({ description: "Keystrokes to send (use \\x1b for Escape, \\r for Enter, etc.)" }),
-      settle_ms: Type.Optional(
-        Type.Number({ description: "Wait time in ms after sending keys (default: 150)" }),
-      ),
-    }),
-    async execute(_toolCallId: string, params: any) {
-      const keys = interpretEscapes(params.keys);
-      const settleMs = params.settle_ms ?? 150;
-      bus.emit("shell:stdout-show", {});
-      process.stdout.write("\n");
-      bus.emit("shell:pty-write", { data: keys });
-      await settle(settleMs);
-
-      const tb = ctx.terminalBuffer;
-      if (!tb) return { content: [{ type: "text", text: "Keys sent." }], details: undefined };
-      const { text, altScreen, cursorX, cursorY } = tb.readScreen();
-      const info = [
-        altScreen ? "mode: alternate screen" : "mode: normal",
-        `cursor: row=${cursorY} col=${cursorX}`,
-      ].join(", ");
-      return { content: [{ type: "text", text: `Keys sent. Screen after:\n[${info}]\n\n${text}` }], details: undefined };
-    },
-  };
-}
 
 // ── Extension entry point ─────────────────────────────────────────
 export default function activate(ctx: ExtensionContext): void {
   const { bus } = ctx;
   const cwd = process.cwd();
 
-  const userShellTool = createUserShellToolDef(bus);
-  const termReadTool = createTerminalReadToolDef(ctx);
-  const termKeysTool = createTerminalKeysToolDef(bus, ctx);
-
   // ── Boot pi session (async — register backend synchronously first) ──
   let session: any = null;
   let runtime: any = null;
@@ -190,7 +49,6 @@ export default function activate(ctx: ExtensionContext): void {
         const result = await createAgentSessionFromServices({
           services,
           sessionManager: opts.sessionManager ?? sessionManager,
-          customTools: [userShellTool, termReadTool, termKeysTool],
         });
         return { ...result, services };
       };
@@ -227,9 +85,7 @@ export default function activate(ctx: ExtensionContext): void {
             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",
+              kind: (event as any).toolName === "bash" ? "execute" : "read",
             });
             break;
 
@@ -251,9 +107,7 @@ export default function activate(ctx: ExtensionContext): void {
             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",
+              kind: (event as any).toolName === "bash" ? "execute" : "read",
             });
             break;
 

package/package.json

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

package/dist/extensions/shell-recall.d.ts

@@ -1,9 +0,0 @@
-/**
- * Shell recall extension.
- *
- * Intercepts __shell_recall terminal commands via the
- * "agent:terminal-intercept" pipe, returning virtual output from
- * ContextManager's recall API without spawning a subprocess.
- */
-import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, contextManager }: ExtensionContext): void;

package/dist/extensions/shell-recall.js

@@ -1,8 +0,0 @@
-export default function activate({ bus, contextManager }) {
-    bus.onPipe("agent:terminal-intercept", (payload) => {
-        if (!payload.command.trimStart().startsWith("__shell_recall"))
-            return payload;
-        const output = contextManager.handleRecallCommand(payload.command.trim());
-        return { ...payload, intercepted: true, output };
-    });
-}