aiden-runtime 4.7.0 → 4.8.1

package/dist/cli/v4/onboarding/disclaimer.js

@@ -60,9 +60,24 @@ const readline = __importStar(require("node:readline"));
 const banner_1 = require("../../../core/v4/ui/banner");
 const theme_1 = require("../../../core/v4/ui/theme");
 const version_1 = require("../../../core/version");
-const DISCLAIMER_PARA = 'Aiden is a semi-autonomous AI agent that can touch your files, ' +
-    'browser, and shell. Open source — read the code if you want. ' +
-    'Started as a hobby project, built solo, still rough in spots.';
+// v4.8.0 Slice 10c — replaced the single-paragraph prose with two
+// scannable bullet lists (capability + acknowledgments). Legal terms
+// surfaced as a checklist instead of buried inside prose.
+const DISCLAIMER_HEAD = 'Aiden is an autonomous AI engine that runs on your machine. Aiden can:';
+const CAPABILITY_BULLETS = [
+    'Read, write, and modify files on your computer',
+    'Execute shell commands and run code',
+    'Browse the web and interact with online services',
+    'Connect to AI providers using YOUR API keys (BYOK)',
+    'Generate and execute new skills based on your prompts',
+];
+const ACK_HEAD = 'By continuing, you acknowledge:';
+const ACK_BULLETS = [
+    'Aiden operates on your behalf with full local-system access',
+    'You are responsible for outcomes of commands you approve',
+    'Open source under AGPL-3.0 — read the code at github.com/taracodlabs/aiden',
+    'This is beta software, built solo, still rough in spots',
+];
 /**
  * Word-wrap `text` to `width` columns. Preserves single spaces; does
  * not handle ANSI codes (callers pass plain text here).
@@ -97,18 +112,35 @@ function clearScreen(out) {
     out.write('\x1b[2J\x1b[H');
 }
 /**
- * Render the disclaimer body — banner + separator + wrapped paragraph.
- * Pure renderer; caller owns the write.
+ * Render the disclaimer body — v4.8.0 Slice 10c: banner + framed-panel
+ * capability list + acknowledgments. Orange `▎` bar on every line of
+ * the panel matches the rest of v4.8.0 chrome. `▸` bullets keep
+ * capability/ack items scannable rather than buried in prose.
  */
 function renderDisclaimerBody(version) {
     const w = (0, theme_1.termWidth)();
+    const innerW = Math.min(w - 4, 70);
     const body = [];
     body.push((0, banner_1.renderBanner)({ version }));
-    body.push('  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n');
-    body.push('\n');
-    const indent = '  ';
-    for (const line of wrap(DISCLAIMER_PARA, Math.min(w - 4, 70))) {
-        body.push(indent + theme_1.c.text(line) + '\n');
+    // Slice 10c framed-panel chrome. Orange bar at col 2; content + 2
+    // inner spaces; muted `─` divider between sections.
+    // v4.8.0 Slice 11c — `▎` swapped for `│` (U+2502); same swap as
+    // glyphs.panel.bar in the design tokens.
+    const bar = theme_1.c.primary('│');
+    const divider = theme_1.c.muted('─'.repeat(innerW - 2));
+    const line = (s) => `  ${bar}  ${s}\n`;
+    body.push(line(theme_1.c.text(DISCLAIMER_HEAD)));
+    body.push(line(''));
+    for (const item of CAPABILITY_BULLETS) {
+        body.push(line(theme_1.c.muted('▸ ') + theme_1.c.text(item)));
+    }
+    body.push(line(''));
+    body.push(line(divider));
+    body.push(line(''));
+    body.push(line(theme_1.c.text(ACK_HEAD)));
+    body.push(line(''));
+    for (const item of ACK_BULLETS) {
+        body.push(line(theme_1.c.muted('▸ ') + theme_1.c.text(item)));
     }
     body.push('\n');
     return body.join('');

package/dist/cli/v4/onboarding/loading.js

@@ -86,13 +86,29 @@ async function runLoadingSequence(steps, opts = {}) {
         return { ok: results.every((r) => r.ok), steps: results };
     }
     out.write('\n  ' + theme_1.c.text(heading) + '\n\n');
+    // v4.8.0 Slice 10c — progress bar above the step rows. 10 cells
+    // (●/○) split proportionally across the steps; each completed step
+    // fills floor(10 * (i+1) / N) cells. Uses the same hex-dot glyphs
+    // as the status footer's context bar for visual consistency.
+    const BAR_CELLS = 10;
+    const buildBar = (completed) => {
+        const filled = Math.min(BAR_CELLS, Math.floor((BAR_CELLS * completed) / steps.length));
+        const pct = Math.round((completed / steps.length) * 100);
+        const fillSeg = theme_1.c.primary('●'.repeat(filled));
+        const emptySeg = theme_1.c.muted('○'.repeat(BAR_CELLS - filled));
+        const label = completed < steps.length
+            ? theme_1.c.muted(steps[completed].label + '...')
+            : theme_1.c.muted('done');
+        return `  ${fillSeg}${emptySeg}  ${theme_1.c.text(String(pct).padStart(3) + '%')}   ${label}`;
+    };
+    out.write(buildBar(0) + '\n\n');
     // Pre-paint placeholder rows so the spinner overwrites in place.
     for (const step of steps) {
         const line = '  ' + theme_1.c.muted('·') + ' ' + rpad(step.label, labelCol) +
             ' ' + theme_1.c.muted(lpad('—', statusCol));
         out.write(line + '\n');
     }
-    // Walk back up to the top of the block.
+    // Walk back up to the top of the step block.
     out.write(`\x1b[${steps.length}A`);
     for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
@@ -127,6 +143,13 @@ async function runLoadingSequence(steps, opts = {}) {
             ' ' + lpad(statusText, statusCol) + '  ' + timing;
         out.write('\x1b[2K\r' + row + '\n');
         results.push({ label: step.label, ok, status, ms });
+        // v4.8.0 Slice 10c — repaint the progress bar above the step
+        // block after each step completes. Cursor is currently on the
+        // line below the just-completed step; walk up to the bar line
+        // (steps.length - i - 1 rows of remaining steps + 1 blank line
+        // separator + the bar itself), rewrite, then walk back down.
+        const upCount = (steps.length - i - 1) + 2;
+        out.write(`\x1b[${upCount}A\x1b[2K\r${buildBar(i + 1)}\x1b[${upCount}B\r`);
     }
     out.write('\n  ' + (0, theme_1.separator)(Math.min(w - 4, 64)) + '\n');
     return { ok: results.every((r) => r.ok), steps: results };

package/dist/cli/v4/onboarding/successScreen.js

@@ -47,22 +47,31 @@ function renderSuccessScreen(opts = {}) {
         out.write('setup-complete\n');
         return;
     }
+    // v4.8.0 Slice 10b — Aiden-native framed panel chrome. Each row
+    // carries the orange bar; content (title + examples + closing
+    // hint) preserved verbatim so content-level test assertions hold.
+    // v4.8.0 Slice 11c — `▎` swapped for `│` (U+2502); same swap as
+    // glyphs.panel.bar in the design tokens.
     const w = (0, theme_1.termWidth)();
     const sepW = Math.min(w - 4, 64);
     const narrow = w < 60;
-    out.write('\n  ' + (0, theme_1.separator)(sepW) + '\n');
-    out.write('\n  ' + (0, theme_1.bold)(theme_1.c.primary('All set!')) + '\n');
-    out.write('\n  ' + theme_1.c.text('Aiden is ready. Try these to start:') + '\n');
+    const bar = theme_1.c.primary('│');
+    const divider = theme_1.c.muted('─'.repeat(sepW - 2));
+    const line = (s) => `  ${bar}  ${s}`;
     out.write('\n');
+    out.write(line((0, theme_1.bold)(theme_1.c.primary('All set!'))) + '\n');
+    out.write(line(divider) + '\n');
+    out.write(line(theme_1.c.text('Aiden is ready. Try these to start:')) + '\n');
+    out.write(line('') + '\n');
     if (narrow) {
-        // Compact: a single suggestion line + the muted hello fallback.
-        out.write('  ' + theme_1.c.muted('▸ ') + theme_1.c.accent(examples[0]) + '\n');
+        out.write(line(theme_1.c.muted('▸ ') + theme_1.c.accent(examples[0])) + '\n');
     }
     else {
         for (const ex of examples) {
-            out.write('  ' + theme_1.c.muted('▸ ') + theme_1.c.accent(ex) + '\n');
+            out.write(line(theme_1.c.muted('▸ ') + theme_1.c.accent(ex)) + '\n');
         }
     }
-    out.write('\n  ' + theme_1.c.muted('Or just say hi.') + '\n');
-    out.write('\n  ' + (0, theme_1.separator)(sepW) + '\n\n');
+    out.write(line('') + '\n');
+    out.write(line(theme_1.c.muted('Or just say hi.')) + '\n');
+    out.write('\n');
 }

package/dist/cli/v4/pasteIntercept.js

@@ -6,19 +6,52 @@
  * Aiden — local-first agent.
  */
 /**
- * cli/v4/pasteIntercept.ts — Tier-3.1a (v4.1-tier3.1a)
+ * cli/v4/pasteIntercept.ts — stdin pre-tap for bracketed paste.
  *
- * Stdin pre-tap that handles bracketed paste sequences before
- * @inquirer/prompts sees them. Modern inquirer treats any internal
- * `\n` as Enter and resolves early, so a multi-line paste auto-
- * submits before the user has a chance to review. This module
- * intercepts paste boundaries (CSI 2004), captures the content,
- * persists it via the existing pasteCompression manifest, and
- * substitutes a `[paste #<id>: <N> lines, <KB>]` label on stdin.
+ * Modern @inquirer/prompts treats any embedded `\n` as Enter and
+ * resolves early, so a multi-line paste would auto-submit one line
+ * at a time. This module intercepts paste payloads BEFORE inquirer
+ * sees them, persists them to a manifest, and substitutes a
+ * `[paste #<id>: <N> lines, <bytes>]` label on stdin. The user sees
+ * the label inside inquirer's input buffer, edits it like any other
+ * text, then presses Enter to submit; `chatSession.readUserInput`
+ * swaps the label back for the original via `getPasteOriginal(id)`
+ * before handing to the agent.
  *
- * The user sees the label in inquirer's input buffer, presses Enter
- * to submit, and chatSession.readUserInput swaps the label for the
- * original via getPasteOriginal(id) before handing to the agent.
+ * v4.8.1 Slice 2 hotfix #6 — robustness rebuild for terminal-
+ * environment diversity:
+ *
+ *   • State machine survives reads split across chunk boundaries.
+ *     The begin or end marker can arrive partially in one chunk
+ *     and be completed by the next; the parser keeps state in `buf`
+ *     until a full marker is observed.
+ *
+ *   • 800ms watchdog flushes a stuck `in_marker_paste` state if
+ *     the terminal never delivers PASTE_END (mosh/tmux/SSH paths
+ *     have all been observed to drop end markers under load).
+ *
+ *   • Degraded marker forms get normalised to canonical at the
+ *     intercept boundary. Visible-escape variants (`^[[200~`) are
+ *     the common case from terminals that escape control sequences
+ *     for display.
+ *
+ *   • CRLF/CR → LF normalisation is applied universally on every
+ *     incoming chunk, not just inside marker payloads. Some
+ *     clipboard payloads carry CR-only line endings.
+ *
+ *   • 30ms timing accumulation catches line-by-line paste delivery
+ *     — the failure mode that surfaced after hotfix #5. When a
+ *     terminal delivers a paste as N small `"<line>\n"` chunks
+ *     instead of one bulk chunk, each chunk has a single trailing
+ *     `\n` and would otherwise pass through as an Enter keystroke.
+ *     The accumulator holds candidate chunks (`length > 1` so the
+ *     bare Enter keystroke `"\n"` is never held) for a 30ms window;
+ *     if another candidate arrives, both are accumulated as a
+ *     multi-line paste and substituted with the placeholder before
+ *     any `\n` reaches inquirer. If no follow-up arrives within the
+ *     window, the held chunk is emitted unchanged (normal Enter).
+ *     30ms is imperceptible to humans and well below sustained
+ *     keystroke timing.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -33,7 +66,16 @@ const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("../../core/v4/paths");
 const PASTE_BEGIN = '\x1b[200~';
 const PASTE_END = '\x1b[201~';
-/** id → original text (in-memory swap table). */
+/**
+ * Degraded marker patterns observed in the wild. Each is rewritten
+ * to canonical at the normalisation boundary so the parser only
+ * needs to know about one form.
+ */
+const DEGRADED_BEGIN = /\^\[\[200~/g;
+const DEGRADED_END = /\^\[\[201~/g;
+const ACCUMULATION_MS = 30;
+const WATCHDOG_MS = 800;
+/** id → original text (in-memory swap table). Disk has /pastes/paste_<id>.txt as source of truth for /show. */
 const originals = new Map();
 function pastesDir() {
     return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, 'pastes');
@@ -74,18 +116,17 @@ function compressSync(text) {
 }
 /**
  * Look up the original text for a paste id. Returns undefined if the
- * id was never seen by this process (e.g. the user typed a label by
- * hand). Disk is the source of truth for /show <id>; this map is the
- * fast path for the in-flight prompt swap.
+ * id was never seen by this process. Disk (/pastes/paste_<id>.txt)
+ * is the source of truth for /show <id>; this map is the fast path
+ * for the in-flight prompt swap.
  */
 function getPasteOriginal(id) {
     return originals.get(id);
 }
 /**
  * Replace `[paste #N: …]` patterns in `input` with the corresponding
- * original text from the in-process map. Patterns whose id we don't
- * know are left intact (might be user-typed). Returns the swapped
- * string.
+ * original text. Patterns whose id we don't know are left intact
+ * (might be user-typed by hand).
  */
 function expandPasteLabels(input) {
     return input.replace(/\[paste #(\d+):[^\]]*\]/g, (m, id) => {
@@ -93,6 +134,38 @@ function expandPasteLabels(input) {
         return orig !== undefined ? orig : m;
     });
 }
+/**
+ * Universal normalisation applied at the intercept boundary:
+ * CRLF + bare CR → LF, then degraded marker variants → canonical.
+ */
+function normalize(text) {
+    let t = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    t = t.replace(DEGRADED_BEGIN, PASTE_BEGIN);
+    t = t.replace(DEGRADED_END, PASTE_END);
+    return t;
+}
+/**
+ * Decide whether `payload` should emit inline (small single-line) or
+ * be funnelled through the disk-backed placeholder system. Same
+ * thresholds for marker-wrapped and timing-accumulated paths so the
+ * user sees identical chrome regardless of how the paste arrived.
+ */
+function payloadToEmission(payload) {
+    const trimmed = payload.replace(/\n+$/, '');
+    if (!trimmed.includes('\n') && trimmed.length <= 500) {
+        return trimmed;
+    }
+    try {
+        const { id, label } = compressSync(trimmed);
+        originals.set(id, trimmed);
+        return label;
+    }
+    catch {
+        // Disk failure: collapse newlines so the auto-submit we're
+        // preventing doesn't fire downstream.
+        return trimmed.replace(/\n/g, ' ');
+    }
+}
 let installed = null;
 /**
  * Install the stdin pre-tap. Wraps `process.stdin.emit('data', …)`
@@ -103,72 +176,140 @@ let installed = null;
  * MCP serve mode: never call this — `aiden mcp serve` doesn't run
  * the REPL.
  */
-function installPasteInterceptor(stdin) {
+function installPasteInterceptor(stdin, opts = {}) {
     if (installed)
         return installed.restore;
+    const accumulationMs = opts.accumulationMs ?? ACCUMULATION_MS;
+    const watchdogMs = opts.watchdogMs ?? WATCHDOG_MS;
     const origEmit = stdin.emit.bind(stdin);
-    const state = { inPaste: false, buf: '' };
-    function processChunk(text) {
-        let out = '';
+    // State machine —
+    //   normal           : default; chunks pass through or accumulate
+    //   in_marker_paste  : between PASTE_BEGIN and PASTE_END; buf accumulates payload
+    let mode = 'normal';
+    let buf = '';
+    let markerTimer = null;
+    let pendingChunk = null;
+    let pendingTimer = null;
+    function emitDownstream(text) {
+        if (text.length === 0)
+            return;
+        origEmit('data', Buffer.from(text, 'utf8'));
+    }
+    function clearMarkerWatchdog() {
+        if (markerTimer) {
+            clearTimeout(markerTimer);
+            markerTimer = null;
+        }
+    }
+    function armMarkerWatchdog() {
+        clearMarkerWatchdog();
+        markerTimer = setTimeout(() => {
+            // PASTE_END never arrived. Flush whatever we have and reset.
+            const payload = buf;
+            buf = '';
+            mode = 'normal';
+            markerTimer = null;
+            emitDownstream(payloadToEmission(payload));
+        }, watchdogMs);
+    }
+    function clearPending() {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+        pendingChunk = null;
+    }
+    function flushPendingAsIs() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        // Pending was a normal Enter — emit as-is, don't placeholder.
+        emitDownstream(chunk);
+    }
+    function flushPendingAsPaste() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        emitDownstream(payloadToEmission(chunk));
+    }
+    function processNormalised(text) {
         let cursor = 0;
         while (cursor < text.length) {
-            if (state.inPaste) {
+            if (mode === 'in_marker_paste') {
                 const endIdx = text.indexOf(PASTE_END, cursor);
                 if (endIdx === -1) {
-                    state.buf += text.slice(cursor);
+                    buf += text.slice(cursor);
                     cursor = text.length;
+                    // Watchdog stays armed — extending the buf without an end
+                    // marker doesn't restart the clock; we still want to flush
+                    // if the entire turn never produces PASTE_END.
                 }
                 else {
-                    state.buf += text.slice(cursor, endIdx);
+                    buf += text.slice(cursor, endIdx);
                     cursor = endIdx + PASTE_END.length;
-                    // Tier-3.1c: terminals (and some clipboard payloads) emit a
-                    // trailing CR/LF immediately after PASTE_END. Without this
-                    // swallow the bytes pass through to readline, where they
-                    // become an Enter event and auto-submit the prompt before
-                    // the user has reviewed the paste. Eat at most one CR + one
-                    // LF (in either order) right after PASTE_END.
-                    if (text[cursor] === '\r')
-                        cursor += 1;
+                    // Swallow a trailing newline that some terminals emit
+                    // immediately after PASTE_END.
                     if (text[cursor] === '\n')
                         cursor += 1;
-                    state.inPaste = false;
-                    const original = state.buf.replace(/\r\n/g, '\n');
-                    state.buf = '';
-                    // Strip a single trailing newline (Enter at end of paste).
-                    const trimmed = original.replace(/\n+$/, '');
-                    if (!trimmed.includes('\n') && trimmed.length <= 500) {
-                        // Single-line, small — emit as-is so user can edit.
-                        out += trimmed;
-                    }
-                    else {
-                        // Multi-line or large — disk-back + emit label.
-                        try {
-                            const { id, label } = compressSync(trimmed);
-                            originals.set(id, trimmed);
-                            out += label;
-                        }
-                        catch {
-                            // Disk failure: fall back to a single-space substitute
-                            // so internal newlines don't trigger auto-submit.
-                            out += trimmed.replace(/\n/g, ' ');
-                        }
-                    }
+                    mode = 'normal';
+                    clearMarkerWatchdog();
+                    const payload = buf;
+                    buf = '';
+                    emitDownstream(payloadToEmission(payload));
                 }
+                continue;
             }
-            else {
-                const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
-                if (beginIdx === -1) {
-                    out += text.slice(cursor);
-                    cursor = text.length;
+            // mode === 'normal'
+            const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
+            if (beginIdx !== -1) {
+                // Pre-marker content: flush any pending and emit inline so
+                // it lands in inquirer's buffer ahead of the placeholder
+                // (preserves typed prefix when the user pastes after typing).
+                flushPendingAsIs();
+                if (beginIdx > cursor)
+                    emitDownstream(text.slice(cursor, beginIdx));
+                cursor = beginIdx + PASTE_BEGIN.length;
+                mode = 'in_marker_paste';
+                armMarkerWatchdog();
+                continue;
+            }
+            // No marker in the remainder.
+            const remainder = text.slice(cursor);
+            cursor = text.length;
+            const nlCount = (remainder.match(/\n/g) ?? []).length;
+            const hasInternalNl = nlCount > 1 || (nlCount === 1 && !remainder.endsWith('\n'));
+            if (hasInternalNl) {
+                // Single bulk chunk with internal newlines — instant
+                // placeholder. Flush pending first so any prior single-line
+                // candidate isn't lost.
+                flushPendingAsIs();
+                emitDownstream(payloadToEmission(remainder));
+                continue;
+            }
+            // Candidate paste-line: non-empty content ending in `\n` with
+            // length > 1 (excludes bare Enter keystroke `"\n"`).
+            const isCandidate = remainder.endsWith('\n') && remainder.length > 1;
+            if (isCandidate) {
+                if (pendingChunk !== null) {
+                    // Already pending — append, restart the window.
+                    pendingChunk += remainder;
+                    if (pendingTimer)
+                        clearTimeout(pendingTimer);
+                    pendingTimer = setTimeout(flushPendingAsPaste, accumulationMs);
                 }
                 else {
-                    out += text.slice(cursor, beginIdx);
-                    cursor = beginIdx + PASTE_BEGIN.length;
-                    state.inPaste = true;
+                    pendingChunk = remainder;
+                    pendingTimer = setTimeout(flushPendingAsIs, accumulationMs);
                 }
+                continue;
             }
+            // Non-candidate (bare Enter, or non-`\n`-terminated keystroke).
+            // Flush pending first since this chunk closes the window.
+            flushPendingAsIs();
+            emitDownstream(remainder);
         }
-        return out;
     }
     const wrappedEmit = function (event, ...args) {
         if (event !== 'data')
@@ -176,19 +317,22 @@ function installPasteInterceptor(stdin) {
         const chunk = args[0];
         if (chunk == null)
             return origEmit(event, ...args);
-        const text = Buffer.isBuffer(chunk)
+        const raw = Buffer.isBuffer(chunk)
             ? chunk.toString('utf8')
             : (typeof chunk === 'string' ? chunk : String(chunk));
-        const processed = processChunk(text);
-        if (processed.length === 0)
-            return true; // suppress entirely
-        const nextArgs = [Buffer.from(processed, 'utf8'), ...args.slice(1)];
-        return origEmit(event, ...nextArgs);
+        const normalised = normalize(raw);
+        processNormalised(normalised);
+        // We always claim to have handled the emit. Downstream listeners
+        // fire from `emitDownstream` immediately on the same tick OR
+        // from a deferred timer in the accumulation case.
+        return true;
     };
     stdin.emit = wrappedEmit;
     const restore = () => {
         if (!installed)
             return;
+        clearPending();
+        clearMarkerWatchdog();
         stdin.emit = origEmit;
         installed = null;
     };