agent-sh 0.10.0 → 0.10.2

package/dist/utils/ansi.js

@@ -10,9 +10,67 @@ export const RESET = "\x1b[0m";
 // ── ANSI utility functions ───────────────────────────────────
 /**
  * Check if a Unicode code point is a wide character (CJK, fullwidth, emoji, etc.)
- * Returns 2 for wide chars, 1 for normal chars.
+ * Returns 2 for wide chars, 1 for normal chars, 0 for combining chars.
+ *
+ * Based on East Asian Width and Unicode categories.
  */
 export function charWidth(codePoint) {
+    // Combining characters (zero width)
+    if (codePoint >= 0x0300 && codePoint <= 0x036f)
+        return 0; // Combining Diacritical Marks
+    if (codePoint >= 0x1ab0 && codePoint <= 0x1aff)
+        return 0; // Combining Diacritical Marks Extended
+    if (codePoint >= 0x1dc0 && codePoint <= 0x1dff)
+        return 0; // Combining Diacritical Marks Supplement
+    if (codePoint >= 0x20d0 && codePoint <= 0x20ff)
+        return 0; // Combining Diacritical Marks for Symbols
+    if (codePoint >= 0xfe20 && codePoint <= 0xfe2f)
+        return 0; // Combining Half Marks
+    if (codePoint >= 0xfe00 && codePoint <= 0xfe0f)
+        return 0; // Variation Selectors
+    if (codePoint >= 0xe0100 && codePoint <= 0xe01ef)
+        return 0; // Variation Selectors Supplement
+    // Emoji and symbols that render as wide (2 columns)
+    // Emoji presentation sequences and keycap
+    if (codePoint === 0x20e3)
+        return 2; // Combining Enclosing Keycap
+    // Emoji blocks
+    if (codePoint >= 0x1f600 && codePoint <= 0x1f64f)
+        return 2; // Emoticons
+    if (codePoint >= 0x1f300 && codePoint <= 0x1f5ff)
+        return 2; // Misc Symbols and Pictographs
+    if (codePoint >= 0x1f680 && codePoint <= 0x1f6ff)
+        return 2; // Transport and Map
+    if (codePoint >= 0x1f700 && codePoint <= 0x1f77f)
+        return 2; // Alchemical Symbols
+    if (codePoint >= 0x1f780 && codePoint <= 0x1f7ff)
+        return 2; // Geometric Shapes Extended
+    if (codePoint >= 0x1f800 && codePoint <= 0x1f8ff)
+        return 2; // Supplemental Arrows-C
+    if (codePoint >= 0x1f900 && codePoint <= 0x1f9ff)
+        return 2; // Supplemental Symbols and Pictographs
+    if (codePoint >= 0x1fa00 && codePoint <= 0x1faff)
+        return 2; // Chess Symbols, Symbols and Pictographs Extended-A
+    // NOTE: 0x2300-0x23ff (Misc Technical), 0x2600-0x26ff (Misc Symbols),
+    // and 0x2700-0x27bf (Dingbats) are mostly "Ambiguous" width — render as
+    // 1 column in non-CJK terminal locales (e.g. ❯, ⌘, ★, ♦). But a handful
+    // of dingbats have Emoji_Presentation=Yes and render as 2 cols everywhere.
+    if (codePoint === 0x2705 || // ✅ white heavy check mark
+        codePoint === 0x270a || // ✊ raised fist
+        codePoint === 0x270b || // ✋ raised hand
+        codePoint === 0x2728 || // ✨ sparkles
+        codePoint === 0x274c || // ❌ cross mark
+        codePoint === 0x274e || // ❎ negative squared cross mark
+        (codePoint >= 0x2753 && codePoint <= 0x2755) || // ❓❔❕
+        codePoint === 0x2757 || // ❗ heavy exclamation mark
+        (codePoint >= 0x2795 && codePoint <= 0x2797) || // ➕➖➗
+        codePoint === 0x27b0 || // ➰ curly loop
+        codePoint === 0x27bf // ➿ double curly loop
+    )
+        return 2;
+    // Regional indicator symbols (flag emoji components)
+    if (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)
+        return 2;
     // CJK Unified Ideographs
     if (codePoint >= 0x4e00 && codePoint <= 0x9fff)
         return 2;
@@ -28,7 +86,6 @@ export function charWidth(codePoint) {
     // 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;
@@ -76,18 +133,68 @@ export function visibleLen(str) {
  */
 export function truncateToWidth(str, maxWidth) {
     const clean = str.replace(/\x1b\[[^m]*m/g, "");
+    if (maxWidth <= 0)
+        return "";
+    // First check if the entire string fits
+    let fullWidth = 0;
+    for (const char of clean) {
+        fullWidth += charWidth(char.codePointAt(0) ?? 0);
+    }
+    if (fullWidth <= maxWidth)
+        return clean;
+    // String doesn't fit — truncate with "…"
+    // At maxWidth=1 the ellipsis alone fills the budget.
+    if (maxWidth === 1)
+        return "…";
+    // Reserve 1 column for "…", so target content width is maxWidth - 1
+    const target = maxWidth - 1;
     let width = 0;
     let i = 0;
     for (const char of clean) {
         const cw = charWidth(char.codePointAt(0) ?? 0);
-        if (width + cw > maxWidth - 1) {
-            // Need room for the "…" (1 column wide)
-            return clean.slice(0, i) + "…";
-        }
+        if (width + cw > target)
+            break;
         width += cw;
         i += char.length;
     }
-    return clean;
+    // If nothing fit (first char is wider than target), just show the ellipsis
+    // rather than emit a character that would overflow the budget.
+    if (i === 0)
+        return "…";
+    return clean.slice(0, i) + "…";
+}
+/** Truncate to visible width while preserving SGR sequences — use when
+ *  input carries color/bold codes. `truncateToWidth` strips them. */
+export function truncateAnsiToWidth(str, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (visibleLen(str) <= maxWidth)
+        return str;
+    if (maxWidth === 1)
+        return "…";
+    const target = maxWidth - 1;
+    let width = 0;
+    let out = "";
+    let i = 0;
+    while (i < str.length) {
+        if (str[i] === "\x1b" && str[i + 1] === "[") {
+            const end = str.indexOf("m", i);
+            if (end !== -1) {
+                out += str.slice(i, end + 1);
+                i = end + 1;
+                continue;
+            }
+        }
+        const cp = str.codePointAt(i) ?? 0;
+        const cw = charWidth(cp);
+        if (width + cw > target)
+            break;
+        const chLen = cp > 0xffff ? 2 : 1;
+        out += str.slice(i, i + chLen);
+        width += cw;
+        i += chLen;
+    }
+    return out + "\x1b[0m…";
 }
 /**
  * Pad a string with spaces to fill `targetWidth` visible columns.

package/dist/utils/box-frame.js

@@ -5,7 +5,7 @@
  * never writes to stdout. Supports multiple border styles and
  * optional title/footer sections with dividers.
  */
-import { visibleLen } from "./ansi.js";
+import { visibleLen, truncateToWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 const BORDERS = {
     rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│", ml: "├", mr: "┤" },
@@ -63,6 +63,12 @@ export function renderBoxFrame(content, opts) {
 }
 // ── Helpers ──────────────────────────────────────────────────────
 function boxLine(text, innerW, v, bc) {
-    const pad = Math.max(0, innerW - visibleLen(text));
+    const textWidth = visibleLen(text);
+    if (textWidth > innerW) {
+        // Content is too wide — truncate to fit exactly
+        const truncated = truncateToWidth(text, innerW);
+        return `${bc}${v}${p.reset} ${truncated} ${bc}${v}${p.reset}`;
+    }
+    const pad = innerW - textWidth;
     return `${bc}${v}${p.reset} ${text}${" ".repeat(pad)} ${bc}${v}${p.reset}`;
 }

package/dist/utils/llm-client.d.ts

@@ -12,6 +12,10 @@ export interface LlmClientConfig {
     apiKey: string;
     baseURL?: string;
     model: string;
+    /** Sent as OpenRouter X-Title; ignored by other providers. */
+    appName?: string;
+    /** Sent as OpenRouter HTTP-Referer; ignored by other providers. */
+    appUrl?: string;
 }
 export declare class LlmClient {
     private config;

package/dist/utils/llm-client.js

@@ -6,6 +6,12 @@
  * (command suggestions, completions).
  */
 import OpenAI from "openai";
+function attributionHeaders(config) {
+    return {
+        "HTTP-Referer": config.appUrl ?? "https://agent-sh.dev",
+        "X-Title": config.appName ?? "agent-sh",
+    };
+}
 export class LlmClient {
     config;
     client;
@@ -15,6 +21,7 @@ export class LlmClient {
         this.client = new OpenAI({
             apiKey: config.apiKey,
             baseURL: config.baseURL,
+            defaultHeaders: attributionHeaders(config),
         });
         this.model = config.model;
     }
@@ -24,6 +31,7 @@ export class LlmClient {
         this.client = new OpenAI({
             apiKey: newConfig.apiKey,
             baseURL: newConfig.baseURL,
+            defaultHeaders: attributionHeaders(newConfig),
         });
         this.model = newConfig.model;
     }

package/dist/utils/markdown.d.ts

@@ -2,6 +2,10 @@ export declare const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ *
+ * Handles CJK text by breaking between wide characters and applying basic
+ * CJK rules (closing punctuation sticks to the previous line; opening
+ * punctuation sticks to the next).
  */
 export declare function wrapLine(text: string, maxWidth: number): string[];
 /**

package/dist/utils/markdown.js

@@ -1,9 +1,65 @@
-import { visibleLen, truncateToWidth, padEndToWidth } from "./ansi.js";
+import { visibleLen, truncateAnsiToWidth, padEndToWidth, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 export const MAX_CONTENT_WIDTH = 90;
+// CJK line-breaking rules: closing punctuation must not start a line,
+// opening punctuation must not end a line. Both CJK fullwidth and ASCII
+// equivalents are included so mixed text wraps correctly.
+const CJK_NO_LINE_START = new Set([
+    "。", "，", "、", "．", "；", "：", "！", "？",
+    "）", "」", "』", "】", "》", "〉", "〕", "］", "｝",
+    "・", "々", "〜", "～", "ー",
+    ".", ",", ";", ":", "!", "?", ")", "]", "}",
+]);
+const CJK_NO_LINE_END = new Set([
+    "（", "「", "『", "【", "《", "〈", "〔", "［", "｛",
+    "(", "[", "{",
+]);
+/**
+ * Tokenize a visible-text run into units suitable for wrapping.
+ * Each width-2 character (CJK, fullwidth, emoji) becomes its own token so the
+ * wrapper can break between them; ASCII runs stay together as word tokens.
+ */
+function tokenizeVisible(text) {
+    const tokens = [];
+    let ascii = "";
+    const flush = () => { if (ascii) {
+        tokens.push(ascii);
+        ascii = "";
+    } };
+    let i = 0;
+    while (i < text.length) {
+        const cp = text.codePointAt(i) ?? 0;
+        const chLen = cp > 0xffff ? 2 : 1;
+        const ch = text.slice(i, i + chLen);
+        if (ch === " ") {
+            flush();
+            let spaces = "";
+            while (i < text.length && text[i] === " ") {
+                spaces += " ";
+                i += 1;
+            }
+            tokens.push(spaces);
+            continue;
+        }
+        if (charWidth(cp) === 2) {
+            flush();
+            tokens.push(ch);
+            i += chLen;
+            continue;
+        }
+        ascii += ch;
+        i += chLen;
+    }
+    flush();
+    return tokens;
+}
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ *
+ * Handles CJK text by breaking between wide characters and applying basic
+ * CJK rules (closing punctuation sticks to the previous line; opening
+ * punctuation sticks to the next).
  */
 export function wrapLine(text, maxWidth) {
     if (!(maxWidth > 0))
@@ -11,63 +67,92 @@ export function wrapLine(text, maxWidth) {
     if (visibleLen(text) <= maxWidth)
         return [text];
     const result = [];
-    // Split into segments: ANSI codes and visible text
     const segments = text.match(/(\x1b\[[^m]*m|[^\x1b]+)/g) || [text];
-    let currentLine = "";
-    let currentWidth = 0;
-    let activeStyles = ""; // track ANSI styles to reapply after wraps
+    let lineTokens = [];
+    let lineWidth = 0;
+    let activeStyles = "";
+    let lastVisibleIdx = -1;
+    const commit = () => {
+        result.push(lineTokens.join("") + p.reset);
+        lineTokens = activeStyles ? [activeStyles] : [];
+        lineWidth = 0;
+        lastVisibleIdx = -1;
+    };
     for (const seg of segments) {
         if (seg.startsWith("\x1b[")) {
-            // ANSI code — track it, add to current line
-            currentLine += seg;
-            if (seg === p.reset) {
+            lineTokens.push(seg);
+            if (seg === p.reset)
                 activeStyles = "";
-            }
-            else {
+            else
                 activeStyles += seg;
-            }
             continue;
         }
-        // Visible text — split into words
-        const words = seg.split(/( +)/);
-        for (const word of words) {
-            if (word.length === 0)
+        for (const token of tokenizeVisible(seg)) {
+            const tokenWidth = visibleLen(token);
+            const isSpace = token[0] === " ";
+            if (lineWidth + tokenWidth <= maxWidth) {
+                lineTokens.push(token);
+                lineWidth += tokenWidth;
+                if (!isSpace)
+                    lastVisibleIdx = lineTokens.length - 1;
                 continue;
-            if (currentWidth + word.length <= maxWidth) {
-                currentLine += word;
-                currentWidth += word.length;
             }
-            else if (currentWidth === 0) {
-                // Single word longer than maxWidth — hard break
-                let remaining = word;
+            // Token doesn't fit on the current line.
+            if (isSpace)
+                continue; // spaces at wrap points are dropped
+            if (lineWidth === 0) {
+                // Token longer than the entire line — hard-break by char width.
+                let remaining = token;
                 while (remaining.length > 0) {
-                    const chunk = remaining.slice(0, maxWidth - currentWidth || maxWidth);
-                    remaining = remaining.slice(chunk.length);
-                    currentLine += chunk;
-                    if (remaining.length > 0) {
-                        result.push(currentLine + p.reset);
-                        currentLine = activeStyles;
-                        currentWidth = 0;
-                    }
-                    else {
-                        currentWidth += chunk.length;
+                    let fitLen = 0, fitWidth = 0;
+                    for (const ch of remaining) {
+                        const cw = charWidth(ch.codePointAt(0) ?? 0);
+                        if (fitWidth + cw > maxWidth)
+                            break;
+                        fitWidth += cw;
+                        fitLen += ch.length;
                     }
+                    if (fitLen === 0)
+                        fitLen = remaining[0]?.length ?? 1;
+                    const chunk = remaining.slice(0, fitLen);
+                    remaining = remaining.slice(fitLen);
+                    lineTokens.push(chunk);
+                    lineWidth += visibleLen(chunk);
+                    lastVisibleIdx = lineTokens.length - 1;
+                    if (remaining.length > 0)
+                        commit();
+                }
+                continue;
+            }
+            // Rule (a): closing punctuation must not start a line. Allow up to 2
+            // columns of overflow so the punctuation stays with its phrase.
+            if (CJK_NO_LINE_START.has(token)) {
+                lineTokens.push(token);
+                lineWidth += tokenWidth;
+                commit();
+                continue;
+            }
+            // Rule (b): opening punctuation must not end a line. Pull the trailing
+            // opener down to the next line with us.
+            let carried = [];
+            if (lastVisibleIdx >= 0 && CJK_NO_LINE_END.has(lineTokens[lastVisibleIdx])) {
+                carried = lineTokens.splice(lastVisibleIdx);
+                while (lineTokens.length > 0 && /^ +$/.test(lineTokens[lineTokens.length - 1])) {
+                    lineTokens.pop();
                 }
             }
-            else {
-                // Wrap to next line
-                result.push(currentLine + p.reset);
-                currentLine = activeStyles;
-                currentWidth = 0;
-                // Skip leading spaces on new line
-                const trimmed = word.replace(/^ +/, "");
-                currentLine += trimmed;
-                currentWidth = trimmed.length;
+            commit();
+            for (const t of carried) {
+                lineTokens.push(t);
+                lineWidth += visibleLen(t);
             }
+            lineTokens.push(token);
+            lineWidth += tokenWidth;
+            lastVisibleIdx = lineTokens.length - 1;
         }
     }
-    if (currentLine.length > 0) {
-        result.push(currentLine);
+    if (lineWidth > 0) {
+        result.push(lineTokens.join(""));
     }
     return result;
 }
@@ -173,17 +258,17 @@ export class MarkdownRenderer {
             while (row.length < numCols)
                 row.push("");
         }
-        // Calculate column widths from content
+        // Width from rendered cell — raw `**bold**` over-counts by 4 per pair.
         const colWidths = new Array(numCols).fill(0);
         for (const row of dataRows) {
             for (let c = 0; c < numCols; c++) {
-                colWidths[c] = Math.max(colWidths[c], visibleLen(row[c]));
+                colWidths[c] = Math.max(colWidths[c], visibleLen(this.renderInline(row[c])));
             }
         }
-        // Shrink columns proportionally if total exceeds content width
-        // Account for separators: " │ " between cols (3 chars each) + 2 outer padding
+        // Tables bypass the prose width cap — borders guide the eye, so wider is fine.
         const separatorWidth = (numCols - 1) * 3;
-        const availableWidth = this.contentWidth - separatorWidth;
+        const tableWidth = Math.max(10, this.width - 2);
+        const availableWidth = tableWidth - separatorWidth;
         const totalWidth = colWidths.reduce((a, b) => a + b, 0);
         if (totalWidth > availableWidth && availableWidth > numCols) {
             const scale = availableWidth / totalWidth;
@@ -201,7 +286,10 @@ export class MarkdownRenderer {
             const isHeader = hasHeader && i === 0;
             const cells = row.map((cell, c) => {
                 const w = colWidths[c];
-                const text = visibleLen(cell) > w ? truncateToWidth(cell, w) : padEndToWidth(cell, w);
+                const rendered = this.renderInline(cell);
+                const text = visibleLen(rendered) > w
+                    ? truncateAnsiToWidth(rendered, w)
+                    : padEndToWidth(rendered, w);
                 return isHeader ? `${p.bold}${text}${p.reset}` : text;
             });
             this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);

package/dist/utils/package-version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/utils/package-version.js

@@ -0,0 +1,10 @@
+/**
+ * The agent-sh package version, read from package.json at load time.
+ * Emitted on `agent:info` so consumers (TUI, remote peers, logs) see a
+ * version that tracks releases instead of a hand-edited constant.
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+// dist/utils/package-version.js → ../../package.json (project root)
+const pkg = require("../../package.json");
+export const PACKAGE_VERSION = pkg.version ?? "0.0.0";

package/dist/utils/shell-output-spill.d.ts

@@ -0,0 +1,2 @@
+export declare function getSessionDir(): string;
+export declare function spillOutput(id: number, text: string): string;

package/dist/utils/shell-output-spill.js

@@ -0,0 +1,81 @@
+/**
+ * Spill long shell outputs to per-session tempfiles.
+ *
+ * Captured PTY output that exceeds the truncation threshold is written to
+ * `<tmpdir>/agent-sh-<pid>/<id>.out`. The in-memory exchange keeps only a
+ * head+tail stub pointing at that path, so the agent can fetch the full
+ * text via `read_file` on demand. The session dir is removed on process
+ * exit; stale dirs from dead processes are swept lazily on first use.
+ */
+import { mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const DIR_PREFIX = "agent-sh-";
+let sessionDir = null;
+let cleanupRegistered = false;
+export function getSessionDir() {
+    if (sessionDir)
+        return sessionDir;
+    sessionDir = join(tmpdir(), `${DIR_PREFIX}${process.pid}`);
+    mkdirSync(sessionDir, { recursive: true });
+    sweepStaleDirs();
+    if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        const cleanup = () => {
+            if (!sessionDir)
+                return;
+            try {
+                rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch { }
+            sessionDir = null;
+        };
+        process.on("exit", cleanup);
+        for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+            process.on(sig, () => { cleanup(); process.exit(128); });
+        }
+    }
+    return sessionDir;
+}
+export function spillOutput(id, text) {
+    const path = join(getSessionDir(), `${id}.out`);
+    writeFileSync(path, text);
+    return path;
+}
+function sweepStaleDirs() {
+    const base = tmpdir();
+    let entries;
+    try {
+        entries = readdirSync(base);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (!name.startsWith(DIR_PREFIX))
+            continue;
+        const pid = Number(name.slice(DIR_PREFIX.length));
+        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+            continue;
+        if (isProcessAlive(pid))
+            continue;
+        const full = join(base, name);
+        try {
+            // Small safety check: only remove directories.
+            if (statSync(full).isDirectory()) {
+                rmSync(full, { recursive: true, force: true });
+            }
+        }
+        catch { }
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // ESRCH = no such process; EPERM = exists but we can't signal it
+        return e.code === "EPERM";
+    }
+}

package/examples/extensions/claude-code-bridge/README.md

@@ -33,3 +33,17 @@ Or switch at runtime:
 
 - `ANTHROPIC_API_KEY` must be set in your environment
 - Claude Code manages its own model selection — no model configuration needed in agent-sh
+
+## What this bridge is
+
+A pure protocol translator between the Claude Agent SDK's event stream and agent-sh's bus events. Claude Code uses its own built-in tools exactly as the SDK ships them (`Read`, `Edit`, `Write`, `Bash`, `Glob`, `Grep`). The bridge adds no tools of its own.
+
+## What this bridge intentionally does NOT bundle
+
+Three PTY-access tools are left out on purpose:
+
+- `terminal_read` — observe the user's live terminal screen
+- `terminal_keys` — send keystrokes to the user's PTY
+- `user_shell` — run commands in the user's live shell with lasting `cd`/`export`/`source` effects
+
+These are opt-in capabilities that belong in their own extensions. If you want any of them with Claude Code, write a companion extension that uses the SDK's `tool()` + `createSdkMcpServer()` to expose them as MCP tools, and extend the bridge (or fork it) to attach that MCP server to the SDK's `query()` options.