aiden-runtime 4.1.4 → 4.5.0

package/dist/cli/v4/updateBootPrompt.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/updateBootPrompt.ts — v4.5 update system.
+ *
+ * Boxed three-option prompt rendered after the boot card / status
+ * pills, before the bottomPromptHint (Q-U5(b) position). When an
+ * update is available AND not skipped, the user sees:
+ *
+ *   ┌─────────────────────────────────────────────────────────┐
+ *   │  ◆ Aiden 4.5.1 available (you're on 4.5.0)              │
+ *   │                                                         │
+ *   │  What's new: bug fix for IMAP reconnect on Windows      │
+ *   │                                                         │
+ *   │  Update now? (y/n/later)                                │
+ *   │    y       — update now, restart after                  │
+ *   │    n       — skip this version (don't ask again)        │
+ *   │    later   — remind me next session                     │
+ *   └─────────────────────────────────────────────────────────┘
+ *
+ * Behavior (Q-U2(a)):
+ *   - 5-second timeout defaults to 'later' (no state change)
+ *   - 'y' triggers `executeInstall` via the method-aware dispatch
+ *   - 'n' persists `skippedVersion = status.latest` to the cache
+ *   - 'later' is a no-op (re-prompt next session)
+ *
+ * Display sink: writes via the supplied `display`. Keypress capture
+ * uses raw stdin mode so the user can press a single key — no Enter
+ * needed for y/n. 'later' is the timeout default; an explicit 'l'
+ * keypress also maps to it.
+ *
+ * Designed to be skippable: if stdin isn't a TTY (CI / piped /
+ * non-interactive), short-circuits to 'later' immediately so boot
+ * doesn't hang.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBootUpdateBox = renderBootUpdateBox;
+exports.showBootUpdatePrompt = showBootUpdatePrompt;
+const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * Pure box renderer — public so tests can assert the rendered shape
+ * without driving stdin.
+ */
+function renderBootUpdateBox(status, method) {
+    const innerWidth = 60;
+    const pad = (s) => {
+        const visible = s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        const len = visible.length;
+        if (len >= innerWidth)
+            return s.slice(0, innerWidth);
+        return s + ' '.repeat(innerWidth - len);
+    };
+    const top = '┌' + '─'.repeat(innerWidth) + '┐';
+    const bottom = '└' + '─'.repeat(innerWidth) + '┘';
+    const blank = '│' + ' '.repeat(innerWidth) + '│';
+    const lines = [];
+    lines.push(top);
+    lines.push(blank);
+    lines.push('│' + pad(`  ◆ Aiden ${status.latest} available (you're on ${status.installed})`) + '│');
+    if (status.releaseNotes && status.releaseNotes.length > 0) {
+        lines.push(blank);
+        lines.push('│' + pad(`  What's new: ${status.releaseNotes}`) + '│');
+    }
+    lines.push(blank);
+    lines.push('│' + pad(`  Update now? (y/n/later)`) + '│');
+    lines.push('│' + pad(`    y       — update via ${method.method}`) + '│');
+    lines.push('│' + pad(`    n       — skip ${status.latest} (don't ask again)`) + '│');
+    lines.push('│' + pad(`    later   — remind me next session (default in 5s)`) + '│');
+    lines.push(blank);
+    lines.push(bottom);
+    return lines;
+}
+/**
+ * Show the prompt and resolve with the user's choice. Never throws
+ * — returns 'later' on any error / timeout / non-TTY.
+ */
+async function showBootUpdatePrompt(input) {
+    // Test seam — short-circuit before any I/O.
+    if (input._testChoice)
+        return input._testChoice;
+    const isTTY = input.isTTY ?? Boolean(input.stdin?.isTTY ?? process.stdin.isTTY);
+    // Non-interactive stdin → silently default to 'later'. Boot must
+    // not hang in CI / piped contexts.
+    if (!isTTY)
+        return 'later';
+    if (!input.status.updateAvailable || !input.status.latest)
+        return 'later';
+    if (input.status.skipped)
+        return 'later';
+    // Render the box.
+    for (const line of renderBootUpdateBox(input.status, input.method)) {
+        input.display.write(line + '\n');
+    }
+    const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const stdin = input.stdin ?? process.stdin;
+    return await captureSingleKey(stdin, timeoutMs);
+}
+/**
+ * Read ONE keypress from stdin in raw mode. Maps:
+ *   - 'y' / 'Y' → 'install'
+ *   - 'n' / 'N' → 'skip'
+ *   - 'l' / 'L' / Enter / any other key → 'later'
+ *   - Timeout                          → 'later'
+ *
+ * Restores stdin's prior pause/resume + rawMode state so the
+ * subsequent REPL prompt isn't broken.
+ */
+function captureSingleKey(stdin, timeoutMs) {
+    return new Promise((resolve) => {
+        let done = false;
+        const wasRaw = stdin.isRaw === true;
+        const wasPaused = stdin.isPaused();
+        const cleanup = () => {
+            if (done)
+                return;
+            done = true;
+            try {
+                stdin.removeListener('data', onData);
+            }
+            catch { /* noop */ }
+            try {
+                if (!wasRaw && stdin.setRawMode)
+                    stdin.setRawMode(false);
+            }
+            catch { /* noop */ }
+            if (wasPaused)
+                try {
+                    stdin.pause();
+                }
+                catch { /* noop */ }
+            clearTimeout(timer);
+        };
+        const onData = (chunk) => {
+            const raw = chunk.toString();
+            const ch = raw.length > 0 ? raw[0].toLowerCase() : '';
+            let choice;
+            if (ch === 'y')
+                choice = 'install';
+            else if (ch === 'n')
+                choice = 'skip';
+            else
+                choice = 'later';
+            cleanup();
+            resolve(choice);
+        };
+        try {
+            if (stdin.setRawMode && !wasRaw)
+                stdin.setRawMode(true);
+            if (wasPaused)
+                stdin.resume();
+            stdin.on('data', onData);
+        }
+        catch {
+            cleanup();
+            resolve('later');
+            return;
+        }
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve('later');
+        }, timeoutMs);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+    });
+}

package/dist/core/playwrightBridge.js

@@ -58,11 +58,14 @@ exports.pwClickFirstResult = pwClickFirstResult;
 exports.pwType = pwType;
 exports.pwScroll = pwScroll;
 exports.pwSnapshot = pwSnapshot;
+exports.pwSnapshotHash = pwSnapshotHash;
+exports.pwSnapshotTabs = pwSnapshotTabs;
 exports.pwGetUrl = pwGetUrl;
 exports.pwClose = pwClose;
 exports.getActiveBrowserPage = getActiveBrowserPage;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
 const paths_1 = require("./paths");
 // ── Lazy-import Playwright so the server boots even if playwright
 //    is not installed (tools will return a clear error message).
@@ -410,6 +413,132 @@ async function pwSnapshot() {
         return { ok: false, error: e.message };
     }
 }
+/**
+ * v4.3 Phase 1 — structured page-state snapshot used by the BrowserState
+ * observer. Captures URL + title + body-text hash + recursive iframe-tree
+ * hash in a single in-page evaluate. Truncates body innerText to 5 000
+ * chars before hashing so cost stays bounded for large pages.
+ *
+ * Cross-origin iframe srcs are surfaced (URL is visible); attempting to
+ * read `iframe.contentDocument` on a cross-origin frame throws — the
+ * recursive walker catches and skips, recording only the iframe's src.
+ *
+ * Returns `ok: false` when the browser is closed or evaluate fails.
+ * Caller (BrowserState.captureState) treats `ok: false` as "snapshot
+ * unavailable, embed no sidecar this call".
+ */
+async function pwSnapshotHash() {
+    try {
+        const page = await ensurePage();
+        const url = page.url();
+        const title = await page.title();
+        // eslint-disable-next-line no-undef
+        const data = await page.evaluate(() => {
+            const doc = globalThis.document;
+            const text = (doc?.body?.innerText ?? '');
+            // Recursive iframe URL walk. Cross-origin iframes throw on
+            // contentDocument access — catch and record just the src.
+            const urls = [];
+            function walk(d) {
+                try {
+                    const iframes = Array.from(d.querySelectorAll('iframe'));
+                    for (const f of iframes) {
+                        urls.push(String(f.src ?? ''));
+                        try {
+                            if (f.contentDocument)
+                                walk(f.contentDocument);
+                        }
+                        catch { /* cross-origin */ }
+                    }
+                }
+                catch { /* defensive */ }
+            }
+            walk(doc);
+            return { text, frame_urls: urls.join('|') };
+        });
+        const dom_text_hash = crypto_1.default.createHash('sha256').update(data.text.slice(0, 5000)).digest('hex');
+        const frame_tree_hash = crypto_1.default.createHash('sha256').update(data.frame_urls).digest('hex');
+        return { ok: true, url, title, dom_text_hash, frame_tree_hash };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+// ── v4.3 Phase 4 — multi-tab snapshot ─────────────────────────────────────
+//
+// Persistent context can hold many pages (target=_blank, window.open,
+// CDP popups). Aiden's tools still target `_activePage` only — Phase 4
+// is DATA-ONLY: it records what tabs exist, who opened whom, and which
+// is the active one, so v4.4+ cross-tab orchestration has a foundation.
+//
+// `_tabIdMap` is a WeakMap that assigns each observed Page a stable
+// `tab_id` (`tab-1`, `tab-2`, ...). When a Page closes, Playwright drops
+// its reference and the WeakMap entry GCs naturally — no manual cleanup.
+const _tabIdMap = new WeakMap();
+let _nextTabIdCounter = 0;
+function getOrAssignTabId(page) {
+    let id = _tabIdMap.get(page);
+    if (!id) {
+        _nextTabIdCounter += 1;
+        id = `tab-${_nextTabIdCounter}`;
+        _tabIdMap.set(page, id);
+    }
+    return id;
+}
+/**
+ * v4.3 Phase 4 — enumerate all pages in the persistent context and
+ * return their wire-data form. Stable `tab_id` per Page via the
+ * `_tabIdMap` WeakMap. The opener Page is looked up the same way, so
+ * `opener_id` is stable across reconciliations as long as the parent
+ * still exists.
+ *
+ * Cheap — `context.pages()` is in-process; the per-page work is one
+ * `url()` getter and one async `title()` call. Total cost scales
+ * linearly with the number of tabs; for typical sessions (1-5 tabs)
+ * it's well under 50ms.
+ *
+ * Returns `ok: false` when the browser is closed. Caller (BrowserState
+ * .reconcileTabs) treats `ok: false` as "no reconciliation this cycle".
+ */
+async function pwSnapshotTabs() {
+    try {
+        const ctx = await ensureContext();
+        const pages = ctx.pages();
+        const tabs = [];
+        for (const p of pages) {
+            // Skip pages already closed mid-walk (rare race).
+            if (typeof p.isClosed === 'function' && p.isClosed())
+                continue;
+            const tab_id = getOrAssignTabId(p);
+            const url = (typeof p.url === 'function') ? p.url() : '';
+            // title() can throw if the page navigated mid-walk; default to empty.
+            let title = '';
+            try {
+                title = await p.title();
+            }
+            catch { /* defensive */ }
+            // opener() returns the parent Page (or null). Same WeakMap lookup.
+            let opener_id = null;
+            try {
+                const opener = typeof p.opener === 'function' ? await p.opener() : null;
+                if (opener)
+                    opener_id = _tabIdMap.get(opener) ?? null;
+            }
+            catch { /* defensive */ }
+            tabs.push({
+                tab_id,
+                url,
+                title,
+                is_active: p === _activePage,
+                opener_id,
+            });
+        }
+        return { ok: true, tabs };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
 /** Return the URL currently loaded in the active browser page. */
 async function pwGetUrl() {
     try {

package/dist/core/toolRegistry.js

@@ -1388,7 +1388,13 @@ exports.TOOLS = {
             return { success: false, output: '', error: `No research results for: ${topic}` };
         }
         const combined = results.join('\n\n');
-        console.log(`[deep_research] Complete: ${combined.length} chars across ${results.length} passes`);
+        // v4.1.5 Issue O — gated behind AIDEN_DEBUG_WEB to match the
+        // webSearch.ts debug-helper convention. Default off; power users
+        // export the env var to see the research chain.
+        if (process.env.AIDEN_DEBUG_WEB === '1') {
+            // eslint-disable-next-line no-console
+            console.log(`[deep_research] Complete: ${combined.length} chars across ${results.length} passes`);
+        }
         return { success: true, output: combined.slice(0, 15000) };
     },
     // Activate a specialist agent persona — actual synthesis happens in respond phase