becki 0.5.0

package/dist/menu.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * menu.tsx — top-level admin TUI router.
+ *
+ * Repurposed from launcher (splash → prompt → handoff) into Becki Core's
+ * cross-platform Settings panel. Same React + Ink stack; entirely different
+ * purpose. See [[becki-shell-repurposed-as-admin-tui]] in Becki.
+ *
+ * Navigation:
+ *   ↑/↓ or j/k    move
+ *   1-9, 0        jump to item by number
+ *   enter / →     open
+ *   esc / ←       back to menu
+ *   q             quit (only on the menu)
+ */
+import { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { theme } from './theme.js';
+import { StatusScreen } from './screens/status.js';
+import { AccountScreen } from './screens/account.js';
+import { SubscriptionScreen } from './screens/subscription.js';
+import { WatchFoldersScreen } from './screens/watch-folders.js';
+import { GitScreen } from './screens/git.js';
+import { BackfillsScreen } from './screens/backfills.js';
+import { InstallTokenScreen } from './screens/install-token.js';
+import { VaultScreen } from './screens/vault.js';
+import { LogsScreen } from './screens/logs.js';
+// Quit lives at the end as a discoverable menu item — `q` keystroke still
+// works as the fast-path, but the visible row tells new users where the exit
+// is so the TUI doesn't feel like a trap.
+const ITEMS = [
+    { id: 'status', label: 'Status', hint: 'daemon · last digest · vault count · token usage' },
+    { id: 'account', label: 'Account', hint: 'email · sign-out · open /account' },
+    { id: 'subscription', label: 'Subscription', hint: 'plan · renews · billing portal' },
+    { id: 'watch-folders', label: 'Watch folders', hint: 'list · add · remove · pause' },
+    { id: 'git', label: 'Git', hint: 'GitHub / GitLab / Bitbucket tokens' },
+    { id: 'backfills', label: 'Backfills', hint: 'AI sessions · git history · re-extract' },
+    { id: 'install-token', label: 'Install token', hint: 'show · regenerate · copy' },
+    { id: 'vault', label: 'Vault', hint: 'size · export · purge' },
+    { id: 'logs', label: 'Logs', hint: 'tail recent · open log dir' },
+    { id: 'quit', label: 'Quit', hint: 'exit becki (or press q anywhere on the menu)' },
+];
+export function MenuApp() {
+    const { exit } = useApp();
+    const [current, setCurrent] = useState('menu');
+    const [cursor, setCursor] = useState(0);
+    useInput((input, key) => {
+        if (current !== 'menu')
+            return; // screen owns its own input
+        if (key.upArrow || input === 'k') {
+            setCursor((c) => (c - 1 + ITEMS.length) % ITEMS.length);
+        }
+        else if (key.downArrow || input === 'j') {
+            setCursor((c) => (c + 1) % ITEMS.length);
+        }
+        else if (key.return || key.rightArrow) {
+            const next = ITEMS[cursor].id;
+            if (next === 'quit')
+                exit();
+            else
+                setCurrent(next);
+        }
+        else if (input === 'q' || (input === 'c' && key.ctrl)) {
+            exit();
+        }
+        else if (/^[1-9]$/.test(input)) {
+            const i = Number(input) - 1;
+            if (i < ITEMS.length) {
+                const next = ITEMS[i].id;
+                setCursor(i);
+                if (next === 'quit')
+                    exit();
+                else
+                    setCurrent(next);
+            }
+        }
+        else if (input === '0' && ITEMS.length >= 10) {
+            setCursor(9);
+            const next = ITEMS[9].id;
+            if (next === 'quit')
+                exit();
+            else
+                setCurrent(next);
+        }
+    });
+    if (current !== 'menu') {
+        const onBack = () => setCurrent('menu');
+        switch (current) {
+            case 'status': return _jsx(StatusScreen, { onBack: onBack });
+            case 'account': return _jsx(AccountScreen, { onBack: onBack });
+            case 'subscription': return _jsx(SubscriptionScreen, { onBack: onBack });
+            case 'watch-folders': return _jsx(WatchFoldersScreen, { onBack: onBack });
+            case 'git': return _jsx(GitScreen, { onBack: onBack });
+            case 'backfills': return _jsx(BackfillsScreen, { onBack: onBack });
+            case 'install-token': return _jsx(InstallTokenScreen, { onBack: onBack });
+            case 'vault': return _jsx(VaultScreen, { onBack: onBack });
+            case 'logs': return _jsx(LogsScreen, { onBack: onBack });
+            case 'quit':
+                exit();
+                return _jsx(Box, {});
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: theme.gold, bold: true, children: "\u25C6 BECKI " }), _jsx(Text, { color: theme.gray, children: "local admin \u00B7 v0.5" })] }), ITEMS.map((item, i) => {
+                const selected = i === cursor;
+                const num = ((i + 1) % 10).toString();
+                return (_jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: selected ? theme.gold : theme.gray, children: selected ? '▸ ' : '  ' }) }), _jsx(Box, { width: 3, children: _jsx(Text, { color: theme.gray, children: num }) }), _jsx(Box, { width: 18, children: _jsx(Text, { color: selected ? theme.gold : theme.text, bold: selected, children: item.label }) }), _jsx(Text, { color: theme.gray, children: item.hint })] }, item.id));
+            }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, dimColor: true, children: "\u2191/\u2193 pick \u00B7 1-9 jump \u00B7 enter open \u00B7 q quit" }) })] }));
+}

package/dist/prompt.js

@@ -0,0 +1,121 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * prompt.tsx — the "what are you working on today?" input + the App that ties
+ * splash → prompt → (loops manager) → launch banner together.
+ *
+ * The App is the single Ink tree bin/becki.js renders. It calls `onComplete`
+ * with the typed focus (or null if skipped) once the user commits, then shows
+ * the launch banner briefly before Ink unmounts and the handoff runs.
+ *
+ * A focus can be entered three ways: type it freely, press a number (1-9) to
+ * jump-select an open thread, or arrow up/down then Enter. Ctrl+L opens the
+ * interactive open-threads manager (a detour — quitting it returns here).
+ *
+ * The input is hand-rolled (not ink-text-input) because digits are reserved
+ * for jump-select and Ctrl+L for the loops manager — a text widget would
+ * swallow both as literal input.
+ */
+import React, { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { theme } from './theme.js';
+import { Splash } from './splash.js';
+import { LoopsApp } from './loops.js';
+import { resolveAuth } from './client.js';
+/** The "what are you working on?" line — free text, number jump, or arrows. */
+function FocusPrompt({ threads, highlightIndex, setHighlightIndex, onOpenLoops, onSubmit, }) {
+    const [value, setValue] = useState('');
+    useInput((input, key) => {
+        // --- Ctrl+L → loops manager -----------------------------------------
+        if (key.ctrl && input === 'l') {
+            onOpenLoops?.();
+            return;
+        }
+        // --- Arrow navigation through the open-threads list -----------------
+        // Stepping off the top or bottom clears the selection (back to free text).
+        if (key.upArrow) {
+            const n = threads.length;
+            if (n === 0)
+                return;
+            setHighlightIndex((h) => (h === null ? n - 1 : h === 0 ? null : h - 1));
+            return;
+        }
+        if (key.downArrow) {
+            const n = threads.length;
+            if (n === 0)
+                return;
+            setHighlightIndex((h) => (h === null ? 0 : h === n - 1 ? null : h + 1));
+            return;
+        }
+        // --- Commit ----------------------------------------------------------
+        if (key.return) {
+            if (highlightIndex !== null && value.trim() === '') {
+                onSubmit(threads[highlightIndex].title);
+            }
+            else {
+                onSubmit(value.trim() === '' ? null : value.trim());
+            }
+            return;
+        }
+        // --- Editing ---------------------------------------------------------
+        if (key.backspace || key.delete) {
+            setValue((v) => v.slice(0, -1));
+            return;
+        }
+        // A digit as the FIRST keystroke jumps the highlight to that thread.
+        // Once free text exists, digits fall through and append as normal text.
+        if (value === '' && /^[1-9]$/.test(input)) {
+            const idx = Number(input) - 1;
+            if (idx < threads.length) {
+                setHighlightIndex(idx);
+                return;
+            }
+        }
+        // Any other printable character is free-text focus; typing clears the
+        // thread selection so the two inputs never fight.
+        if (input && !key.ctrl && !key.meta && !key.escape && !key.tab) {
+            setValue((v) => v + input);
+            setHighlightIndex(null);
+        }
+    });
+    const selected = highlightIndex !== null ? threads[highlightIndex] : null;
+    const hint = onOpenLoops
+        ? '(↑↓ or number to pick · type your own · ⌃L loops · enter)'
+        : '(↑↓ or number to pick a thread · or type · enter)';
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 2, children: [_jsxs(Text, { color: theme.gold, children: ["What are you working on today? ", _jsx(Text, { color: theme.gray, children: hint })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.gold, children: '> ' }), selected && value === '' ? (_jsxs(Text, { color: theme.gold, children: [highlightIndex + 1, " \u00B7", ' ', _jsx(Text, { color: theme.text, children: selected.title })] })) : (_jsxs(Text, { color: theme.text, children: [value, _jsx(Text, { inverse: true, children: " " })] }))] })] }));
+}
+/** The launch banner shown after the prompt resolves, just before handoff. */
+function LaunchBanner({ cli }) {
+    const rule = '─'.repeat(Math.max(0, 54 - cli.length));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 2, children: [_jsxs(Text, { color: theme.gold, children: ["Launching ", cli, "  ", _jsx(Text, { color: theme.gray, children: rule })] }), _jsxs(Text, { color: theme.gray, children: ["Becki is connected to ", cli, " over MCP \u2014 context loads on demand."] })] }));
+}
+export function App({ vault, config, warnings, onComplete }) {
+    const { exit } = useApp();
+    // If the prompt is disabled, jump straight to the launch banner.
+    const [phase, setPhase] = useState(config.skip_prompt ? 'launching' : 'prompt');
+    // Which open thread the prompt currently has highlighted (null = free text).
+    const [highlightIndex, setHighlightIndex] = useState(null);
+    // Vault owner — gates the loops manager (Ctrl+L). Resolved once.
+    const [userId] = useState(() => resolveAuth().userId);
+    // When skip_prompt is set, resolve immediately on first render.
+    React.useEffect(() => {
+        if (config.skip_prompt) {
+            onComplete(null);
+            const t = setTimeout(() => exit(), 500);
+            return () => clearTimeout(t);
+        }
+        return undefined;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const handleSubmit = (focus) => {
+        onComplete(focus);
+        setPhase('launching');
+        // Give the launch banner a beat to render, then unmount Ink so the
+        // spawned CLI can take over the inherited TTY cleanly.
+        setTimeout(() => exit(), 500);
+    };
+    // Loops manager — a full-screen detour. Quitting it returns to the prompt.
+    if (phase === 'loops' && userId) {
+        return _jsx(LoopsApp, { userId: userId, onExit: () => setPhase('prompt') });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Splash, { vault: vault, config: config, warnings: warnings, highlightIndex: phase === 'prompt' ? highlightIndex : null }), phase === 'prompt' ? (_jsx(FocusPrompt, { threads: vault.openThreads, highlightIndex: highlightIndex, setHighlightIndex: setHighlightIndex, onOpenLoops: userId ? () => setPhase('loops') : undefined, onSubmit: handleSubmit })) : (_jsx(LaunchBanner, { cli: config.cli }))] }));
+}

package/dist/screens/_shared.js

@@ -0,0 +1,67 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * _shared.tsx — small primitives shared by every screen.
+ *
+ * Screen header (title + back hint), simple key/value rows, async loader hook.
+ * Keeps each screen short and visually consistent.
+ */
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from '../theme.js';
+export function ScreenHeader({ title, subtitle }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: theme.gold, bold: true, children: ["\u25C6 ", title.toUpperCase()] }) }), subtitle && (_jsx(Box, { children: _jsx(Text, { color: theme.gray, children: subtitle }) }))] }));
+}
+export function Kv({ k, v, kWidth = 18, color }) {
+    return (_jsxs(Box, { children: [_jsx(Box, { width: kWidth, children: _jsx(Text, { color: theme.gray, children: k }) }), _jsx(Text, { color: color ?? theme.text, children: v })] }));
+}
+export function BackFooter({ extra }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.gray, dimColor: true, children: ["esc/\u2190 back to menu", extra ? ` · ${extra}` : ''] }) }));
+}
+/** Closes the screen when the user presses esc or left-arrow. */
+export function useBackOnEsc(onBack, extraHandler) {
+    useInput((input, key) => {
+        if (key.escape || key.leftArrow) {
+            onBack();
+            return;
+        }
+        extraHandler?.(input, key);
+    });
+}
+/**
+ * Tiny data-fetch hook. Re-runs the loader on demand via refresh().
+ * Captures errors into state instead of throwing.
+ */
+export function useAsync(loader, deps = []) {
+    const [loading, setLoading] = useState(true);
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [tick, setTick] = useState(0);
+    useEffect(() => {
+        let cancelled = false;
+        setLoading(true);
+        setError(null);
+        loader()
+            .then((d) => { if (!cancelled) {
+            setData(d);
+            setLoading(false);
+        } })
+            .catch((e) => {
+            if (!cancelled) {
+                setError(e instanceof Error ? e.message : String(e));
+                setLoading(false);
+            }
+        });
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [tick, ...deps]);
+    return { loading, data, error, refresh: () => setTick((t) => t + 1) };
+}
+export function Loading({ label = 'loading…' }) {
+    return _jsx(Text, { color: theme.gray, children: label });
+}
+export function ErrorLine({ message }) {
+    return _jsxs(Text, { color: "red", children: ["! ", message] });
+}
+export function OkLine({ message }) {
+    return _jsxs(Text, { color: "green", children: ["\u2713 ", message] });
+}

package/dist/screens/account.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * account.tsx — read-only account state + handoff to web for full management.
+ *
+ * Most account operations (signup, password reset, GitHub OAuth) require a
+ * browser and live at becki.io/account. This screen shows what we know
+ * locally and opens the web portal in the default browser.
+ */
+import React from 'react';
+import { Box, useInput } from 'ink';
+import { spawn } from 'node:child_process';
+import { platform } from 'node:os';
+import { resolveAuth } from '../client.js';
+import { ScreenHeader, Kv, BackFooter, OkLine } from './_shared.js';
+import { theme } from '../theme.js';
+function openInBrowser(url) {
+    const cmd = platform() === 'darwin' ? 'open' :
+        platform() === 'win32' ? 'cmd' :
+            'xdg-open';
+    const args = platform() === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+}
+export function AccountScreen({ onBack }) {
+    const auth = resolveAuth();
+    const [opened, setOpened] = React.useState(false);
+    useInput((input, key) => {
+        if (key.escape || key.leftArrow)
+            onBack();
+        else if (input === 'o') {
+            openInBrowser('https://www.becki.io/account');
+            setOpened(true);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(ScreenHeader, { title: "Account", subtitle: "manage email, password, and GitHub at becki.io/account" }), _jsx(Kv, { k: "User ID", v: auth.userId ?? 'not signed in — visit /account in browser', color: auth.userId ? theme.text : 'yellow' }), _jsx(Kv, { k: "Install token", v: auth.ingestToken ? 'present' : 'missing', color: auth.ingestToken ? theme.text : 'yellow' }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: opened && _jsx(OkLine, { message: "opened becki.io/account in your browser" }) }), _jsx(BackFooter, { extra: "o open /account in browser" })] }));
+}

package/dist/screens/backfills.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * backfills.tsx — run scheduled or windowed history ingests.
+ *
+ * Shells out to `becki-mcp bootstrap N` and `becki-mcp digest`. Streams
+ * stderr so the user sees progress in real time (each ai-sessions log line
+ * lands here). On Win/Linux: same spawn — becki-mcp is the cross-platform
+ * binary the user installed alongside `becki`.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { spawn } from 'node:child_process';
+import { ScreenHeader, BackFooter, OkLine, ErrorLine } from './_shared.js';
+import { theme } from '../theme.js';
+const OPTIONS = [
+    { key: '1', label: 'digest (today)', command: ['digest'], description: 'process new AI sessions settled in the last 24h' },
+    { key: '2', label: 'bootstrap 7 days', command: ['bootstrap', '7'], description: '~1m · last week of AI session history' },
+    { key: '3', label: 'bootstrap 30 days', command: ['bootstrap', '30'], description: '~3m · last month' },
+    { key: '4', label: 'bootstrap 90 days', command: ['bootstrap', '90'], description: '~10m · last quarter (recommended first-run)' },
+    { key: '5', label: 'bootstrap full', command: ['bootstrap', '36500'], description: 'everything on disk — token cap will pause mid-way' },
+];
+export function BackfillsScreen({ onBack }) {
+    const [cursor, setCursor] = useState(0);
+    const [action, setAction] = useState({ kind: 'idle' });
+    const [spawnError, setSpawnError] = useState(null);
+    const startAction = (opt) => {
+        setSpawnError(null);
+        const output = [];
+        let proc;
+        try {
+            proc = spawn('becki-mcp', opt.command, { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (err) {
+            setSpawnError(err.message);
+            return;
+        }
+        const onChunk = (buf) => {
+            const lines = buf.toString('utf8').split('\n').filter((l) => l.length > 0);
+            output.push(...lines);
+            // Cap output buffer so Ink doesn't churn re-rendering 10k lines.
+            if (output.length > 100)
+                output.splice(0, output.length - 100);
+            setAction((a) => (a.kind === 'running' ? { ...a, output: [...output] } : a));
+        };
+        proc.stdout?.on('data', onChunk);
+        proc.stderr?.on('data', onChunk);
+        proc.on('error', (err) => {
+            setSpawnError(`becki-mcp not on PATH? ${err.message}`);
+            setAction({ kind: 'idle' });
+        });
+        proc.on('close', (code) => {
+            setAction({ kind: 'done', label: opt.label, output, exitCode: code ?? -1 });
+        });
+        setAction({ kind: 'running', label: opt.label, proc, output });
+    };
+    useInput((input, key) => {
+        if (action.kind === 'running') {
+            // Allow cancel via Ctrl-C / esc.
+            if (key.escape || (input === 'c' && key.ctrl)) {
+                action.proc.kill('SIGTERM');
+            }
+            return;
+        }
+        if (key.escape || key.leftArrow) {
+            onBack();
+            return;
+        }
+        if (key.upArrow || input === 'k')
+            setCursor((c) => Math.max(0, c - 1));
+        else if (key.downArrow || input === 'j')
+            setCursor((c) => Math.min(OPTIONS.length - 1, c + 1));
+        else if (key.return)
+            startAction(OPTIONS[cursor]);
+        else if (/^[1-5]$/.test(input)) {
+            const i = Number(input) - 1;
+            setCursor(i);
+            startAction(OPTIONS[i]);
+        }
+    });
+    if (action.kind === 'running') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(ScreenHeader, { title: "Backfills \u00B7 running", subtitle: action.label }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: theme.gray, paddingX: 1, children: [action.output.slice(-20).map((line, i) => (_jsx(Text, { color: theme.text, children: line }, i))), action.output.length === 0 && _jsx(Text, { color: theme.gray, children: "(waiting for first output\u2026)" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, dimColor: true, children: "esc cancel (SIGTERM)" }) })] }));
+    }
+    if (action.kind === 'done') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(ScreenHeader, { title: "Backfills \u00B7 done", subtitle: action.label }), action.exitCode === 0
+                    ? _jsx(OkLine, { message: `finished cleanly (exit 0)` })
+                    : _jsx(ErrorLine, { message: `exited with code ${action.exitCode}` }), _jsx(Box, { marginTop: 1, flexDirection: "column", borderStyle: "single", borderColor: theme.gray, paddingX: 1, children: action.output.slice(-12).map((line, i) => (_jsx(Text, { color: theme.gray, children: line }, i))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, dimColor: true, children: "any key to return to backfills menu" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(ScreenHeader, { title: "Backfills", subtitle: "invokes becki-mcp digest/bootstrap; streams output here" }), OPTIONS.map((o, i) => {
+                const sel = i === cursor;
+                return (_jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: sel ? theme.gold : theme.gray, children: sel ? '▸ ' : '  ' }) }), _jsx(Box, { width: 3, children: _jsx(Text, { color: theme.gray, children: o.key }) }), _jsx(Box, { width: 22, children: _jsx(Text, { color: sel ? theme.gold : theme.text, bold: sel, children: o.label }) }), _jsx(Text, { color: theme.gray, children: o.description })] }, o.key));
+            }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.gray, children: "Re-extract operations (advanced):" }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsx(Text, { color: theme.gray, dimColor: true, children: "\u00B7 Decision Reasoning Graph re-run \u2014 scheduled in Core v0.7" }), _jsx(Text, { color: theme.gray, dimColor: true, children: "\u00B7 Commitment dedup re-run \u2014 scheduled in Core v0.7" }), _jsx(Text, { color: theme.gray, dimColor: true, children: "\u00B7 Vault re-embed \u2014 only after model upgrade (v0.7)" })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.gray, children: "Git history:" }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: theme.gray, dimColor: true, children: "\u00B7 not yet wired \u2014 local git-log walker ships in Core v1.2 (#192)" }) })] }), spawnError && (_jsx(Box, { marginTop: 1, children: _jsx(ErrorLine, { message: spawnError }) })), _jsx(BackFooter, { extra: "\u2191/\u2193 pick \u00B7 enter run \u00B7 1-5 jump+run" })] }));
+}

package/dist/screens/diagnostics.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * diagnostics.tsx — HTTP reachability probes for Becki's three upstream
+ * dependencies.
+ *
+ * Each probe is a HEAD (or smallest possible GET) with a short timeout. Result
+ * is "reachable / unreachable / auth-required" — auth-required (401) still
+ * means the endpoint is up, just doesn't accept anon. That's the expected
+ * answer for endpoints behind auth.
+ */
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { ScreenHeader, BackFooter } from './_shared.js';
+import { theme } from '../theme.js';
+const PROBES = [
+    { name: 'Supabase (rest)', url: 'https://mbutedmgtkmoigfbrthr.supabase.co/rest/v1/', method: 'GET', expect: [200, 401] },
+    { name: 'Supabase (edge fn)', url: 'https://mbutedmgtkmoigfbrthr.supabase.co/functions/v1/extract-mcp-content', method: 'POST', expect: [401] },
+    { name: 'Voyage AI', url: 'https://api.voyageai.com/v1/embeddings', method: 'POST', expect: [401] },
+    { name: 'Anthropic', url: 'https://api.anthropic.com/v1/messages', method: 'POST', expect: [401, 400] },
+    { name: 'becki.io', url: 'https://www.becki.io/', method: 'GET', expect: [200] },
+];
+async function runProbe(p) {
+    const start = Date.now();
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 5_000);
+    try {
+        const r = await fetch(p.url, {
+            method: p.method ?? 'HEAD',
+            signal: ctrl.signal,
+            body: p.method === 'POST' ? '{}' : undefined,
+            headers: p.method === 'POST' ? { 'Content-Type': 'application/json' } : undefined,
+        });
+        clearTimeout(timeout);
+        const latencyMs = Date.now() - start;
+        const up = (p.expect ?? [200]).includes(r.status);
+        return { state: up ? 'up' : 'unknown', status: r.status, latencyMs };
+    }
+    catch (err) {
+        clearTimeout(timeout);
+        return { state: 'down', error: err.message };
+    }
+}
+export function DiagnosticsScreen({ onBack }) {
+    const [results, setResults] = useState(new Map());
+    const runAll = React.useCallback(() => {
+        const next = new Map();
+        for (const p of PROBES)
+            next.set(p.name, { state: 'running' });
+        setResults(new Map(next));
+        Promise.all(PROBES.map(async (p) => {
+            const r = await runProbe(p);
+            next.set(p.name, r);
+            setResults(new Map(next));
+        }));
+    }, []);
+    React.useEffect(() => { runAll(); }, [runAll]);
+    useInput((input, key) => {
+        if (key.escape || key.leftArrow) {
+            onBack();
+            return;
+        }
+        if (input === 'r')
+            runAll();
+    });
+    const stateColor = (s) => {
+        switch (s) {
+            case 'up': return 'green';
+            case 'down': return 'red';
+            case 'unknown': return 'yellow';
+            case 'running': return theme.gray;
+            default: return theme.gray;
+        }
+    };
+    const stateGlyph = (s) => {
+        switch (s) {
+            case 'up': return '●';
+            case 'down': return '○';
+            case 'unknown': return '◐';
+            case 'running': return '…';
+            default: return '?';
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(ScreenHeader, { title: "Diagnostics", subtitle: "reachability checks for Becki's upstream dependencies" }), PROBES.map((p) => {
+                const r = results.get(p.name) ?? { state: 'idle' };
+                return (_jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: stateColor(r.state), children: stateGlyph(r.state) }) }), _jsx(Box, { width: 22, children: _jsx(Text, { color: theme.text, children: p.name }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: theme.gray, children: r.status ? `${r.status}` : r.state === 'down' ? 'down' : r.state === 'running' ? 'probing' : '—' }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: theme.gray, children: r.latencyMs ? `${r.latencyMs}ms` : '' }) }), _jsx(Text, { color: theme.gray, dimColor: true, children: r.error ?? '' })] }, p.name));
+            }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, dimColor: true, children: "\u25CF up \u00B7 \u25D0 unexpected status (still reachable) \u00B7 \u25CB unreachable \u00B7 \u2026 probing" }) }), _jsx(BackFooter, { extra: "r re-run all" })] }));
+}