agent-sh 0.1.0

package/dist/event-bus.js

@@ -0,0 +1,79 @@
+import { EventEmitter } from "node:events";
+/**
+ * Typed event bus with two modes:
+ * - emit/on/off: fire-and-forget notifications
+ * - emitPipe/onPipe: synchronous transform chain where each listener
+ *   can modify the payload before passing to the next
+ */
+export class EventBus {
+    emitter = new EventEmitter();
+    pipeListeners = new Map();
+    asyncPipeListeners = new Map();
+    /** Subscribe to a fire-and-forget event. */
+    on(event, fn) {
+        this.emitter.on(event, fn);
+    }
+    /** Unsubscribe from a fire-and-forget event. */
+    off(event, fn) {
+        this.emitter.off(event, fn);
+    }
+    /** Emit a fire-and-forget event. */
+    emit(event, payload) {
+        this.emitter.emit(event, payload);
+    }
+    /** Register a transform listener for a pipeline event. */
+    onPipe(event, fn) {
+        let listeners = this.pipeListeners.get(event);
+        if (!listeners) {
+            listeners = [];
+            this.pipeListeners.set(event, listeners);
+        }
+        listeners.push(fn);
+    }
+    /**
+     * Emit a pipeline event — each registered pipe listener receives the
+     * output of the previous one. Returns the final transformed payload.
+     * If no listeners are registered, returns the original payload unchanged.
+     */
+    emitPipe(event, payload) {
+        const listeners = this.pipeListeners.get(event);
+        if (!listeners)
+            return payload;
+        let result = payload;
+        for (const fn of listeners) {
+            result = fn(result);
+        }
+        return result;
+    }
+    /** Register an async transform listener for a pipeline event. */
+    onPipeAsync(event, fn) {
+        let listeners = this.asyncPipeListeners.get(event);
+        if (!listeners) {
+            listeners = [];
+            this.asyncPipeListeners.set(event, listeners);
+        }
+        listeners.push(fn);
+    }
+    /**
+     * Emit an async pipeline event. Two phases:
+     * 1. Notify — fire regular `on` listeners synchronously (e.g., TUI flushes state)
+     * 2. Transform — run async pipe listeners in series, each receiving the
+     *    output of the previous (e.g., extension provides a permission decision)
+     *
+     * Returns the final transformed payload. If no pipe listeners are registered,
+     * returns the original payload unchanged (with safe defaults).
+     */
+    async emitPipeAsync(event, payload) {
+        // Phase 1: notify (lets renderers prepare for interactive I/O)
+        this.emitter.emit(event, payload);
+        // Phase 2: transform (extensions provide decisions)
+        const listeners = this.asyncPipeListeners.get(event);
+        if (!listeners)
+            return payload;
+        let result = payload;
+        for (const fn of listeners) {
+            result = await fn(result);
+        }
+        return result;
+    }
+}

package/dist/executor.d.ts

@@ -0,0 +1,31 @@
+import { type ChildProcess } from "node:child_process";
+export interface ExecutorSession {
+    id: string;
+    command: string;
+    output: string;
+    exitCode: number | null;
+    done: boolean;
+    truncated: boolean;
+    process: ChildProcess | null;
+    resolve?: () => void;
+}
+/**
+ * Spawn a command in an isolated child process with piped I/O.
+ * Does NOT use the user's PTY — completely separate process.
+ */
+export declare function executeCommand(opts: {
+    command: string;
+    cwd: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    maxOutputBytes?: number;
+    onOutput?: (chunk: string) => void;
+}): {
+    session: ExecutorSession;
+    done: Promise<void>;
+};
+/**
+ * Kill a running session's process group.
+ * Sends SIGTERM first, then SIGKILL after 5 seconds.
+ */
+export declare function killSession(session: ExecutorSession): void;

package/dist/executor.js

@@ -0,0 +1,116 @@
+import { spawn } from "node:child_process";
+import { stripAnsi } from "./utils/ansi.js";
+const DEFAULT_TIMEOUT = 60_000;
+const DEFAULT_MAX_OUTPUT = 256 * 1024; // 256KB
+/**
+ * Spawn a command in an isolated child process with piped I/O.
+ * Does NOT use the user's PTY — completely separate process.
+ */
+export function executeCommand(opts) {
+    const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+    const maxOutput = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT;
+    const session = {
+        id: "",
+        command: opts.command,
+        output: "",
+        exitCode: null,
+        done: false,
+        truncated: false,
+        process: null,
+    };
+    const done = new Promise((resolve) => {
+        session.resolve = resolve;
+    });
+    // Build env — filter undefined values
+    const env = {};
+    const source = opts.env ?? process.env;
+    for (const [k, v] of Object.entries(source)) {
+        if (v !== undefined)
+            env[k] = v;
+    }
+    let child;
+    try {
+        child = spawn("/bin/bash", ["-c", opts.command], {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: opts.cwd,
+            env,
+            detached: true,
+        });
+    }
+    catch (err) {
+        session.exitCode = -1;
+        session.output = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
+        session.done = true;
+        session.resolve?.();
+        return { session, done };
+    }
+    session.process = child;
+    const handleData = (data) => {
+        const raw = data.toString("utf-8");
+        const clean = stripAnsi(raw);
+        // Accumulate cleaned output for the agent
+        session.output += clean;
+        // Enforce output cap — truncate from beginning, keep tail
+        if (session.output.length > maxOutput) {
+            session.output = session.output.slice(-maxOutput);
+            session.truncated = true;
+        }
+        // Real-time streaming callback
+        opts.onOutput?.(raw);
+    };
+    child.stdout?.on("data", handleData);
+    child.stderr?.on("data", handleData);
+    // Timeout handler
+    const timer = setTimeout(() => {
+        if (!session.done) {
+            killSession(session);
+        }
+    }, timeout);
+    child.on("exit", (code, signal) => {
+        clearTimeout(timer);
+        session.exitCode = code ?? (signal ? -1 : null);
+        session.done = true;
+        session.process = null;
+        session.resolve?.();
+    });
+    child.on("error", (err) => {
+        clearTimeout(timer);
+        if (!session.done) {
+            session.exitCode = -1;
+            session.output += `\nProcess error: ${err.message}`;
+            session.done = true;
+            session.process = null;
+            session.resolve?.();
+        }
+    });
+    return { session, done };
+}
+/**
+ * Kill a running session's process group.
+ * Sends SIGTERM first, then SIGKILL after 5 seconds.
+ */
+export function killSession(session) {
+    const proc = session.process;
+    if (!proc || !proc.pid)
+        return;
+    try {
+        // Kill the entire process group
+        process.kill(-proc.pid, "SIGTERM");
+    }
+    catch {
+        // Process may already be dead
+    }
+    // Fallback: SIGKILL after 5 seconds
+    const fallback = setTimeout(() => {
+        if (!session.done && proc.pid) {
+            try {
+                process.kill(-proc.pid, "SIGKILL");
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }, 5000);
+    // Don't let the timer keep the process alive
+    fallback.unref();
+}

package/dist/extension-loader.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionContext } from "./types.js";
+/**
+ * Load extensions from three sources (merged, deduplicated):
+ *
+ * 1. CLI flags: -e / --extensions (npm packages or file paths)
+ * 2. settings.json: ~/.agent-sh/settings.json → extensions[]
+ * 3. Extensions dir: ~/.agent-sh/extensions/ (files and directories with index.{ts,js})
+ *
+ * Extension specifiers resolve as:
+ *   - File path (relative or absolute) → import directly
+ *   - Bare name → npm package (Node resolution)
+ *
+ * Each module should export a default or named `activate(ctx)` function.
+ * Errors are non-fatal — logged via ui:error and skipped.
+ */
+export declare function loadExtensions(ctx: ExtensionContext, cliExtensions?: string[]): Promise<void>;

package/dist/extension-loader.js

@@ -0,0 +1,164 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".agent-sh");
+const EXT_DIR = path.join(CONFIG_DIR, "extensions");
+const SETTINGS_PATH = path.join(CONFIG_DIR, "settings.json");
+const TS_EXTS = [".ts", ".tsx", ".mts"];
+const SCRIPT_EXTS = [".js", ".mjs", ".ts", ".tsx", ".mts"];
+let tsRegistered = false;
+async function ensureTsSupport() {
+    if (tsRegistered)
+        return;
+    try {
+        const { register } = await import("tsx/esm/api");
+        register();
+        tsRegistered = true;
+    }
+    catch {
+        // tsx not available — TS extensions will fail with a clear error
+    }
+}
+async function loadSettings() {
+    try {
+        const raw = await fs.readFile(SETTINGS_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Load extensions from three sources (merged, deduplicated):
+ *
+ * 1. CLI flags: -e / --extensions (npm packages or file paths)
+ * 2. settings.json: ~/.agent-sh/settings.json → extensions[]
+ * 3. Extensions dir: ~/.agent-sh/extensions/ (files and directories with index.{ts,js})
+ *
+ * Extension specifiers resolve as:
+ *   - File path (relative or absolute) → import directly
+ *   - Bare name → npm package (Node resolution)
+ *
+ * Each module should export a default or named `activate(ctx)` function.
+ * Errors are non-fatal — logged via ui:error and skipped.
+ */
+export async function loadExtensions(ctx, cliExtensions) {
+    const specifiers = [];
+    // 1. CLI -e / --extensions
+    if (cliExtensions) {
+        specifiers.push(...cliExtensions);
+    }
+    // 2. settings.json
+    const settings = await loadSettings();
+    if (settings.extensions) {
+        specifiers.push(...settings.extensions);
+    }
+    // 3. ~/.agent-sh/extensions/ directory
+    try {
+        const entries = await fs.readdir(EXT_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(EXT_DIR, entry.name);
+            if (entry.isDirectory()) {
+                // Directory extension: look for index.{ts,js,mjs,...}
+                const indexFile = await findIndex(fullPath);
+                if (indexFile) {
+                    specifiers.push(indexFile);
+                }
+            }
+            else if (SCRIPT_EXTS.some((ext) => entry.name.endsWith(ext))) {
+                specifiers.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist — no user extensions
+    }
+    // Deduplicate
+    const seen = new Set();
+    const unique = specifiers.filter((s) => {
+        if (seen.has(s))
+            return false;
+        seen.add(s);
+        return true;
+    });
+    // Load each extension
+    for (const specifier of unique) {
+        try {
+            const importPath = await resolveSpecifier(specifier);
+            if (TS_EXTS.some((ext) => importPath.endsWith(ext))) {
+                await ensureTsSupport();
+            }
+            const mod = await import(importPath);
+            // tsx may double-wrap default exports: mod.default.default
+            const activate = typeof mod.default === "function"
+                ? mod.default
+                : typeof mod.default?.default === "function"
+                    ? mod.default.default
+                    : mod.activate;
+            if (typeof activate === "function") {
+                activate(ctx);
+            }
+        }
+        catch (err) {
+            ctx.bus.emit("ui:error", {
+                message: `Failed to load extension ${specifier}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+}
+/**
+ * Find an index file in a directory extension.
+ */
+async function findIndex(dir) {
+    for (const ext of SCRIPT_EXTS) {
+        const candidate = path.join(dir, `index${ext}`);
+        try {
+            await fs.access(candidate);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a specifier to an importable string.
+ *
+ * - Relative path (starts with ".") → resolve from cwd, file:// URL
+ * - Absolute path → file:// URL (directories resolved to index file)
+ * - Bare name → npm package (let Node resolve)
+ */
+async function resolveSpecifier(specifier) {
+    let resolved;
+    if (specifier.startsWith(".")) {
+        resolved = path.resolve(process.cwd(), specifier);
+    }
+    else if (path.isAbsolute(specifier)) {
+        resolved = specifier;
+    }
+    else {
+        // Bare specifier — npm package
+        return specifier;
+    }
+    // If it's a directory, find the index file
+    try {
+        const stat = await fs.stat(resolved);
+        if (stat.isDirectory()) {
+            const indexFile = await findIndex(resolved);
+            if (indexFile) {
+                return `file://${indexFile}`;
+            }
+            throw new Error(`No index file found in ${resolved}`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            // Not a directory, treat as file
+        }
+        else if (err instanceof Error && err.message.startsWith("No index")) {
+            throw err;
+        }
+    }
+    return `file://${resolved}`;
+}

package/dist/extensions/file-autocomplete.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionContext } from "../types.js";
+export default function activate({ bus, contextManager }: ExtensionContext): void;

package/dist/extensions/file-autocomplete.js

@@ -0,0 +1,63 @@
+/**
+ * File autocomplete extension.
+ *
+ * Provides @-triggered file path completion in agent input mode.
+ * Responds to "autocomplete:request" pipe events by listing files
+ * matching the path after the @ trigger.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export default function activate({ bus, contextManager }) {
+    bus.onPipe("autocomplete:request", (payload) => {
+        const atPos = payload.buffer.lastIndexOf("@");
+        if (atPos < 0 || (atPos > 0 && payload.buffer[atPos - 1] !== " ")) {
+            return payload;
+        }
+        const afterAt = payload.buffer.slice(atPos + 1);
+        if (afterAt.includes(" ") || !/^[a-zA-Z0-9_.\/-]*$/.test(afterAt)) {
+            return payload;
+        }
+        const files = listFiles(afterAt, contextManager.getCwd());
+        if (files.length === 0)
+            return payload;
+        return { ...payload, items: [...payload.items, ...files] };
+    });
+}
+function listFiles(query, cwd) {
+    const lastSlash = query.lastIndexOf("/");
+    let searchDir;
+    let prefix;
+    let basePath;
+    if (lastSlash >= 0) {
+        basePath = query.slice(0, lastSlash + 1);
+        searchDir = path.resolve(cwd, query.slice(0, lastSlash) || ".");
+        prefix = query.slice(lastSlash + 1);
+    }
+    else {
+        basePath = "";
+        searchDir = cwd;
+        prefix = query;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(searchDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => !e.name.startsWith(".") &&
+        e.name.toLowerCase().startsWith(prefix.toLowerCase()))
+        .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    })
+        .slice(0, 15)
+        .map((e) => ({
+        name: basePath + e.name + (e.isDirectory() ? "/" : ""),
+        description: e.isDirectory() ? "dir" : "",
+    }));
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+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 };
+    });
+}

package/dist/extensions/slash-commands.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionContext } from "../types.js";
+export default function activate({ bus, getAcpClient, quit }: ExtensionContext): void;

package/dist/extensions/slash-commands.js

@@ -0,0 +1,105 @@
+/**
+ * Slash commands extension.
+ *
+ * Registers built-in slash commands on the event bus:
+ * - Responds to "autocomplete:request" pipe for /-prefixed completions
+ * - Handles "command:execute" events and dispatches to matching handler
+ * - Uses "ui:info"/"ui:error" for user feedback (no direct TUI dependency)
+ */
+import { execSync } from "node:child_process";
+import { palette as p } from "../utils/palette.js";
+export default function activate({ bus, getAcpClient, quit }) {
+    const commands = [
+        {
+            name: "/help",
+            description: "Show available commands",
+            handler: () => {
+                const lines = commands.map((c) => `  ${p.accent}${c.name.padEnd(12)}${p.reset} ${c.description}`);
+                bus.emit("ui:info", { message: "Available commands:\n" + lines.join("\n") });
+            },
+        },
+        {
+            name: "/clear",
+            description: "Start a new agent session",
+            handler: async () => {
+                try {
+                    await getAcpClient().resetSession();
+                    bus.emit("ui:info", { message: "Session cleared." });
+                }
+                catch (err) {
+                    bus.emit("ui:error", {
+                        message: `Failed to reset session: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+            },
+        },
+        {
+            name: "/copy",
+            description: "Copy last agent response to clipboard",
+            handler: () => {
+                const text = getAcpClient().getLastResponseText();
+                if (!text) {
+                    bus.emit("ui:info", { message: "No agent response to copy." });
+                    return;
+                }
+                try {
+                    if (process.platform === "darwin") {
+                        execSync("pbcopy", { input: text });
+                    }
+                    else {
+                        execSync("xclip -selection clipboard", { input: text });
+                    }
+                    bus.emit("ui:info", { message: "Copied to clipboard." });
+                }
+                catch {
+                    bus.emit("ui:error", { message: "Failed to copy to clipboard." });
+                }
+            },
+        },
+        {
+            name: "/compact",
+            description: "Ask agent to summarize the conversation",
+            handler: async () => {
+                await getAcpClient().sendPrompt("Please provide a concise summary of our conversation so far and the current state of the work.");
+            },
+        },
+        {
+            name: "/quit",
+            description: "Exit agent-sh",
+            handler: () => {
+                quit();
+            },
+        },
+    ];
+    // Provide command completions for /-prefixed input
+    bus.onPipe("autocomplete:request", (payload) => {
+        if (!payload.buffer.startsWith("/"))
+            return payload;
+        const prefix = payload.buffer.toLowerCase();
+        const matching = commands
+            .filter((c) => c.name.toLowerCase().startsWith(prefix))
+            .map((c) => ({ name: c.name, description: c.description }));
+        if (matching.length === 0)
+            return payload;
+        return { ...payload, items: [...payload.items, ...matching] };
+    });
+    // Handle command execution
+    bus.on("command:execute", (e) => {
+        const cmd = commands.find((c) => c.name === e.name);
+        if (cmd) {
+            const result = cmd.handler(e.args);
+            if (result instanceof Promise) {
+                result.catch((err) => {
+                    bus.emit("ui:error", {
+                        message: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+        }
+        else {
+            bus.emit("ui:info", {
+                message: `Unknown command: ${e.name}. Type /help for available commands.`,
+            });
+        }
+    });
+}

package/dist/extensions/tui-renderer.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionContext } from "../types.js";
+export default function activate({ bus }: ExtensionContext): void;