agent-sh 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { Shell } from "./shell.js";
 import { createCore } from "./core.js";
 import { palette as p } from "./utils/palette.js";
@@ -10,35 +10,63 @@ import shellRecall from "./extensions/shell-recall.js";
 import shellExec from "./extensions/shell-exec.js";
 import { loadExtensions } from "./extension-loader.js";
 /**
- * Capture the user's full shell environment by running a quick interactive
- * subshell. This picks up env vars exported in .zshrc/.bashrc that the
- * Node.js process (which was spawned before the PTY sources rc files)
- * doesn't have.
+ * Capture the user's full shell environment asynchronously.
+ * This picks up env vars exported in .zshrc/.bashrc that the
+ * Node.js process doesn't have.
+ *
+ * Uses -l (login shell) instead of -i to avoid TTY blocking issues.
  */
-function captureShellEnv(shell) {
-    try {
-        const output = execFileSync(shell, ["-i", "-c", "env -0"], {
-            encoding: "utf-8",
-            timeout: 5000,
-            stdio: ["pipe", "pipe", "pipe"], // suppress interactive noise on stderr
-        });
-        const env = {};
-        for (const entry of output.split("\0")) {
-            const eq = entry.indexOf("=");
-            if (eq > 0)
-                env[entry.slice(0, eq)] = entry.slice(eq + 1);
+async function captureShellEnvAsync(shell) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(shell, ["-l", "-c", "env -0"], {
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            });
+            let output = "";
+            child.stdout?.on("data", (data) => {
+                output += data.toString("utf-8");
+            });
+            child.on("close", (code) => {
+                if (code !== 0 || !output) {
+                    resolve({}); // Return empty to trigger fallback
+                    return;
+                }
+                const env = {};
+                for (const entry of output.split("\0")) {
+                    const eq = entry.indexOf("=");
+                    if (eq > 0)
+                        env[entry.slice(0, eq)] = entry.slice(eq + 1);
+                }
+                resolve(env);
+            });
+            child.on("error", () => {
+                resolve({}); // Return empty to trigger fallback
+            });
+            // Safety timeout
+            setTimeout(() => {
+                child.kill("SIGTERM");
+                resolve({});
+            }, 5000);
         }
-        return env;
-    }
-    catch {
-        // Fallback: use Node's own environment
-        const env = {};
-        for (const [k, v] of Object.entries(process.env)) {
-            if (v !== undefined)
-                env[k] = v;
+        catch {
+            resolve({});
+        }
+    });
+}
+/**
+ * Merge captured shell env into base env, only adding keys that don't exist.
+ * This preserves any runtime modifications while adding missing shell vars.
+ */
+function mergeShellEnv(baseEnv, shellEnv) {
+    const merged = { ...baseEnv };
+    for (const [key, value] of Object.entries(shellEnv)) {
+        // Only add if key doesn't exist or is empty in base env
+        if (!(key in merged) || !merged[key]) {
+            merged[key] = value;
         }
-        return env;
     }
+    return merged;
 }
 function parseArgs(argv) {
     // Priority: CLI args > Environment variables > Config file > Defaults
@@ -111,7 +139,7 @@ Inside the shell:
     }
     return { agentCommand, agentArgs, shell, model, extensions };
 }
-function formatAgentInfo(agentInfo, model) {
+function formatAgentInfo(agentInfo, model, thoughtLevel) {
     const name = agentInfo.name.replace(/-acp$/, "").replace(/-/g, " ");
     let infoStr = `${p.dim}${name}${p.reset}`;
     if (model) {
@@ -121,17 +149,51 @@ function formatAgentInfo(agentInfo, model) {
             .replace(/^google\//i, "");
         infoStr += ` ${p.dim}(${cleanModel})${p.reset}`;
     }
+    if (thoughtLevel) {
+        // Clean up verbose mode names like "Thinking: medium" → "medium"
+        const label = thoughtLevel.replace(/^Thinking:\s*/i, "");
+        infoStr += ` ${p.dim}[${label}]${p.reset}`;
+    }
     return `${infoStr} ${p.success}●${p.reset}`;
 }
 async function main() {
+    // Set up signal handlers before any terminal operations.
+    // Ignore SIGTTOU to prevent suspension when modifying terminal settings.
+    process.on("SIGTTOU", () => { });
+    // Also ignore SIGTTIN which can occur when reading from terminal while backgrounded.
+    process.on("SIGTTIN", () => { });
     const config = parseArgs(process.argv.slice(2));
-    // Capture the user's shell environment (picks up vars from .zshrc/.bashrc
-    // that the Node process doesn't have)
-    config.shellEnv = captureShellEnv(config.shell || process.env.SHELL || "/bin/bash");
+    // Start with current process environment (fast, non-blocking)
+    // We'll enrich it with shell env asynchronously in the background
+    const baseEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            baseEnv[k] = v;
+    }
+    config.shellEnv = baseEnv;
+    // Asynchronously capture full shell environment without blocking startup
+    const shellPath = config.shell || process.env.SHELL || "/bin/bash";
+    captureShellEnvAsync(shellPath).then((shellEnv) => {
+        if (Object.keys(shellEnv).length > 0) {
+            const merged = mergeShellEnv(config.shellEnv, shellEnv);
+            config.shellEnv = merged;
+            if (process.env.DEBUG) {
+                console.error('[agent-sh] Shell environment enriched asynchronously');
+            }
+        }
+    }).catch(() => {
+        // Ignore errors, we already have process.env as fallback
+    });
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Using current process environment (async enrichment pending)');
+    }
     // ── Core (frontend-agnostic) ──────────────────────────────────
     const core = createCore(config);
     const { bus, client } = core;
     // ── Interactive frontend ──────────────────────────────────────
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Setting up interactive frontend...');
+    }
     process.stdout.write(`\x1b]0;agent-sh\x07`);
     const cols = process.stdout.columns || 80;
     const rows = process.stdout.rows || 24;
@@ -143,6 +205,12 @@ async function main() {
         }
         process.exit(0);
     };
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Creating Shell...');
+    }
+    // Small delay on macOS to ensure we're fully in the foreground process group
+    // before spawning the PTY. This prevents SIGTTOU suspension.
+    await new Promise(resolve => setTimeout(resolve, 100));
     const shell = new Shell({
         bus,
         cols,
@@ -154,32 +222,86 @@ async function main() {
                 const agentInfo = client.getAgentInfo();
                 const model = client.getModel();
                 if (agentInfo) {
-                    return { info: formatAgentInfo(agentInfo, model) };
+                    const mode = client.getCurrentMode();
+                    return { info: formatAgentInfo(agentInfo, model, mode?.name ?? null) };
                 }
             }
             return { info: "" };
         },
     });
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Shell created');
+    }
     // ── Extensions ────────────────────────────────────────────────
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Setting up extensions...');
+    }
     const extCtx = core.extensionContext({ quit: cleanup });
     tuiRenderer(extCtx);
     slashCommands(extCtx);
     fileAutocomplete(extCtx);
     shellRecall(extCtx);
-    // Shell-exec: start the Unix socket bridge so the MCP server can
-    // route user_shell tool calls to the PTY via the EventBus.
+    // Shell-exec: start the Unix domain socket bridge so agent extensions
+    // and MCP servers can route tool calls to the PTY via the EventBus.
     const tmpDir = shell.getTmpDir();
     if (tmpDir) {
+        if (process.env.DEBUG) {
+            console.error('[agent-sh] Starting shell-exec socket server...');
+        }
         shellExec(extCtx, { socketPath: `${tmpDir}/shell.sock` });
     }
-    await loadExtensions(extCtx, config.extensions);
+    // Load extensions with timeout to prevent blocking startup
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Loading extensions...');
+    }
+    const loadExtensionsTimeoutMs = 10000; // 10 seconds
+    await Promise.race([
+        loadExtensions(extCtx, config.extensions),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Extension loading timeout after ${loadExtensionsTimeoutMs}ms`)), loadExtensionsTimeoutMs)),
+    ]).catch((err) => {
+        console.error(`Warning: ${err.message}`);
+    });
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Extensions loaded');
+    }
     // ── Agent connection (async — don't block shell startup) ──────
-    core.start().catch((err) => {
+    const agentStartTimeoutMs = 35000; // 35 seconds (slightly longer than internal timeouts)
+    Promise.race([
+        core.start(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Agent connection timeout`)), agentStartTimeoutMs)),
+    ]).catch((err) => {
         console.error(`Failed to connect to ${config.agentCommand}:`, err);
     });
     // ── Terminal lifecycle ────────────────────────────────────────
     process.on("SIGTERM", cleanup);
     process.on("SIGHUP", cleanup);
+    // Handle terminal stop/resume signals properly
+    process.on("SIGTSTP", () => {
+        // Handle Ctrl+Z - suspend the entire process group
+        // Restore terminal state before suspending
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        // Re-send SIGSTOP to actually suspend
+        process.kill(process.pid, "SIGSTOP");
+    });
+    process.on("SIGCONT", () => {
+        // Re-acquire terminal when brought back to foreground
+        if (process.stdin.isTTY) {
+            try {
+                // Ensure we reacquire controlling terminal
+                process.stdin.setRawMode(true);
+            }
+            catch {
+                // May fail if stdin is not a TTY
+            }
+        }
+    });
     process.stdout.on("resize", () => {
         shell.resize(process.stdout.columns || 80, process.stdout.rows || 24);
     });
@@ -190,10 +312,35 @@ async function main() {
         }
         process.exit(e.exitCode);
     });
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
+    // Set up stdin - resume after all event listeners are in place
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Resuming stdin...');
     }
     process.stdin.resume();
+    // Set raw mode after resume to avoid SIGTTOU issues
+    if (process.stdin.isTTY) {
+        if (process.env.DEBUG) {
+            console.error('[agent-sh] Setting raw mode...');
+        }
+        // Use setImmediate to ensure we're in the next tick
+        setImmediate(() => {
+            try {
+                process.stdin.setRawMode(true);
+                if (process.env.DEBUG) {
+                    console.error('[agent-sh] Raw mode enabled');
+                }
+            }
+            catch (err) {
+                if (process.env.DEBUG) {
+                    console.error(`[agent-sh] Failed to set raw mode: ${err}`);
+                }
+                // May fail if process is in background; SIGTTOU handler prevents suspension
+            }
+        });
+    }
+    if (process.env.DEBUG) {
+        console.error('[agent-sh] Startup complete');
+    }
 }
 main().catch((err) => {
     console.error("Fatal:", err);

package/dist/input-handler.d.ts

@@ -22,6 +22,11 @@ export declare class InputHandler {
     private autocompleteIndex;
     private autocompleteItems;
     private autocompleteLines;
+    private history;
+    private historyIndex;
+    private savedBuffer;
+    private promptWrappedLines;
+    private escapeTimer;
     private bus;
     private onShowAgentInfo;
     constructor(opts: {
@@ -32,11 +37,15 @@ export declare class InputHandler {
             model?: string;
         };
     });
+    private loadHistory;
+    private saveHistory;
     /** Write the agent prompt line with cursor at the correct position. */
     private writeAgentPromptLine;
     handleInput(data: string): void;
     private enterAgentInputMode;
     private exitAgentInputMode;
+    /** Move to the start of the prompt area and clear everything below. */
+    private clearPromptArea;
     printPrompt(): void;
     private renderAgentInput;
     private updateAutocomplete;
@@ -45,4 +54,5 @@ export declare class InputHandler {
     private dismissAutocomplete;
     private clearAutocompleteLines;
     private handleAgentInput;
+    private processAgentActions;
 }

package/dist/input-handler.js

@@ -1,6 +1,10 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { visibleLen } from "./utils/ansi.js";
 import { palette as p } from "./utils/palette.js";
 import { LineEditor } from "./utils/line-editor.js";
+import { CONFIG_DIR, getSettings } from "./settings.js";
+const HISTORY_FILE = path.join(CONFIG_DIR, "history");
 export class InputHandler {
     ctx;
     lineBuffer = "";
@@ -10,24 +14,105 @@ export class InputHandler {
     autocompleteIndex = 0;
     autocompleteItems = [];
     autocompleteLines = 0;
+    history = [];
+    historyIndex = -1; // -1 = not browsing history
+    savedBuffer = ""; // buffer saved when entering history
+    promptWrappedLines = 0; // extra lines from terminal wrapping
+    escapeTimer = null;
     bus;
     onShowAgentInfo;
     constructor(opts) {
         this.ctx = opts.ctx;
         this.bus = opts.bus;
         this.onShowAgentInfo = opts.onShowAgentInfo;
+        this.loadHistory();
+        // Re-render prompt when config changes (e.g. thinking level cycled)
+        this.bus.on("config:changed", () => {
+            if (this.agentInputMode)
+                this.writeAgentPromptLine();
+        });
+    }
+    loadHistory() {
+        try {
+            const data = fs.readFileSync(HISTORY_FILE, "utf-8");
+            this.history = data.split("\n").filter(Boolean);
+        }
+        catch {
+            // No history file yet
+        }
+    }
+    saveHistory() {
+        try {
+            const { historySize } = getSettings();
+            fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+            const lines = this.history.slice(-historySize);
+            fs.writeFileSync(HISTORY_FILE, lines.join("\n") + "\n");
+        }
+        catch {
+            // Non-critical — ignore write failures
+        }
     }
     /** Write the agent prompt line with cursor at the correct position. */
     writeAgentPromptLine(showBuffer = true) {
+        const termW = process.stdout.columns || 80;
+        // Move cursor to the start of the prompt area (first line of wrapped content)
+        if (this.promptWrappedLines > 0) {
+            process.stdout.write(`\x1b[${this.promptWrappedLines}A`);
+        }
+        // Clear from here to end of screen — removes current + all wrapped lines below
+        process.stdout.write("\r\x1b[J");
         const agentInfo = this.onShowAgentInfo();
         const infoPrefix = agentInfo.info ? `${agentInfo.info} ` : "";
         const promptPrefix = infoPrefix + p.warning + p.bold + "❯ " + p.reset;
-        const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
-        process.stdout.write("\r\x1b[2K" + promptPrefix + bufferText);
-        // Position cursor within the buffer (not always at end)
-        if (showBuffer && this.editor.cursor < this.editor.buffer.length) {
-            const charsAfterCursor = this.editor.buffer.length - this.editor.cursor;
-            process.stdout.write(`\x1b[${charsAfterCursor}D`);
+        const promptVisLen = visibleLen(infoPrefix) + 2; // "❯ "
+        if (!showBuffer || !this.editor.buffer.includes("\n")) {
+            // Single-line: simple rendering
+            const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
+            process.stdout.write(promptPrefix + bufferText);
+            const bufferVisLen = showBuffer ? this.editor.buffer.length : 0;
+            const totalVisLen = promptVisLen + bufferVisLen;
+            this.promptWrappedLines = totalVisLen > 0 ? Math.floor((totalVisLen - 1) / termW) : 0;
+            // Position cursor within the buffer
+            if (showBuffer && this.editor.cursor < this.editor.buffer.length) {
+                const charsAfterCursor = this.editor.buffer.length - this.editor.cursor;
+                process.stdout.write(`\x1b[${charsAfterCursor}D`);
+            }
+        }
+        else {
+            // Multi-line: render each line with continuation indent
+            const lines = this.editor.buffer.split("\n");
+            const indent = " ".repeat(promptVisLen);
+            let totalTermLines = 0;
+            for (let li = 0; li < lines.length; li++) {
+                const prefix = li === 0 ? promptPrefix : indent;
+                const prefixVisLen = li === 0 ? promptVisLen : promptVisLen;
+                const lineText = lines[li];
+                process.stdout.write(prefix + p.accent + lineText + p.reset);
+                if (li < lines.length - 1)
+                    process.stdout.write("\n");
+                // Count terminal lines this logical line occupies
+                const lineVisLen = prefixVisLen + lineText.length;
+                totalTermLines += lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+            }
+            this.promptWrappedLines = totalTermLines - 1;
+            // Position cursor: find which line and column the cursor is on
+            let charsRemaining = this.editor.cursor;
+            let cursorLine = 0;
+            for (let li = 0; li < lines.length; li++) {
+                if (charsRemaining <= lines[li].length) {
+                    cursorLine = li;
+                    break;
+                }
+                charsRemaining -= lines[li].length + 1; // +1 for \n
+                cursorLine = li + 1;
+            }
+            // Move from end position to cursor position
+            const linesFromEnd = lines.length - 1 - cursorLine;
+            if (linesFromEnd > 0) {
+                process.stdout.write(`\x1b[${linesFromEnd}A`);
+            }
+            const cursorCol = (cursorLine === 0 ? promptVisLen : promptVisLen) + charsRemaining;
+            process.stdout.write(`\r\x1b[${cursorCol}C`);
         }
     }
     handleInput(data) {
@@ -41,10 +126,15 @@ export class InputHandler {
             }
             return;
         }
-        // Forward control chars that normal shell mode doesn't handle
+        // Intercept control chars for TUI (Ctrl+T, Ctrl+O) — don't pass to PTY
         if (data.length === 1 && data.charCodeAt(0) < 32 && !this.agentInputMode) {
             const code = data.charCodeAt(0);
-            // Don't intercept keys that shell mode handles: CR, Ctrl-C, Ctrl-D, Tab
+            // Keys consumed by TUI extensions
+            if (code === 0x14 || code === 0x0f) { // Ctrl+T, Ctrl+O
+                this.bus.emit("input:keypress", { key: data });
+                return;
+            }
+            // Forward other control chars that shell mode doesn't handle
             if (code !== 0x0d && code !== 0x03 && code !== 0x04 && code !== 0x09) {
                 this.bus.emit("input:keypress", { key: data });
             }
@@ -95,15 +185,28 @@ export class InputHandler {
     enterAgentInputMode() {
         this.agentInputMode = true;
         this.editor.clear();
+        // Enable kitty keyboard protocol (progressive enhancement flag 1)
+        // so Shift+Enter sends \x1b[13;2u instead of plain \r
+        process.stdout.write("\x1b[>1u");
         this.writeAgentPromptLine(false);
     }
     exitAgentInputMode() {
         this.dismissAutocomplete();
         this.agentInputMode = false;
         this.editor.clear();
-        process.stdout.write("\r\x1b[2K");
+        // Disable kitty keyboard protocol
+        process.stdout.write("\x1b[<u");
+        this.clearPromptArea();
         this.printPrompt();
     }
+    /** Move to the start of the prompt area and clear everything below. */
+    clearPromptArea() {
+        if (this.promptWrappedLines > 0) {
+            process.stdout.write(`\x1b[${this.promptWrappedLines}A`);
+        }
+        process.stdout.write("\r\x1b[J");
+        this.promptWrappedLines = 0;
+    }
     printPrompt() {
         this.ctx.redrawPrompt();
     }
@@ -197,10 +300,29 @@ export class InputHandler {
         this.autocompleteLines = 0;
     }
     handleAgentInput(data) {
+        // Clear any pending escape timer — new data arrived
+        if (this.escapeTimer) {
+            clearTimeout(this.escapeTimer);
+            this.escapeTimer = null;
+        }
         const actions = this.editor.feed(data);
+        // If the editor is waiting for more escape sequence data, set a short
+        // timer — if nothing arrives, treat it as a bare Escape keypress
+        if (this.editor.hasPendingEscape()) {
+            this.escapeTimer = setTimeout(() => {
+                this.escapeTimer = null;
+                const flushed = this.editor.flushPendingEscape();
+                if (flushed.length > 0)
+                    this.processAgentActions(flushed);
+            }, 50);
+        }
+        this.processAgentActions(actions);
+    }
+    processAgentActions(actions) {
         for (const act of actions) {
             switch (act.action) {
                 case "changed":
+                    this.historyIndex = -1;
                     this.autocompleteIndex = 0;
                     this.renderAgentInput();
                     break;
@@ -209,8 +331,18 @@ export class InputHandler {
                         this.applyAutocomplete();
                     }
                     const query = act.buffer.trim();
+                    if (query) {
+                        // Add to history (avoid consecutive duplicates)
+                        if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
+                            this.history.push(query);
+                            this.saveHistory();
+                        }
+                    }
+                    this.historyIndex = -1;
+                    this.savedBuffer = "";
                     this.clearAutocompleteLines();
-                    process.stdout.write("\r\x1b[2K");
+                    this.clearPromptArea();
+                    process.stdout.write("\x1b[<u"); // disable kitty keyboard protocol
                     this.agentInputMode = false;
                     this.editor.clear();
                     this.dismissAutocomplete();
@@ -247,6 +379,9 @@ export class InputHandler {
                         this.applyAutocomplete();
                     }
                     break;
+                case "shift+tab":
+                    this.bus.emit("config:cycle", {});
+                    break;
                 case "arrow-up":
                     if (this.autocompleteActive) {
                         this.autocompleteIndex =
@@ -257,6 +392,18 @@ export class InputHandler {
                         this.writeAgentPromptLine();
                         this.renderAutocomplete();
                     }
+                    else if (this.history.length > 0) {
+                        if (this.historyIndex === -1) {
+                            this.savedBuffer = this.editor.buffer;
+                            this.historyIndex = this.history.length - 1;
+                        }
+                        else if (this.historyIndex > 0) {
+                            this.historyIndex--;
+                        }
+                        this.editor.buffer = this.history[this.historyIndex];
+                        this.editor.cursor = this.editor.buffer.length;
+                        this.renderAgentInput();
+                    }
                     break;
                 case "arrow-down":
                     if (this.autocompleteActive) {
@@ -268,6 +415,18 @@ export class InputHandler {
                         this.writeAgentPromptLine();
                         this.renderAutocomplete();
                     }
+                    else if (this.historyIndex !== -1) {
+                        if (this.historyIndex < this.history.length - 1) {
+                            this.historyIndex++;
+                            this.editor.buffer = this.history[this.historyIndex];
+                        }
+                        else {
+                            this.historyIndex = -1;
+                            this.editor.buffer = this.savedBuffer;
+                        }
+                        this.editor.cursor = this.editor.buffer.length;
+                        this.renderAgentInput();
+                    }
                     break;
             }
         }