@giovannijecha/jecode 0.2.1 → 0.2.2

package/dist/controller.js

@@ -38,41 +38,58 @@ export async function runTurn(history, options, events, signal) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         history.push(assistant);
-        if (assistant.usage !== undefined)
-            events.onUsage?.(assistant.usage);
-        if (calls.length === 0)
+        if (calls.length === 0) {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
             return; // the model is done — hand back to the user
+        }
         // Calls run one after another because approval prompts serialise anyway,
         // but every result from this step goes back in a SINGLE message. Splitting
         // them teaches the model to stop batching its calls.
         const results = [];
         const announced = new Set();
         try {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
             for (let index = 0; index < calls.length; index++) {
                 throwIfAborted(signal);
                 const call = calls[index];
                 events.onToolProgress?.(index + 1, calls.length);
                 const preview = await look(call, options, signal);
                 throwIfAborted(signal);
-                events.onToolCall(call, preview);
                 announced.add(call.id);
+                events.onToolCall(call, preview);
                 const { result, summary } = await settle(call, options, events, signal, preview);
-                events.onToolResult(call, result, summary);
                 results.push(result);
+                events.onToolResult(call, result, summary);
             }
         }
         catch (error) {
-            if (signal?.aborted !== true)
-                throw error;
+            const interrupted = signal?.aborted === true;
+            const repairs = [];
             for (const call of calls.slice(results.length)) {
-                const interrupted = refuse(call, "interrupted before completion", "interrupted");
-                if (announced.has(call.id)) {
-                    events.onToolResult(call, interrupted.result, interrupted.summary);
-                }
-                results.push(interrupted.result);
+                const run = interrupted
+                    ? refuse(call, "interrupted before completion", "interrupted")
+                    : refuse(call, "tool processing stopped before completion", "failed");
+                repairs.push({ call, run });
+                results.push(run.result);
             }
             history.push({ role: "user", content: results });
-            throw abortReason(signal);
+            // History repair is the invariant. UI recovery is best-effort and must
+            // never replace the original exception or leave the conversation open.
+            for (const { call, run } of repairs) {
+                if (!announced.has(call.id))
+                    continue;
+                try {
+                    events.onToolResult(call, run.result, run.summary);
+                }
+                catch {
+                    // The surface is already failing; the next turn can still proceed.
+                }
+            }
+            if (interrupted)
+                throw abortReason(signal);
+            throw error;
         }
         history.push({ role: "user", content: results });
     }

package/dist/credential-safety.js

@@ -2,6 +2,12 @@
 import { credentialValues } from "./credentials.js";
 import { accountValues } from "./accounts.js";
 const REDACTED = "[credential redacted]";
+const MIN_HEURISTIC_SECRET_CHARS = 8;
+const EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES = new Set([
+    "ANTHROPIC_API_KEY",
+    "OLLAMA_API_KEY",
+    "OPENAI_API_KEY",
+]);
 const SENSITIVE_ENVIRONMENT_NAME = /(?:^|_)(?:API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|PWD|CREDENTIALS?|AUTH|JWT|COOKIE|PAT)(?:_|$)/i;
 const COMPACT_SENSITIVE_ENVIRONMENT_NAME = /^(?:PGPASSWORD)$/i;
 const SAFE_ENVIRONMENT_NAMES = new Set([
@@ -71,8 +77,12 @@ function sensitiveEnvironmentName(name) {
 function secrets(source) {
     const values = new Set([...credentialValues(), ...accountValues()]);
     for (const [name, value] of Object.entries(source)) {
-        if (value !== undefined && value !== "" && sensitiveEnvironment(name, value))
+        if (value === undefined || value === "")
+            continue;
+        const explicit = EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES.has(name.toUpperCase());
+        if (explicit || (value.length >= MIN_HEURISTIC_SECRET_CHARS && sensitiveEnvironment(name, value))) {
             values.add(value);
+        }
     }
     return [...values].filter((value) => value !== "").sort((left, right) => right.length - left.length);
 }

package/dist/tools/search.js

@@ -8,6 +8,7 @@ const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
+const MAX_GLOB_CHARS = 512;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
     name: "find_files",
@@ -17,7 +18,10 @@ export const findFiles = {
     input: {
         type: "object",
         properties: {
-            pattern: { type: "string", description: "Glob matched against workspace-relative paths." },
+            pattern: {
+                type: "string",
+                description: "Glob matched against workspace-relative paths. Maximum 512 characters.",
+            },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
             max_results: { type: "integer", description: "Maximum paths returned. Defaults to 100, caps at 500." },
         },
@@ -52,7 +56,10 @@ export const searchText = {
         properties: {
             query: { type: "string", description: "Literal text to find." },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
-            pattern: { type: "string", description: "Optional file glob, for example **/*.ts." },
+            pattern: {
+                type: "string",
+                description: "Optional file glob, for example **/*.ts. Maximum 512 characters.",
+            },
             case_sensitive: { type: "boolean", description: "Defaults to false." },
             max_results: { type: "integer", description: "Maximum matching lines. Defaults to 100, caps at 500." },
         },
@@ -166,29 +173,107 @@ function resultLimit(args) {
 }
 function glob(pattern) {
     const normalized = pattern.replace(/\\/g, "/");
-    let source = "";
-    for (let index = 0; index < normalized.length; index++) {
-        const char = normalized[index];
-        if (char === "*" && normalized[index + 1] === "*") {
-            if (normalized[index + 2] === "/") {
-                source += "(?:.*/)?";
-                index += 2;
+    if (normalized.length > MAX_GLOB_CHARS) {
+        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
+    }
+    const tokens = tokenizeGlob(normalized.toLowerCase());
+    const basenameOnly = !normalized.includes("/");
+    return (relative) => {
+        const candidate = relative.replace(/\\/g, "/");
+        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
+        return matchGlob(tokens, Array.from(target));
+    };
+}
+function tokenizeGlob(pattern) {
+    const chars = Array.from(pattern);
+    const tokens = [];
+    let index = 0;
+    while (index < chars.length) {
+        const char = chars[index];
+        if (char === "*") {
+            let end = index + 1;
+            while (chars[end] === "*")
+                end++;
+            if (end - index >= 2) {
+                if (chars[end] === "/") {
+                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
+                    index = end + 1;
+                }
+                else {
+                    tokens.push({ kind: "globstar" });
+                    index = end;
+                }
             }
             else {
-                source += ".*";
-                index++;
+                tokens.push({ kind: "star" });
+                index = end;
             }
+            continue;
         }
-        else if (char === "*")
-            source += "[^/]*";
-        else if (char === "?")
-            source += "[^/]";
-        else
-            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
+        index++;
     }
-    const expression = new RegExp(`^${source}$`, "i");
-    const basenameOnly = !normalized.includes("/");
-    return (relative) => expression.test(basenameOnly ? path.posix.basename(relative) : relative);
+    return tokens;
+}
+/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
+function matchGlob(tokens, text) {
+    let states = epsilonClosure(new Set([0]), tokens);
+    for (const char of text) {
+        const next = new Set();
+        for (const state of states) {
+            const token = tokens[state];
+            if (token === undefined)
+                continue;
+            switch (token.kind) {
+                case "literal":
+                    if (token.value === char)
+                        next.add(state + 1);
+                    break;
+                case "one":
+                    if (char !== "/")
+                        next.add(state + 1);
+                    break;
+                case "star":
+                    if (char !== "/")
+                        next.add(state);
+                    break;
+                case "globstar":
+                    next.add(state);
+                    break;
+                case "globdir-body":
+                    next.add(state);
+                    if (char === "/")
+                        next.add(state + 1);
+                    break;
+                case "globdir-start":
+                    break;
+            }
+        }
+        states = epsilonClosure(next, tokens);
+        if (states.size === 0)
+            return false;
+    }
+    return epsilonClosure(states, tokens).has(tokens.length);
+}
+function epsilonClosure(seed, tokens) {
+    const states = new Set(seed);
+    const pending = [...seed];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        const token = tokens[state];
+        const targets = token?.kind === "globdir-start"
+            ? [state + 1, state + 2]
+            : token?.kind === "star" || token?.kind === "globstar"
+                ? [state + 1]
+                : [];
+        for (const target of targets) {
+            if (states.has(target))
+                continue;
+            states.add(target);
+            pending.push(target);
+        }
+    }
+    return states;
 }
 function summary(count, limit, capped, one, many) {
     const noun = count === 1 ? one : many;

package/dist/tools/shell.js

@@ -4,7 +4,9 @@ import { spawn } from "node:child_process";
 import { optionalInt, requireString } from "./args.js";
 import { credentialRedactor, redactCredentials, shellEnvironment } from "../credential-safety.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_OUTPUT_CHARS = 30_000;
+const PIPE_DRAIN_MS = 100;
 export const runCommand = {
     name: "run_command",
     description: "Run a shell command starting in the workspace root and return its combined stdout " +
@@ -24,6 +26,9 @@ export const runCommand = {
         const timeoutMs = optionalInt(args, "timeout_ms") ?? DEFAULT_TIMEOUT_MS;
         if (timeoutMs <= 0)
             throw new Error('"timeout_ms" must be a positive integer');
+        if (timeoutMs > MAX_TIMEOUT_MS) {
+            throw new Error(`"timeout_ms" must be at most ${MAX_TIMEOUT_MS}ms`);
+        }
         const result = await execute(command, ctx.root, timeoutMs, ctx.signal, ctx.onOutput);
         const output = redactCredentials(result.output);
         const summary = result.timedOut
@@ -53,6 +58,7 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
         let aborted;
         let settled = false;
         let forceTimer;
+        let drainTimer;
         const timer = setTimeout(() => {
             timedOut = true;
             stopTree(child.pid, false);
@@ -68,8 +74,20 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             clearTimeout(timer);
             if (forceTimer !== undefined)
                 clearTimeout(forceTimer);
+            if (drainTimer !== undefined)
+                clearTimeout(drainTimer);
             signal?.removeEventListener("abort", onAbort);
         };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (aborted !== undefined)
+                reject(aborted);
+            else
+                resolve({ output: output.value().trimEnd(), code, timedOut });
+        };
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", output.append);
@@ -81,16 +99,17 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             cleanup();
             reject(error);
         });
-        child.on("close", (code) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (aborted !== undefined)
-                reject(aborted);
-            else
-                resolve({ output: output.value().trimEnd(), code, timedOut });
+        child.on("exit", (code) => {
+            // `close` normally follows once both pipes drain. A detached descendant
+            // can inherit those descriptors after the command itself has exited,
+            // though, so bound that final drain instead of hanging the tool on it.
+            drainTimer = setTimeout(() => {
+                child.stdout.destroy();
+                child.stderr.destroy();
+                finish(code);
+            }, PIPE_DRAIN_MS);
         });
+        child.on("close", finish);
     });
 }
 function capture(onOutput) {

package/dist/tui/app.js

@@ -34,6 +34,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let closed;
     let frameTimer;
     let spinTimer;
+    let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
     // Timers outlive the teardown they were scheduled before. Painting after the
@@ -118,6 +119,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             clearInterval(spinTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
         feedback.close();
         terminal.leave();
         closed?.();
@@ -204,12 +207,23 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         draw();
     });
     stopInput = terminal.onInput((chunk) => {
-        for (const key of keys.push(chunk))
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
+        for (const key of keys.push(chunk)) {
+            if (!live)
+                break;
             input.handle(key);
-        setTimeout(() => {
+        }
+        if (!live)
+            return;
+        escapeTimer = setTimeout(() => {
+            escapeTimer = undefined;
+            if (!live)
+                return;
             for (const key of keys.flush())
                 input.handle(key);
-            render();
+            if (live)
+                render();
         }, ESCAPE_MS);
         render();
     });

package/dist/tui/keys.js

@@ -12,6 +12,8 @@ const PASTE_END = "[201~";
 // one packs the coordinates into single bytes and simply stops being able to
 // say where the pointer is past column 223.
 const MOUSE = /^\[<(\d+);(\d+);(\d+)([Mm])/;
+const CSI_SEQUENCE = /^\[[0-?]*[ -/]*[@-~]/;
+const SS3_SEQUENCE = /^O[ -~]/;
 const BUTTONS = ["left", "middle", "right", "none"];
 // Both the normal and the application-cursor forms, because a terminal sends
 // either depending on the mode it thinks it is in.
@@ -59,6 +61,16 @@ export function decoder() {
             if (pasting) {
                 const end = held.indexOf(ESC + PASTE_END);
                 if (end === -1) {
+                    const interrupt = firstInterrupt(held);
+                    if (interrupt !== -1) {
+                        // A missing bracketed-paste terminator must not trap the decoder
+                        // forever. Ctrl+C/Ctrl+D are emergency exits: discard the partial
+                        // paste, then let the normal control-key path handle the byte.
+                        held = held.slice(interrupt);
+                        pasted = "";
+                        pasting = false;
+                        continue;
+                    }
                     // Hold back a possible partial terminator rather than pasting it.
                     const safe = held.length - PASTE_END.length - 1;
                     if (safe > 0) {
@@ -96,6 +108,13 @@ export function decoder() {
                     keys.push({ name: SEQUENCES[match], text: "", ctrl: false });
                     continue;
                 }
+                const unbound = completeTerminalSequence(rest);
+                if (unbound !== undefined) {
+                    // Terminals have many optional keys and mode reports. An unbound but
+                    // complete CSI/SS3 sequence is terminal protocol, never editor text.
+                    held = rest.slice(unbound.length);
+                    continue;
+                }
                 if (!final && couldGrow(rest))
                     break;
                 held = held.slice(1);
@@ -139,6 +158,15 @@ export function decoder() {
         },
     };
 }
+function firstInterrupt(text) {
+    const ctrlC = text.indexOf(String.fromCharCode(3));
+    const ctrlD = text.indexOf(String.fromCharCode(4));
+    if (ctrlC === -1)
+        return ctrlD;
+    if (ctrlD === -1)
+        return ctrlC;
+    return Math.min(ctrlC, ctrlD);
+}
 function matchSequence(rest) {
     for (const seq of Object.keys(SEQUENCES)) {
         if (rest.startsWith(seq))
@@ -146,10 +174,15 @@ function matchSequence(rest) {
     }
     return undefined;
 }
+function completeTerminalSequence(rest) {
+    return CSI_SEQUENCE.exec(rest)?.[0] ?? SS3_SEQUENCE.exec(rest)?.[0];
+}
 /** Whether `rest` is still a viable prefix of something we know. */
 function couldGrow(rest) {
     if (PASTE_START.startsWith(rest))
         return true;
+    if (/^\[[0-?]*[ -/]*$/.test(rest))
+        return true;
     // A mouse report has no fixed length, so it grows until its final letter.
     if (/^\[<?\d*;?\d*;?\d*$/.test(rest))
         return true;

package/dist/tui/screen.js

@@ -37,6 +37,7 @@ const CURSOR_RESET = `${CSI}0 q`;
 const SYNC_BEGIN = `${CSI}?2026h`;
 const SYNC_END = `${CSI}?2026l`;
 let active = false;
+let handlersRegistered = false;
 export function interactive() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -53,9 +54,7 @@ export function enter(reducedMotion = false) {
     if (active)
         return;
     active = true;
-    process.on("exit", leave);
-    process.on("SIGTERM", onFatalSignal);
-    process.on("SIGHUP", onFatalSignal);
+    registerProcessHandlers();
     write(ALT_ON + WRAP_OFF + CURSOR_HIDE + (reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK) + PASTE_ON + MOUSE_ON);
     process.stdin.setRawMode(true);
     process.stdin.setEncoding("utf8");
@@ -74,9 +73,24 @@ export function setReducedMotion(reducedMotion) {
     if (active)
         write(reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK);
 }
-function onFatalSignal() {
+function registerProcessHandlers() {
+    if (handlersRegistered)
+        return;
+    handlersRegistered = true;
+    process.on("exit", leave);
+    process.on("uncaughtExceptionMonitor", leave);
+    process.on("SIGTERM", onSigterm);
+    process.on("SIGHUP", onSighup);
+}
+function onSigterm() {
+    onFatalSignal(15);
+}
+function onSighup() {
+    onFatalSignal(1);
+}
+function onFatalSignal(number) {
     leave();
-    process.exit(0);
+    process.exit(128 + number);
 }
 export function onResize(handler) {
     process.stdout.on("resize", handler);

package/dist/ui/width.js

@@ -27,6 +27,43 @@ const WIDE = [
     [0x1fa70, 0x1faff],
     [0x20000, 0x3fffd],
 ];
+/** Default emoji-presentation ranges below the main supplementary blocks. */
+const EMOJI_WIDE = [
+    [0x231a, 0x231b],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+    [0x1f1e6, 0x1f1ff],
+];
 /** Ranges that occupy no cell of their own: they attach to what precedes. */
 const ZERO = [
     [0x0300, 0x036f],
@@ -54,6 +91,7 @@ function inRanges(code, ranges) {
 }
 // The emoji presentation selector, built rather than typed: an invisible byte
 // in source is a byte nobody reviews.
+const VS15 = String.fromCodePoint(0xfe0e);
 const VS16 = String.fromCodePoint(0xfe0f);
 // Grapheme segmentation is in the standard library, so a family emoji built
 // out of five code points and three joiners counts as the one thing the
@@ -80,9 +118,11 @@ export function charWidth(cluster) {
         return 0;
     if (inRanges(code, ZERO))
         return 0;
+    if (cluster.includes(VS15))
+        return inRanges(code, WIDE) ? 2 : 1;
     if (cluster.includes(VS16))
         return 2;
-    return inRanges(code, WIDE) ? 2 : 1;
+    return inRanges(code, WIDE) || inRanges(code, EMOJI_WIDE) ? 2 : 1;
 }
 export function textWidth(text) {
     let total = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {