@giovannijecha/jecode 0.8.2 → 0.8.4

package/dist/tui/app.js

@@ -42,6 +42,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
+    let stopShutdown = () => { };
     let failure;
     let activeWorkflow;
     // Timers outlive the teardown they were scheduled before. Painting after the
@@ -158,6 +159,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         live = false;
         safely(stopInput);
         safely(stopResize);
+        safely(stopShutdown);
         if (activityTimer !== undefined)
             clearInterval(activityTimer);
         if (frameTimer !== undefined)
@@ -194,15 +196,15 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         activeWorkflow = tracked;
         return tracked;
     }
-    function requestQuit() {
+    function requestQuit(reason = new Error("interrupted")) {
+        state.open = overlay.cancel(state.open);
         const activity = state.activity;
         if (activity === undefined) {
             quit();
             return;
         }
         state.closeWhenIdle = true;
-        state.open = overlay.cancel(state.open);
-        activity.control.abort(new Error("interrupted"));
+        activity.control.abort(reason);
     }
     function startActivity(kind, label) {
         if (state.activity !== undefined)
@@ -305,6 +307,12 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         }
     }
     try {
+        const shutdownSignal = environment.shutdownSignal;
+        const onShutdown = () => requestQuit(shutdownSignal?.reason);
+        if (shutdownSignal?.aborted === true)
+            return;
+        shutdownSignal?.addEventListener("abort", onShutdown, { once: true });
+        stopShutdown = () => shutdownSignal?.removeEventListener("abort", onShutdown);
         terminal.enter(session.config.reducedMotion);
         stopResize = terminal.onResize(() => guard(() => {
             paint.invalidate();

package/dist/tui/editor.js

@@ -2,12 +2,14 @@
 //
 // Pure functions over an immutable state — no rendering, no I/O — so the whole
 // line editor is testable without a terminal.
+import { assertPromptAppend } from "../input-boundary.js";
 import { graphemes } from "../ui/width.js";
 export const EMPTY = { text: "", cursor: 0 };
 export function of(text) {
     return { text, cursor: text.length };
 }
 export function insert(state, chunk) {
+    assertPromptAppend(state.text.length, chunk.length);
     return {
         text: state.text.slice(0, state.cursor) + chunk + state.text.slice(state.cursor),
         cursor: state.cursor + chunk.length,

package/dist/tui/keys.js

@@ -4,6 +4,7 @@
 // sequence can be split across reads, so an incomplete one is held rather than
 // guessed at; and a bracketed paste arrives as a delimited run that must not be
 // interpreted key by key, or a pasted newline submits half the paste.
+import { MAX_PROMPT_CODE_UNITS } from "../input-boundary.js";
 const ESC = String.fromCharCode(27);
 const BS = String.fromCharCode(8);
 const DEL = String.fromCharCode(127);
@@ -64,6 +65,17 @@ export function decoder(options = {}) {
     let held = "";
     let pasting = false;
     let pasted = "";
+    let pasteTooLong = false;
+    const appendPaste = (text) => {
+        if (pasteTooLong || text === "")
+            return;
+        if (text.length > MAX_PROMPT_CODE_UNITS - pasted.length) {
+            pasted = "";
+            pasteTooLong = true;
+            return;
+        }
+        pasted += text;
+    };
     const drain = (final) => {
         const keys = [];
         while (held !== "") {
@@ -77,22 +89,26 @@ export function decoder(options = {}) {
                         // paste, then let the normal control-key path handle the byte.
                         held = held.slice(interrupt);
                         pasted = "";
+                        pasteTooLong = false;
                         pasting = false;
                         continue;
                     }
                     // Hold back a possible partial terminator rather than pasting it.
                     const safe = held.length - PASTE_END.length - 1;
                     if (safe > 0) {
-                        pasted += held.slice(0, safe);
+                        appendPaste(held.slice(0, safe));
                         held = held.slice(safe);
                     }
                     break;
                 }
-                pasted += held.slice(0, end);
+                appendPaste(held.slice(0, end));
                 held = held.slice(end + PASTE_END.length + 1);
                 pasting = false;
-                keys.push({ name: "paste", text: pasted, ctrl: false });
+                keys.push(pasteTooLong
+                    ? { name: "input_limit", text: "", ctrl: false }
+                    : { name: "paste", text: pasted, ctrl: false });
                 pasted = "";
+                pasteTooLong = false;
                 continue;
             }
             const ch = held[0];
@@ -103,6 +119,7 @@ export function decoder(options = {}) {
                 if (rest.startsWith(PASTE_START)) {
                     held = rest.slice(PASTE_START.length);
                     pasting = true;
+                    pasteTooLong = false;
                     continue;
                 }
                 const mouse = MOUSE.exec(rest);
@@ -161,14 +178,56 @@ export function decoder(options = {}) {
     };
     return {
         push(chunk) {
-            held += chunk;
-            return drain(false);
+            // The usual printable run needs no protocol buffering. This also rejects
+            // one unbracketed paste atomically before copying it into `held`.
+            if (held === "" && !pasting && printable(chunk)) {
+                return [chunk.length > MAX_PROMPT_CODE_UNITS
+                        ? { name: "input_limit", text: "", ctrl: false }
+                        : { name: "char", text: chunk, ctrl: false }];
+            }
+            const keys = [];
+            const chunkSize = 64 * 1_024;
+            for (let from = 0; from < chunk.length;) {
+                let to = Math.min(from + chunkSize, chunk.length);
+                if (to < chunk.length &&
+                    isHighSurrogate(chunk.charCodeAt(to - 1)) &&
+                    isLowSurrogate(chunk.charCodeAt(to))) {
+                    to++;
+                }
+                const part = chunk.slice(from, to);
+                from = to;
+                if (part.length > MAX_PROMPT_CODE_UNITS - held.length) {
+                    held = "";
+                    pasted = "";
+                    pasting = false;
+                    pasteTooLong = false;
+                    keys.push({ name: "input_limit", text: "", ctrl: false });
+                    break;
+                }
+                held += part;
+                keys.push(...drain(false));
+            }
+            return keys;
         },
         flush() {
             return drain(true);
         },
     };
 }
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+function printable(text) {
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if ((char.codePointAt(0) ?? 0) < 0x20 || char === ESC || char === DEL)
+            return false;
+    }
+    return text !== "";
+}
 function firstInterrupt(text) {
     const ctrlC = text.indexOf(String.fromCharCode(3));
     const ctrlD = text.indexOf(String.fromCharCode(4));

package/dist/tui/overlay.js

@@ -2,6 +2,7 @@
 import * as picker from "./picker.js";
 import { oneLine } from "./field.js";
 import { applyKey } from "./input.js";
+import { PromptLimitError } from "../input-boundary.js";
 export function shown(open) {
     if (open === undefined)
         return undefined;
@@ -33,10 +34,17 @@ export function handle(open, key) {
         cancel(open);
         return {};
     }
-    if ("picker" in open)
-        return handlePicker(open, key);
-    if ("field" in open)
-        return handleField(open, key);
+    try {
+        if ("picker" in open)
+            return handlePicker(open, key);
+        if ("field" in open)
+            return handleField(open, key);
+    }
+    catch (error) {
+        if (error instanceof PromptLimitError)
+            return { open, inputLimit: true };
+        throw error;
+    }
     return { open };
 }
 function handlePicker(open, key) {

package/dist/tui/picker.js

@@ -1,6 +1,7 @@
 // One interaction model for every terminal selector.
 import { row } from "../ui/render.js";
 import { elide, graphemes } from "../ui/width.js";
+import { assertPromptAppend } from "../input-boundary.js";
 import { menuWindow, renderMenuRows } from "./components/menu.js";
 import { promptCursor, promptLine } from "./components/prompt.js";
 const WINDOW = 6;
@@ -28,6 +29,7 @@ export function adjust(picker, step) {
 export function type(picker, text) {
     if (picker.searchable !== true || text === "")
         return picker;
+    assertPromptAppend((picker.query ?? "").length, text.length);
     return withQuery(picker, `${picker.query ?? ""}${text}`);
 }
 export function backspace(picker) {

package/dist/tui/screen.js

@@ -37,7 +37,7 @@ const CURSOR_RESET = `${CSI}0 q`;
 const SYNC_BEGIN = `${CSI}?2026h`;
 const SYNC_END = `${CSI}?2026l`;
 let active = false;
-let handlersRegistered = false;
+let restoreHandlersRegistered = false;
 export function interactive() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -54,7 +54,7 @@ export function enter(reducedMotion = false) {
     if (active)
         return;
     active = true;
-    registerProcessHandlers();
+    registerRestoreHandlers();
     write(ALT_ON + WRAP_OFF + CURSOR_HIDE + (reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK) + PASTE_ON + MOUSE_ON);
     process.stdin.setRawMode(true);
     process.stdin.setEncoding("utf8");
@@ -73,24 +73,12 @@ export function setReducedMotion(reducedMotion) {
     if (active)
         write(reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK);
 }
-function registerProcessHandlers() {
-    if (handlersRegistered)
+function registerRestoreHandlers() {
+    if (restoreHandlersRegistered)
         return;
-    handlersRegistered = true;
+    restoreHandlersRegistered = 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(128 + number);
 }
 export function onResize(handler) {
     process.stdout.on("resize", handler);

package/dist/user-store.js

@@ -0,0 +1,54 @@
+// Bounded synchronous reads for the tiny JSON stores under ~/.jecode.
+import { Buffer } from "node:buffer";
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+export const USER_STORE_LIMITS = Object.freeze({
+    settingsBytes: 64 * 1_024,
+    credentialsBytes: 256 * 1_024,
+    accountsBytes: 128 * 1_024,
+    credentialEntries: 64,
+    credentialName: 256,
+    credentialValue: 16_384,
+    model: 512,
+    endpoint: 2_048,
+    accountToken: 32_768,
+    accountLabel: 1_024,
+});
+export function readBoundedJsonSync(file, maxBytes) {
+    // Non-blocking open keeps a replaced FIFO or device from stalling startup;
+    // fstat below then accepts only regular files before any content is read.
+    const flags = process.platform === "win32"
+        ? "r"
+        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+    const descriptor = openSync(file, flags);
+    try {
+        const details = fstatSync(descriptor);
+        if (!details.isFile())
+            throw new Error("user store must be a regular file");
+        if (!Number.isSafeInteger(details.size) || details.size > maxBytes) {
+            throw new Error(`user store exceeds ${maxBytes} bytes`);
+        }
+        // One extra byte detects an in-place growth after fstat without allowing
+        // the read allocation to follow the file's new size.
+        const capacity = Math.min(maxBytes + 1, Math.max(1, details.size + 1));
+        const bytes = Buffer.allocUnsafe(capacity);
+        let offset = 0;
+        while (offset < capacity) {
+            const count = readSync(descriptor, bytes, offset, capacity - offset, null);
+            if (count === 0)
+                break;
+            offset += count;
+        }
+        if (offset > maxBytes || offset > details.size) {
+            throw new Error("user store changed while it was being read");
+        }
+        return JSON.parse(bytes.toString("utf8", 0, offset));
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+export function assertStoreText(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+        throw new Error(`user store exceeds ${maxBytes} bytes`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -25,7 +25,8 @@
   "files": [
     "bin/",
     "dist/",
-    "docs/assets/brand/jeco-256.png",
+    "assets/jeco-256.png",
+    "assets/wordmark-steel.svg",
     "LICENSE",
     "README.md"
   ],
@@ -44,8 +45,11 @@
     "pack:release": "npm run build:release && npm pack --ignore-scripts",
     "start": "node src/main.ts",
     "tui:lab": "node dev/tui-lab.ts",
-    "bench:transcript": "node dev/benchmark-transcript.ts",
+    "bench:context": "node dev/benchmark-context.ts",
+    "bench:redaction": "node dev/benchmark-redaction.ts",
     "bench:search": "node dev/benchmark-search.ts",
+    "bench:session": "node dev/benchmark-session.ts",
+    "bench:transcript": "node dev/benchmark-transcript.ts",
     "typecheck": "tsc --noEmit",
     "test": "npm run build:release && node --test",
     "coverage": "npm run build:release && node --test --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=80 --test-coverage-branches=75 --test-coverage-functions=75",