@nathapp/nax-agent 0.85.1 → 0.86.0

package/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to `@nathapp/nax-agent` are recorded here. The format follow
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). While the version is `0.x`, a minor
 release may change the public API.
 
+## [0.86.0] - 2026-10-10
+
+- No changes in this package. Released in lockstep with the other nax packages.
+
 ## [0.85.1] - 2026-10-10
 
 ### Added

package/dist/internal/redact.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Matches must pass `acceptMatch`, when present, before masking: the URL scanner also
+ * consumes scheme-only runs to avoid rescanning them on failure.
  * Patterns are reset via `re.lastIndex = 0` before every call because they carry
  * the `/g` flag (required for `String.replace`). Resetting prevents the stale
  * `lastIndex` bug that skips matches on subsequent calls.
@@ -7,6 +9,8 @@
 export interface SecretValuePattern {
     readonly kind: string;
     readonly re: RegExp;
+    /** Reject scanner-only matches that advance past a non-secret run. */
+    readonly acceptMatch?: (match: string) => boolean;
 }
 export declare const SECRET_VALUE_PATTERNS: readonly SecretValuePattern[];
 /**

package/dist/internal/redact.js

@@ -91,7 +91,16 @@ export const SECRET_VALUE_PATTERNS = [
     //   postgres://admin:s3cret@db.internal:5432/prod  →  "postgres://admin:s3cret@"
     //   redis://:hunter2@cache.internal:6379/0          →  "redis://:hunter2@"     (empty user)
     //   mongodb://root:mongoPwd@mongo.internal:27017    →  "mongodb://root:mongoPwd@"
-    { kind: "url-credentials", re: /\b[a-z][a-z0-9+.-]*:\/\/(?:[^/\s@]*:[^/\s@]+)@/gi },
+    // Issue #2428: requiring the credential suffix made a failed scheme run
+    // rescan at every word boundary (quadratic on "a-b-c-..."). Consume the
+    // whole run even without credentials; acceptMatch leaves those
+    // non-secret matches visible. This preserves the original word boundary
+    // and supports arbitrary scheme lengths without rescanning the run.
+    {
+        kind: "url-credentials",
+        re: /\b[a-z][a-z0-9+.-]*(?::\/\/(?:[^/\s@]*:[^/\s@]+)@)?/gi,
+        acceptMatch: (match) => match.endsWith("@"),
+    },
 ];
 const REDACTED = "[REDACTED]";
 /**
@@ -102,11 +111,11 @@ const REDACTED = "[REDACTED]";
 const STRUCTURED_KINDS = new Set(["assignment", "api-key-header"]);
 function redactString(value) {
     let out = value;
-    for (const { kind, re } of SECRET_VALUE_PATTERNS) {
+    for (const { kind, re, acceptMatch } of SECRET_VALUE_PATTERNS) {
         if (STRUCTURED_KINDS.has(kind))
             continue;
         re.lastIndex = 0;
-        out = out.replace(re, REDACTED);
+        out = out.replace(re, (match) => (acceptMatch && !acceptMatch(match) ? match : REDACTED));
     }
     return redactStructured(out);
 }

package/dist/permissions/secret-spans.js

@@ -28,13 +28,14 @@ function referencesVariable(kind, match) {
             .startsWith("$"));
 }
 function rawSpans(text) {
-    return SECRET_VALUE_PATTERNS.flatMap(({ kind, re }) => {
+    return SECRET_VALUE_PATTERNS.flatMap(({ kind, re, acceptMatch }) => {
         // A private copy: the shared /g regex carries lastIndex between callers.
         const scan = new RegExp(re.source, re.flags);
         const found = [];
         for (let m = scan.exec(text); m !== null; m = scan.exec(text)) {
-            if (!referencesVariable(kind, m[0]))
+            if ((!acceptMatch || acceptMatch(m[0])) && !referencesVariable(kind, m[0])) {
                 found.push({ start: m.index, end: m.index + m[0].length, kind });
+            }
         }
         return found;
     });

package/dist/terminal-auth/interaction.js

@@ -25,7 +25,11 @@ export function createTerminalAuthInteraction(options) {
             if (prompt.type === "text")
                 return promptForLine(prompt.message, undefined, style);
             if (prompt.type === "select") {
-                return promptForSelect(prompt.message, prompt.options.map((option) => ({ id: option.id, label: option.label })), style);
+                return promptForSelect(prompt.message, prompt.options.map((option) => ({
+                    id: option.id,
+                    label: option.label,
+                    ...(option.description !== undefined ? { description: option.description } : {}),
+                })), style);
             }
             return promptForSecret(prompt.message, style);
         },

package/dist/terminal-auth/prompt.d.ts

@@ -42,10 +42,15 @@ export declare function promptForLine(message: string, onEmptySubmit?: () => voi
 export interface SelectChoice {
     readonly id: string;
     readonly label: string;
+    readonly description?: string;
 }
 /**
  * Reads a choice with the arrow keys and returns the chosen option's id. The
- * option block is redrawn in place. Enter commits the highlighted row, so a
- * value that is not an option can never be returned.
+ * option block is redrawn in place, so a value that is not an option can never
+ * be returned. Typed characters narrow the block rather than answering it: a
+ * catalog-sized list is scrolled by filtering, not printed whole, and the redraw
+ * moves up only by the rows it drew — a block taller than the terminal cannot be
+ * repainted, because the cursor-up cannot cross the scrollback. Enter with no
+ * match commits nothing.
  */
 export declare function promptForSelect(message: string, choices: readonly SelectChoice[], style?: TerminalStyle): Promise<string>;

package/dist/terminal-auth/prompt.js

@@ -120,10 +120,95 @@ export function promptForSecret(message, style = PLAIN_STYLE) {
 export function promptForLine(message, onEmptySubmit, style = PLAIN_STYLE) {
     return read(message, true, onEmptySubmit, style);
 }
+/** Rows drawn at once. A longer list is narrowed by typing, never printed whole. */
+const MAX_VISIBLE_ROWS = 12;
+/** Case-insensitive label match; an empty filter matches everything. */
+function matchedRows(choices, filter) {
+    const needle = filter.toLowerCase();
+    return needle === "" ? [...choices] : choices.filter((c) => c.label.toLowerCase().includes(needle));
+}
+/** The first row index the window must show so that `active` is visible. */
+function windowStart(active, total) {
+    return Math.min(active, Math.max(0, total - MAX_VISIBLE_ROWS));
+}
+function drawSelectLine(run, text) {
+    _terminalPromptDeps.write(`\r\u001b[2K${text}\n`);
+    run.drawn += 1;
+}
+function drawSelectRow(run, choice, isActive) {
+    const marker = isActive ? run.style.accent(">") : " ";
+    const label = isActive ? run.style.accent(choice.label) : choice.label;
+    const note = isActive && choice.description !== undefined ? ` ${run.style.dim(choice.description)}` : "";
+    drawSelectLine(run, `${marker} ${label}${note}`);
+}
+function renderSelect(run) {
+    const rows = matchedRows(run.choices, run.filter);
+    if (run.active >= rows.length)
+        run.active = 0;
+    const start = windowStart(run.active, rows.length);
+    if (run.drawn > 0)
+        _terminalPromptDeps.write(`\u001b[${run.drawn}A`);
+    run.drawn = 0;
+    drawSelectLine(run, run.style.dim(run.filter));
+    for (const [i, choice] of rows.slice(start, start + MAX_VISIBLE_ROWS).entries()) {
+        drawSelectRow(run, choice, start + i === run.active);
+    }
+}
+function moveSelect(run, delta) {
+    const rows = matchedRows(run.choices, run.filter);
+    if (rows.length > 0)
+        run.active = (run.active + delta + rows.length) % rows.length;
+    renderSelect(run);
+}
+function cleanupSelect(run) {
+    if (run.settled)
+        return;
+    run.settled = true;
+    run.stdin.removeListener("data", run.onData);
+    run.stdin.removeListener("end", run.onEnd);
+    run.stdin.removeListener("error", run.onEnd);
+    run.stdin.setRawMode(false);
+    run.stdin.pause();
+}
+function endSelect(run) {
+    cleanupSelect(run);
+    run.reject();
+}
+function handleSelectKey(run, chunk) {
+    // Whole-chunk matching: an arrow key is a three-byte escape sequence.
+    if (chunk.includes(ETX) || chunk.includes(EOT)) {
+        endSelect(run);
+        return;
+    }
+    if (chunk.includes(ARROW_UP)) {
+        moveSelect(run, -1);
+        return;
+    }
+    if (chunk.includes(ARROW_DOWN)) {
+        moveSelect(run, 1);
+        return;
+    }
+    if (chunk.includes(CR) || chunk.includes(LF)) {
+        const rows = matchedRows(run.choices, run.filter);
+        if (rows.length === 0)
+            return;
+        cleanupSelect(run);
+        // biome-ignore lint/style/noNonNullAssertion: active is held below rows.length by renderSelect and the guard above.
+        run.resolve(rows[run.active].id);
+        return;
+    }
+    run.filter = chunk.includes(BACKSPACE) ? run.filter.slice(0, -1) : run.filter + chunk;
+    run.active = 0;
+    renderSelect(run);
+}
 /**
  * Reads a choice with the arrow keys and returns the chosen option's id. The
- * option block is redrawn in place. Enter commits the highlighted row, so a
- * value that is not an option can never be returned.
+ * option block is redrawn in place, so a value that is not an option can never
+ * be returned. Typed characters narrow the block rather than answering it: a
+ * catalog-sized list is scrolled by filtering, not printed whole, and the redraw
+ * moves up only by the rows it drew — a block taller than the terminal cannot be
+ * repainted, because the cursor-up cannot cross the scrollback. Enter with no
+ * match commits nothing.
  */
 export function promptForSelect(message, choices, style = PLAIN_STYLE) {
     const stdin = stdinOf();
@@ -134,63 +219,25 @@ export function promptForSelect(message, choices, style = PLAIN_STYLE) {
         return Promise.reject(new PromptCancelledError());
     _terminalPromptDeps.write(`${style.accent("?")} ${message}\n`);
     return new Promise((resolve, reject) => {
-        let index = 0;
-        let settled = false;
-        let drawn = false;
-        const render = () => {
-            if (drawn)
-                _terminalPromptDeps.write(`\u001b[${choices.length}A`);
-            drawn = true;
-            for (const [i, choice] of choices.entries()) {
-                const active = i === index;
-                const marker = active ? style.accent(">") : " ";
-                const label = active ? style.accent(choice.label) : choice.label;
-                _terminalPromptDeps.write(`\r\u001b[2K${marker} ${label}\n`);
-            }
-        };
-        const cleanup = () => {
-            if (settled)
-                return;
-            settled = true;
-            stdin.removeListener("data", onData);
-            stdin.removeListener("end", onEnd);
-            stdin.removeListener("error", onEnd);
-            stdin.setRawMode(false);
-            stdin.pause();
-        };
-        const onEnd = () => {
-            cleanup();
-            reject(new PromptCancelledError());
-        };
-        const onData = (chunk) => {
-            // Whole-chunk matching: an arrow key is a three-byte escape sequence.
-            if (chunk.includes(ETX) || chunk.includes(EOT)) {
-                onEnd();
-                return;
-            }
-            if (chunk.includes(ARROW_UP)) {
-                index = (index - 1 + choices.length) % choices.length;
-                render();
-                return;
-            }
-            if (chunk.includes(ARROW_DOWN)) {
-                index = (index + 1) % choices.length;
-                render();
-                return;
-            }
-            if (chunk.includes(CR) || chunk.includes(LF)) {
-                const chosen = choices[index];
-                cleanup();
-                // biome-ignore lint/style/noNonNullAssertion: index is held in range by the modulo above.
-                resolve(chosen.id);
-            }
+        const run = {
+            choices,
+            style,
+            stdin,
+            resolve,
+            reject: () => reject(new PromptCancelledError()),
+            onData: (chunk) => handleSelectKey(run, chunk),
+            onEnd: () => endSelect(run),
+            filter: "",
+            active: 0,
+            drawn: 0,
+            settled: false,
         };
         stdin.setRawMode(true);
         stdin.resume();
         stdin.setEncoding("utf8");
-        stdin.on("data", onData);
-        stdin.once("end", onEnd);
-        stdin.once("error", onEnd);
-        render();
+        stdin.on("data", run.onData);
+        stdin.once("end", run.onEnd);
+        stdin.once("error", run.onEnd);
+        renderSelect(run);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax-agent",
-  "version": "0.85.1",
+  "version": "0.86.0",
   "description": "nax's native coding agent: session contract, native loop, tools, permissions, sandbox, command-safety.",
   "license": "MIT",
   "author": "William Khoo",
@@ -47,7 +47,7 @@
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "0.0.77",
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@nathapp/nax-ai": "0.85.1",
+    "@nathapp/nax-ai": "0.86.0",
     "zod": "^4.3.6"
   },
   "publishConfig": {