agent-sh 0.12.7 → 0.12.9

package/README.md

@@ -77,6 +77,8 @@ alias ash="agent-sh"
 
 Requires Node.js 18+. Currently supports **bash** and **zsh**; other shells (fish, nushell, etc.) are not yet wired up.
 
+**Windows:** the interactive shell layer is bash/zsh-only. Run agent-sh inside **WSL** for the full experience. Native Windows (cmd.exe / PowerShell) is not supported as the host shell, though headless / library / ACP-bridge usage may work — file an issue if you hit a gap.
+
 ## Key Features
 
 **Real terminal, zero compromise.** Full PTY with your shell config, aliases, and environment. Shell starts instantly — the agent connects asynchronously in the background.

package/dist/agent/agent-loop.js

@@ -1,6 +1,7 @@
 import { setMaxListeners } from "node:events";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import * as os from "node:os";
 import { computeDiff, computeEditDiff, computeInputDiff } from "../utils/diff.js";
 import { ToolRegistry } from "./tool-registry.js";
 import { ConversationState } from "./conversation-state.js";
@@ -14,6 +15,7 @@ import { getSettings, updateSettings } from "../settings.js";
 import { createToolProtocol } from "./tool-protocol.js";
 // Core tool factories
 import { createBashTool } from "./tools/bash.js";
+import { createPwshTool } from "./tools/pwsh.js";
 import { createReadFileTool } from "./tools/read-file.js";
 import { createWriteFileTool } from "./tools/write-file.js";
 import { createEditFileTool } from "./tools/edit-file.js";
@@ -590,6 +592,9 @@ export class AgentLoop {
             return env;
         };
         this.toolRegistry.register(createBashTool({ getCwd, getEnv, bus: this.bus }));
+        if (process.platform === "win32") {
+            this.toolRegistry.register(createPwshTool({ getCwd, getEnv, bus: this.bus }));
+        }
         this.toolRegistry.register(createReadFileTool(getCwd, this.fileReadCache));
         this.toolRegistry.register(createWriteFileTool(getCwd));
         this.toolRegistry.register(createEditFileTool(getCwd));
@@ -915,7 +920,7 @@ export class AgentLoop {
                             permKind = "file-write";
                             // Shorten path for display
                             const cwd = process.cwd();
-                            const home = process.env.HOME;
+                            const home = process.env.HOME ?? os.homedir();
                             let displayPath = absPath;
                             if (absPath.startsWith(cwd + "/"))
                                 displayPath = absPath.slice(cwd.length + 1);

package/dist/agent/tools/glob.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { executeCommand } from "../../executor.js";
+import { executeArgv } from "../../executor.js";
+import { resolveRgPath } from "../../utils/ripgrep-path.js";
 import { expandHome } from "./expand-home.js";
 export function createGlobTool(getCwd) {
     return {
@@ -15,11 +16,11 @@ export function createGlobTool(getCwd) {
             properties: {
                 pattern: {
                     type: "string",
-                    description: "Glob pattern (e.g., 'src/**/*.ts', '*.json')",
+                    description: "Glob pattern (e.g., 'src/**/*.ts', '*.json'). Do NOT put `~` or absolute prefixes here — pass the directory in `path` instead.",
                 },
                 path: {
                     type: "string",
-                    description: "Base directory to search (default: cwd)",
+                    description: "Base directory to search (default: cwd). Supports `~` and `~/...` for the home directory.",
                 },
             },
             required: ["pattern"],
@@ -42,18 +43,20 @@ export function createGlobTool(getCwd) {
             const pattern = args.pattern;
             const searchPath = expandHome(args.path ?? ".");
             // Use ripgrep for correct glob matching + .gitignore awareness
-            const shellEsc = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
-            const parts = [
-                "rg", "--files",
-                "--glob", shellEsc(pattern),
-                shellEsc(searchPath),
-            ];
-            const { session, done } = executeCommand({
-                command: parts.join(" "),
+            const { session, done } = executeArgv({
+                file: resolveRgPath(),
+                args: ["--files", "--glob", pattern, searchPath],
                 cwd: getCwd(),
                 timeout: 10_000,
             });
             await done;
+            if (session.spawnFailed) {
+                return {
+                    content: "ripgrep not available — the bundled binary failed to load and `rg` is not on PATH. Reinstall agent-sh, or install ripgrep manually (https://github.com/BurntSushi/ripgrep#installation).",
+                    exitCode: 1,
+                    isError: true,
+                };
+            }
             if (!session.output.trim()) {
                 return {
                     content: "No files matched.",

package/dist/agent/tools/grep.js

@@ -1,4 +1,5 @@
-import { executeCommand } from "../../executor.js";
+import { executeArgv } from "../../executor.js";
+import { resolveRgPath } from "../../utils/ripgrep-path.js";
 import { expandHome } from "./expand-home.js";
 export function createGrepTool(getCwd) {
     return {
@@ -89,43 +90,50 @@ export function createGrepTool(getCwd) {
             const contextAfter = args.context_after;
             const headLimit = args.head_limit;
             const offset = args.offset ?? 0;
-            const shellEsc = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
-            const parts = ["rg", "--color=never"];
+            const rgArgs = ["--color=never"];
             // Mode-specific flags
             if (mode === "files_with_matches") {
-                parts.push("--files-with-matches");
+                rgArgs.push("--files-with-matches");
             }
             else if (mode === "count") {
-                parts.push("--count");
+                rgArgs.push("--count");
             }
             else {
                 // content mode
-                parts.push("--line-number", "--no-heading");
+                rgArgs.push("--line-number", "--no-heading");
                 if (contextBefore != null && contextBefore > 0) {
-                    parts.push(`-B${contextBefore}`);
+                    rgArgs.push(`-B${contextBefore}`);
                 }
                 if (contextAfter != null && contextAfter > 0) {
-                    parts.push(`-A${contextAfter}`);
+                    rgArgs.push(`-A${contextAfter}`);
                 }
                 // If neither -A nor -B specified, use --max-count to limit per-file
                 if (contextBefore == null && contextAfter == null) {
-                    parts.push("--max-count=50");
+                    rgArgs.push("--max-count=50");
                 }
             }
             if (caseInsensitive) {
-                parts.push("-i");
+                rgArgs.push("-i");
             }
             if (include) {
-                parts.push("--glob", shellEsc(include));
+                rgArgs.push("--glob", include);
             }
-            parts.push("-e", shellEsc(pattern), shellEsc(searchPath));
-            const { session, done } = executeCommand({
-                command: parts.join(" "),
+            rgArgs.push("-e", pattern, searchPath);
+            const { session, done } = executeArgv({
+                file: resolveRgPath(),
+                args: rgArgs,
                 cwd: getCwd(),
                 timeout: 10_000,
                 maxOutputBytes: 64 * 1024,
             });
             await done;
+            if (session.spawnFailed) {
+                return {
+                    content: "ripgrep not available — the bundled binary failed to load and `rg` is not on PATH. Reinstall agent-sh, or install ripgrep manually (https://github.com/BurntSushi/ripgrep#installation).",
+                    exitCode: 1,
+                    isError: true,
+                };
+            }
             if (session.exitCode === 1 && !session.output.trim()) {
                 // If the pattern looks like a filename (e.g. "SKILL.md", "package.json"),
                 // the agent probably meant to find files by name, not search inside them.

package/dist/agent/tools/pwsh.d.ts

@@ -0,0 +1,7 @@
+import type { EventBus } from "../../event-bus.js";
+import type { ToolDefinition } from "../types.js";
+export declare function createPwshTool(opts: {
+    getCwd: () => string;
+    getEnv: () => Record<string, string>;
+    bus: EventBus;
+}): ToolDefinition;

package/dist/agent/tools/pwsh.js

@@ -0,0 +1,90 @@
+import { executeArgv, killSession } from "../../executor.js";
+// Targets PowerShell 7+ (`pwsh`). Legacy `powershell.exe` is intentionally
+// not auto-fallback — its tool surface diverges enough that compatibility
+// shims aren't worth the maintenance.
+export function createPwshTool(opts) {
+    return {
+        name: "pwsh",
+        description: "Execute a PowerShell command in an isolated subprocess. " +
+            "Use this on Windows when the `bash` tool fails (no /bin/bash available). " +
+            "Use PowerShell syntax — e.g. `Get-ChildItem`, `Select-String`, `$env:HOME`. " +
+            "Does not affect the user's shell state. " +
+            "cwd is set to the working directory from the shell context. " +
+            "Do NOT use pwsh for file searching — use grep/glob instead. " +
+            "Do NOT use pwsh for reading files — use read_file instead.",
+        input_schema: {
+            type: "object",
+            properties: {
+                command: {
+                    type: "string",
+                    description: "The PowerShell command to execute",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in seconds (default: 60)",
+                },
+                description: {
+                    type: "string",
+                    description: "Short description of what this command does (e.g., 'Install dependencies', 'Run test suite')",
+                },
+            },
+            required: ["command"],
+        },
+        showOutput: true,
+        modifiesFiles: true,
+        requiresPermission: true,
+        getDisplayInfo: () => ({
+            kind: "execute",
+            icon: "▶",
+            locations: [],
+        }),
+        async execute(args, onChunk, ctx) {
+            const command = args.command;
+            const timeout = (args.timeout ?? 60) * 1000;
+            const intercepted = opts.bus.emitPipe("agent:terminal-intercept", {
+                command,
+                cwd: opts.getCwd(),
+                intercepted: false,
+                output: "",
+            });
+            if (intercepted.intercepted) {
+                return {
+                    content: intercepted.output,
+                    exitCode: 0,
+                    isError: false,
+                };
+            }
+            const { session, done } = executeArgv({
+                file: "pwsh",
+                args: ["-NoProfile", "-NonInteractive", "-Command", command],
+                cwd: opts.getCwd(),
+                env: opts.getEnv(),
+                timeout,
+                onOutput: onChunk,
+            });
+            const onAbort = () => killSession(session);
+            ctx?.signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                await done;
+            }
+            finally {
+                ctx?.signal?.removeEventListener("abort", onAbort);
+            }
+            if (session.spawnFailed) {
+                return {
+                    content: "PowerShell (pwsh) not found on PATH. Install PowerShell 7: winget install Microsoft.PowerShell.",
+                    exitCode: 1,
+                    isError: true,
+                };
+            }
+            const content = session.truncated
+                ? `[output truncated, showing last portion]\n${session.output}`
+                : session.output;
+            return {
+                content: content || "(no output)",
+                exitCode: session.exitCode,
+                isError: session.exitCode !== 0,
+            };
+        },
+    };
+}

package/dist/executor.d.ts

@@ -6,6 +6,9 @@ export interface ExecutorSession {
     exitCode: number | null;
     done: boolean;
     truncated: boolean;
+    /** True when the binary couldn't be launched (ENOENT, EACCES). Lets callers
+     *  distinguish "tool missing" from "tool ran and exited with -1". */
+    spawnFailed: boolean;
     process: ChildProcess | null;
     resolve?: () => void;
 }
@@ -24,6 +27,23 @@ export declare function executeCommand(opts: {
     session: ExecutorSession;
     done: Promise<void>;
 };
+/**
+ * Spawn a binary directly (no shell). Use for invoking known tools like `rg`
+ * with structured args — avoids shell-quoting bugs and works on platforms
+ * without /bin/bash.
+ */
+export declare function executeArgv(opts: {
+    file: string;
+    args: 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: SIGTERM, then SIGKILL after 5s.
  * Returns a cleanup that cancels the pending SIGKILL — callers should invoke

package/dist/executor.js

@@ -16,6 +16,7 @@ export function executeCommand(opts) {
         exitCode: null,
         done: false,
         truncated: false,
+        spawnFailed: false,
         process: null,
     };
     const done = new Promise((resolve) => {
@@ -39,6 +40,7 @@ export function executeCommand(opts) {
     }
     catch (err) {
         session.exitCode = -1;
+        session.spawnFailed = true;
         session.output = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
         session.done = true;
         session.resolve?.();
@@ -79,6 +81,103 @@ export function executeCommand(opts) {
         cancelKill?.();
         if (!session.done) {
             session.exitCode = -1;
+            const code = err.code;
+            if (code === "ENOENT" || code === "EACCES")
+                session.spawnFailed = true;
+            session.output += `\nProcess error: ${err.message}`;
+            session.done = true;
+            session.process = null;
+            session.resolve?.();
+        }
+    });
+    return { session, done };
+}
+/**
+ * Spawn a binary directly (no shell). Use for invoking known tools like `rg`
+ * with structured args — avoids shell-quoting bugs and works on platforms
+ * without /bin/bash.
+ */
+export function executeArgv(opts) {
+    const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+    const maxOutput = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT;
+    const session = {
+        id: "",
+        command: `${opts.file} ${opts.args.join(" ")}`,
+        output: "",
+        exitCode: null,
+        done: false,
+        truncated: false,
+        spawnFailed: false,
+        process: null,
+    };
+    const done = new Promise((resolve) => {
+        session.resolve = resolve;
+    });
+    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(opts.file, opts.args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: opts.cwd,
+            env,
+        });
+    }
+    catch (err) {
+        session.exitCode = -1;
+        session.spawnFailed = true;
+        session.output = `Failed to spawn ${opts.file}: ${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);
+        session.output += clean;
+        if (session.output.length > maxOutput) {
+            session.output = session.output.slice(-maxOutput);
+            session.truncated = true;
+        }
+        opts.onOutput?.(raw);
+    };
+    child.stdout?.on("data", handleData);
+    child.stderr?.on("data", handleData);
+    const timer = setTimeout(() => {
+        if (!session.done && session.process) {
+            try {
+                session.process.kill("SIGTERM");
+            }
+            catch { }
+            setTimeout(() => {
+                if (!session.done && session.process) {
+                    try {
+                        session.process.kill("SIGKILL");
+                    }
+                    catch { }
+                }
+            }, 5000).unref();
+        }
+    }, 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;
+            const code = err.code;
+            if (code === "ENOENT" || code === "EACCES")
+                session.spawnFailed = true;
             session.output += `\nProcess error: ${err.message}`;
             session.done = true;
             session.process = null;
@@ -96,10 +195,17 @@ export function killSession(session) {
     const proc = session.process;
     if (!proc || !proc.pid)
         return () => { };
+    // Try process-group kill first (works for executeCommand's detached bash
+    // children); fall back to direct kill (executeArgv's non-detached spawn,
+    // and Windows where negative pids aren't supported).
     try {
         process.kill(-proc.pid, "SIGTERM");
     }
     catch { }
+    try {
+        proc.kill("SIGTERM");
+    }
+    catch { }
     let settled = false;
     const fallback = setTimeout(() => {
         if (!settled && !session.done && proc.pid) {
@@ -107,6 +213,10 @@ export function killSession(session) {
                 process.kill(-proc.pid, "SIGKILL");
             }
             catch { }
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch { }
         }
     }, 5000);
     fallback.unref();

package/dist/extensions/openrouter.js

@@ -1,6 +1,6 @@
 import { getSettings } from "../settings.js";
 const BASE_URL = "https://openrouter.ai/api/v1";
-const DEFAULT_MODELS = ["anthropic/claude-sonnet-4.6"];
+const DEFAULT_MODELS = ["deepseek/deepseek-v4-flash"];
 // Built-in defaults for models requiring reasoning_content echoed back
 // (server 400s without it). Extend or override in settings.json:
 //   providers.openrouter.echoReasoningPatterns = ["deepseek", "..."]

package/dist/utils/ripgrep-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve the ripgrep binary path. Prefers the version bundled via
+ * @vscode/ripgrep (downloaded by its postinstall hook). Falls back to plain
+ * "rg" so users with rg on PATH still work even if the postinstall failed
+ * (offline install, blocked egress, etc.).
+ */
+export declare function resolveRgPath(): string;

package/dist/utils/ripgrep-path.js

@@ -0,0 +1,18 @@
+import * as fs from "node:fs";
+import { rgPath as bundledRgPath } from "@vscode/ripgrep";
+/**
+ * Resolve the ripgrep binary path. Prefers the version bundled via
+ * @vscode/ripgrep (downloaded by its postinstall hook). Falls back to plain
+ * "rg" so users with rg on PATH still work even if the postinstall failed
+ * (offline install, blocked egress, etc.).
+ */
+export function resolveRgPath() {
+    try {
+        if (bundledRgPath && fs.existsSync(bundledRgPath))
+            return bundledRgPath;
+    }
+    catch {
+        // fall through
+    }
+    return "rg";
+}

package/dist/utils/tool-display.js

@@ -1,3 +1,4 @@
+import * as os from "node:os";
 import { visibleLen } from "./ansi.js";
 import { palette as p } from "./palette.js";
 // ── Quiet command detection ──────────────────────────────────────
@@ -231,7 +232,7 @@ function shortenPath(p, cwd) {
         return p.slice(cwd.length + 1);
     if (p.startsWith(cwd))
         return p.slice(cwd.length) || ".";
-    const home = process.env.HOME;
+    const home = process.env.HOME ?? os.homedir();
     if (home && p.startsWith(home + "/"))
         return "~/" + p.slice(home.length + 1);
     return p;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.12.7",
+  "version": "0.12.9",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
@@ -127,6 +127,7 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@vscode/ripgrep": "^1.17.1",
     "@xterm/addon-serialize": "^0.13.0",
     "@xterm/headless": "^5.5.0",
     "cli-highlight": "^2.1.11",