agent-sh 0.1.0 → 0.3.0

package/dist/shell.js

@@ -10,7 +10,9 @@ export class Shell {
     inputHandler;
     outputParser;
     paused = false;
+    echoSkip = false;
     agentActive = false;
+    isZsh = false;
     tmpDir;
     constructor(opts) {
         // Build environment — filter out undefined values (node-pty's native
@@ -38,6 +40,7 @@ export class Shell {
         let shellArgs;
         const osc7Cmd = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
         const promptMarker = 'printf "\\e]9999;PROMPT\\a"';
+        this.isZsh = isZsh;
         if (isZsh) {
             // For zsh: use ZDOTDIR to source user's real config, then append
             // our hooks via precmd_functions (additive — doesn't clobber p10k/omz).
@@ -68,6 +71,14 @@ export class Shell {
                 "  }",
                 "fi",
                 "zle -N zle-line-init __agent_sh_line_init",
+                "",
+                "# Hidden widget to trigger prompt redraw from Node.js side",
+                "# Bound to an unused escape sequence that no real key produces",
+                "__agent_sh_redraw() {",
+                "  zle reset-prompt",
+                "}",
+                "zle -N __agent_sh_redraw",
+                "bindkey '\\e[9999~' __agent_sh_redraw",
             ].join("\n") + "\n");
             env.ZDOTDIR = this.tmpDir;
             shellArgs = ["--no-globalrcs"];
@@ -88,6 +99,18 @@ export class Shell {
             ].join("\n") + "\n");
             shellArgs = ["--rcfile", path.join(this.tmpDir, ".bashrc")];
         }
+        // Pause stdin before spawning PTY to avoid TTY contention on macOS.
+        // The PTY will become the controlling terminal for the child shell.
+        const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+            }
+            catch {
+                // Ignore
+            }
+        }
         this.ptyProcess = pty.spawn(shellBin, shellArgs, {
             name: "xterm-256color",
             cols: opts.cols,
@@ -95,6 +118,18 @@ export class Shell {
             cwd: opts.cwd,
             env,
         });
+        // Restore stdin after PTY is created
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.resume();
+                if (wasRaw) {
+                    process.stdin.setRawMode(true);
+                }
+            }
+            catch {
+                // Ignore - will be set up later in index.ts
+            }
+        }
         this.bus = opts.bus;
         this.outputParser = new OutputParser(opts.bus, opts.cwd);
         // Ensure temp dir cleanup on abnormal exit (SIGKILL won't fire this,
@@ -131,10 +166,11 @@ export class Shell {
         this.ptyProcess.write(data);
     }
     /**
-     * Lightweight redraw: replay just the last line of the shell's prompt
-     * (e.g. p10k's "❯ "). This works because agent input mode only overwrites
-     * the final prompt line — the path bar above is still intact. The last
-     * line is linear text (colors + chars + clear-to-end), no cursor positioning.
+     * Lightweight redraw: ask the shell to redraw its own prompt via a hidden
+     * ZLE widget (zsh) bound to \e[9999~. The shell knows how to draw its
+     * prompt correctly — we don't try to replay captured bytes.
+     *
+     * For bash, falls back to sending \n for a fresh prompt cycle.
      */
     redrawPrompt() {
         const result = this.bus.emitPipe("shell:redraw-prompt", {
@@ -142,12 +178,12 @@ export class Shell {
             handled: false,
         });
         if (!result.handled) {
-            const lastLine = this.outputParser.getLastPromptLine();
-            if (lastLine) {
-                process.stdout.write("\r" + lastLine);
+            if (this.isZsh) {
+                // Trigger the hidden ZLE widget — zle reset-prompt redraws cleanly
+                this.ptyProcess.write("\x1b[9999~");
             }
             else {
-                // Fallback: send \n for a fresh prompt cycle
+                // Bash: no zle reset-prompt equivalent, use fresh prompt cycle
                 this.ptyProcess.write("\n");
             }
         }
@@ -167,9 +203,20 @@ export class Shell {
     setupOutput() {
         this.ptyProcess.onData((data) => {
             this.outputParser.processData(data);
-            if (!this.paused) {
-                process.stdout.write(data);
+            if (this.paused)
+                return;
+            // During user_shell exec, skip the command echo (first line)
+            if (this.echoSkip) {
+                const nlIdx = data.indexOf("\n");
+                if (nlIdx === -1)
+                    return;
+                this.echoSkip = false;
+                const rest = data.slice(nlIdx + 1);
+                if (rest)
+                    process.stdout.write(rest);
+                return;
             }
+            process.stdout.write(data);
         });
     }
     setupInput() {
@@ -191,6 +238,7 @@ export class Shell {
         this.bus.on("agent:processing-done", () => {
             this.paused = false;
             this.agentActive = false;
+            this.echoSkip = true;
             this.freshPrompt();
         });
         // Permission prompts need stdout unpaused so the interactive UI renders,
@@ -202,8 +250,38 @@ export class Shell {
             this.paused = true;
             return payload;
         });
+        // Shell exec: write a command to the live PTY and capture its output.
+        // stdout is paused during agent processing, so PTY output flows through
+        // OutputParser (for OSC detection) but never reaches the terminal.
+        this.bus.onPipeAsync("shell:exec-request", async (payload) => {
+            this.echoSkip = true;
+            this.paused = false;
+            process.stdout.write("\n");
+            const output = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.bus.off("shell:command-done", handler);
+                    this.ptyProcess.write("\x03");
+                    reject(new Error("Shell exec timed out after 30s"));
+                }, 30_000);
+                const handler = (e) => {
+                    clearTimeout(timeout);
+                    this.bus.off("shell:command-done", handler);
+                    resolve({ output: e.output, cwd: e.cwd });
+                };
+                this.bus.on("shell:command-done", handler);
+                this.outputParser.onCommandEntered(payload.command, this.outputParser.getCwd());
+                this.ptyProcess.write(payload.command + "\r");
+            });
+            this.paused = true;
+            this.echoSkip = false;
+            return { ...payload, output: output.output, cwd: output.cwd, done: true };
+        });
     }
     // ── Public API (used by index.ts) ──
+    /** Temp directory used for shell config and sockets. */
+    getTmpDir() {
+        return this.tmpDir;
+    }
     resize(cols, rows) {
         this.ptyProcess.resize(cols, rows);
     }

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface AgentShellConfig {
     shell?: string;
     model?: string;
     extensions?: string[];
+    /** Full shell environment (from user's rc files) for agent subprocess. */
+    shellEnv?: Record<string, string>;
 }
 /**
  * Context passed to user/third-party extensions.
@@ -47,6 +49,8 @@ export type Exchange = {
     exitCode: number | null;
     outputLines: number;
     outputBytes: number;
+    /** Who initiated this command: "user" (typed) or "agent" (via user_shell). */
+    source: "user" | "agent";
 } | {
     type: "agent_query";
     id: number;

package/dist/utils/ansi.d.ts

@@ -6,7 +6,10 @@ export declare const RED = "\u001B[31m";
 export declare const GRAY = "\u001B[90m";
 export declare const BOLD = "\u001B[1m";
 export declare const RESET = "\u001B[0m";
-/** Measure visible string length, excluding SGR (color/style) sequences. */
+/**
+ * Measure visible string length in terminal columns.
+ * Excludes SGR (color/style) sequences and accounts for CJK double-width chars.
+ */
 export declare function visibleLen(str: string): number;
 /** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
 export declare function stripAnsi(str: string): string;

package/dist/utils/ansi.js

@@ -8,9 +8,67 @@ export const GRAY = "\x1b[90m";
 export const BOLD = "\x1b[1m";
 export const RESET = "\x1b[0m";
 // ── ANSI utility functions ───────────────────────────────────
-/** Measure visible string length, excluding SGR (color/style) sequences. */
+/**
+ * Check if a Unicode code point is a wide character (CJK, fullwidth, emoji, etc.)
+ * Returns 2 for wide chars, 1 for normal chars.
+ */
+function charWidth(codePoint) {
+    // CJK Unified Ideographs
+    if (codePoint >= 0x4e00 && codePoint <= 0x9fff)
+        return 2;
+    // CJK Unified Ideographs Extension A
+    if (codePoint >= 0x3400 && codePoint <= 0x4dbf)
+        return 2;
+    // Hangul Syllables
+    if (codePoint >= 0xac00 && codePoint <= 0xd7af)
+        return 2;
+    // CJK Unified Ideographs Extension B-F and other CJK blocks
+    if (codePoint >= 0x20000 && codePoint <= 0x2ebef)
+        return 2;
+    // Fullwidth ASCII variants
+    if (codePoint >= 0xff01 && codePoint <= 0xff5e)
+        return 2;
+    // Halfwidth Katakana (actually narrow, skip)
+    // Fullwidth bracket forms
+    if (codePoint >= 0xff5f && codePoint <= 0xff60)
+        return 2;
+    // Fullwidth symbol variants
+    if (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+        return 2;
+    // Japanese hiragana and katakana
+    if (codePoint >= 0x3040 && codePoint <= 0x309f)
+        return 2;
+    if (codePoint >= 0x30a0 && codePoint <= 0x30ff)
+        return 2;
+    // CJK symbols and punctuation
+    if (codePoint >= 0x3000 && codePoint <= 0x303f)
+        return 2;
+    // Enclosed CJK letters and months
+    if (codePoint >= 0x3200 && codePoint <= 0x32ff)
+        return 2;
+    // CJK compatibility
+    if (codePoint >= 0x3300 && codePoint <= 0x33ff)
+        return 2;
+    // Hangul Jamo
+    if (codePoint >= 0x1100 && codePoint <= 0x11ff)
+        return 2;
+    // Hangul compatibility Jamo
+    if (codePoint >= 0x3130 && codePoint <= 0x318f)
+        return 2;
+    return 1;
+}
+/**
+ * Measure visible string length in terminal columns.
+ * Excludes SGR (color/style) sequences and accounts for CJK double-width chars.
+ */
 export function visibleLen(str) {
-    return str.replace(/\x1b\[[^m]*m/g, "").length;
+    // First strip ANSI escape sequences
+    const cleanStr = str.replace(/\x1b\[[^m]*m/g, "");
+    let width = 0;
+    for (const char of cleanStr) {
+        width += charWidth(char.codePointAt(0) ?? 0);
+    }
+    return width;
 }
 /** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
 export function stripAnsi(str) {

package/dist/utils/line-editor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Minimal line editor with readline-style keybindings.
+ *
+ * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
+ * terminal input bytes and receive high-level actions back. Buffer and
+ * cursor state are public for rendering.
+ */
+export type LineEditAction = {
+    action: "changed";
+} | {
+    action: "submit";
+    buffer: string;
+} | {
+    action: "cancel";
+} | {
+    action: "delete-empty";
+} | {
+    action: "tab";
+} | {
+    action: "shift+tab";
+} | {
+    action: "arrow-up";
+} | {
+    action: "arrow-down";
+};
+export declare class LineEditor {
+    buffer: string;
+    cursor: number;
+    private pendingSeq;
+    /** Process raw terminal input, return actions for the consumer. */
+    feed(data: string): LineEditAction[];
+    /** Check if there's a pending incomplete escape sequence. */
+    hasPendingEscape(): boolean;
+    /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */
+    flushPendingEscape(): LineEditAction[];
+    clear(): void;
+    private readonly bindings;
+    /** Resolve a key name from the bindings table and execute it. */
+    private dispatch;
+    /** Map a legacy control character to a key name. */
+    private static readonly CTRL_MAP;
+    private handleControl;
+    /** Handle a kitty protocol CSI u sequence. Params format: "keycode;modifier". */
+    private handleKittyKey;
+    private insertAt;
+    private moveTo;
+    private deleteBackward;
+    private deleteForward;
+    private deleteRange;
+    /**
+     * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
+     * Returns the number of bytes consumed and whether the sequence was incomplete.
+     */
+    private handleCSI;
+    private wordBackward;
+    private wordForward;
+    private deleteWordBackward;
+    private deleteWordForward;
+}