@matthesketh/fleet 1.2.0 → 1.7.0

package/dist/tui/views/LogsView.js

@@ -17,6 +17,8 @@ export function LogsView() {
     const [following, setFollowing] = useState(false);
     const [loading, setLoading] = useState(true);
     const streamRef = useRef(null);
+    const lineBufferRef = useRef([]);
+    const flushTimerRef = useRef(null);
     useEffect(() => {
         if (!selectedApp)
             return;
@@ -35,6 +37,10 @@ export function LogsView() {
                 streamRef.current.kill();
                 streamRef.current = null;
             }
+            if (flushTimerRef.current) {
+                clearInterval(flushTimerRef.current);
+                flushTimerRef.current = null;
+            }
         };
     }, [selectedApp]);
     const handler = (input, key) => {
@@ -44,6 +50,16 @@ export function LogsView() {
                     streamRef.current.kill();
                     streamRef.current = null;
                 }
+                if (flushTimerRef.current) {
+                    clearInterval(flushTimerRef.current);
+                    flushTimerRef.current = null;
+                }
+                // flush any remaining buffered lines
+                if (lineBufferRef.current.length > 0) {
+                    const buf = lineBufferRef.current;
+                    lineBufferRef.current = [];
+                    setLines(prev => [...prev, ...buf].slice(-MAX_LINES));
+                }
                 setFollowing(false);
             }
             else if (selectedApp) {
@@ -51,8 +67,15 @@ export function LogsView() {
                 const handle = streamFleetCommand(['logs', selectedApp, '-f']);
                 streamRef.current = handle;
                 handle.onData((line) => {
-                    setLines(prev => [...prev.slice(-MAX_LINES + 1), line]);
+                    lineBufferRef.current.push(line);
                 });
+                flushTimerRef.current = setInterval(() => {
+                    const buf = lineBufferRef.current;
+                    if (buf.length === 0)
+                        return;
+                    lineBufferRef.current = [];
+                    setLines(prev => [...prev, ...buf].slice(-MAX_LINES));
+                }, 50);
             }
             return true;
         }

package/dist/tui/views/MultiLogsView.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function MultiLogsView(): React.JSX.Element;

package/dist/tui/views/MultiLogsView.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
+import { useAvailableHeight } from '@matthesketh/ink-viewport';
+import { colors } from '../theme.js';
+import { useRedact } from '../state.js';
+import { load } from '../../core/registry.js';
+import { startMultiTail, resolveSources, } from '../../core/logs-multi.js';
+const MAX_LINES = 500;
+const LEVEL_RANKS = ['debug', 'info', 'warn', 'error', 'all'];
+const LEVEL_RANK_NUMBER = {
+    debug: 0, info: 1, warn: 2, error: 3,
+};
+const SOURCE_PALETTE = [colors.primary, colors.success, colors.warning, colors.muted, 'cyan', 'magenta'];
+function colourForSource(name) {
+    let h = 0;
+    for (let i = 0; i < name.length; i++)
+        h = (h * 31 + name.charCodeAt(i)) | 0;
+    return SOURCE_PALETTE[Math.abs(h) % SOURCE_PALETTE.length];
+}
+export function MultiLogsView() {
+    const redact = useRedact();
+    const availableHeight = useAvailableHeight();
+    const allSources = useMemo(() => {
+        try {
+            return resolveSources(load().apps);
+        }
+        catch {
+            return [];
+        }
+    }, []);
+    // Selection: by default, every container. User toggles with Space.
+    const [selected, setSelected] = useState(() => new Set(allSources.map(s => `${s.app}/${s.container}`)));
+    const [pickerIndex, setPickerIndex] = useState(0);
+    const [paused, setPaused] = useState(false);
+    const [level, setLevel] = useState('all');
+    const [lines, setLines] = useState([]);
+    const [pickerFocused, setPickerFocused] = useState(true);
+    const handleRef = useRef(null);
+    const lineIdRef = useRef(0);
+    // Buffer lines between renders so we batch React updates and don't flicker
+    // when bursts of output land. flushed every 100ms.
+    const pendingRef = useRef([]);
+    // (Re)start tailers whenever the selection changes.
+    useEffect(() => {
+        if (handleRef.current) {
+            void handleRef.current.stop();
+            handleRef.current = null;
+        }
+        pendingRef.current = [];
+        setLines([]);
+        const sources = allSources.filter(s => selected.has(`${s.app}/${s.container}`));
+        if (sources.length === 0)
+            return;
+        const handle = startMultiTail(sources, { tail: 30, follow: true }, line => {
+            pendingRef.current.push({ ...line, id: ++lineIdRef.current });
+        });
+        handleRef.current = handle;
+        return () => { void handle.stop(); };
+    }, [allSources, selected]);
+    // Flush buffered lines into state on a 100ms tick (batched to avoid flicker).
+    useEffect(() => {
+        const t = setInterval(() => {
+            if (paused)
+                return;
+            if (pendingRef.current.length === 0)
+                return;
+            const batch = pendingRef.current;
+            pendingRef.current = [];
+            setLines(prev => {
+                const merged = prev.length + batch.length > MAX_LINES
+                    ? [...prev, ...batch].slice(-MAX_LINES)
+                    : [...prev, ...batch];
+                return merged;
+            });
+        }, 100);
+        return () => clearInterval(t);
+    }, [paused]);
+    const handler = (input, key) => {
+        // Tab toggles focus between picker and viewport (so j/k goes to the right place).
+        if (key.tab) {
+            setPickerFocused(p => !p);
+            return true;
+        }
+        if (pickerFocused) {
+            if (input === 'j' || key.downArrow) {
+                setPickerIndex(i => Math.min(i + 1, allSources.length - 1));
+                return true;
+            }
+            if (input === 'k' || key.upArrow) {
+                setPickerIndex(i => Math.max(i - 1, 0));
+                return true;
+            }
+            if (input === ' ') {
+                const src = allSources[pickerIndex];
+                if (!src)
+                    return true;
+                const k = `${src.app}/${src.container}`;
+                setSelected(prev => {
+                    const next = new Set(prev);
+                    if (next.has(k))
+                        next.delete(k);
+                    else
+                        next.add(k);
+                    return next;
+                });
+                return true;
+            }
+            if (input === 'a') {
+                // Select / deselect all
+                setSelected(prev => prev.size === allSources.length
+                    ? new Set()
+                    : new Set(allSources.map(s => `${s.app}/${s.container}`)));
+                return true;
+            }
+        }
+        if (input === 'p') {
+            setPaused(p => !p);
+            return true;
+        }
+        if (input === 'c') {
+            setLines([]);
+            pendingRef.current = [];
+            return true;
+        }
+        if (input === 'L') {
+            // Cycle level filter
+            setLevel(l => LEVEL_RANKS[(LEVEL_RANKS.indexOf(l) + 1) % LEVEL_RANKS.length]);
+            return true;
+        }
+        return false;
+    };
+    useRegisterHandler(handler);
+    // Apply level filter at render time so the buffer keeps everything (cheap to
+    // change filter back and forth without losing history).
+    const filteredLines = useMemo(() => {
+        if (level === 'all')
+            return lines;
+        const minRank = LEVEL_RANK_NUMBER[level];
+        return lines.filter(l => {
+            if (l.level === 'unknown')
+                return false;
+            return LEVEL_RANK_NUMBER[l.level] >= minRank;
+        });
+    }, [lines, level]);
+    // Rough split of the viewport: 30% picker, 70% logs (min 5 rows each).
+    const totalH = Math.max(10, availableHeight - 4);
+    const pickerH = Math.max(5, Math.floor(totalH * 0.3));
+    const logsH = Math.max(5, totalH - pickerH - 1);
+    const visibleLogs = filteredLines.slice(-logsH);
+    const maxLabelLen = useMemo(() => allSources.reduce((m, s) => Math.max(m, `${s.app}/${s.container}`.length), 0), [allSources]);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, gap: 2, children: [_jsx(Text, { bold: true, color: colors.primary, children: "Multi-source Logs" }), _jsxs(Text, { color: colors.muted, children: [selected.size, "/", allSources.length, " sources \u00B7 level:", level, " \u00B7 ", paused ? 'PAUSED' : 'live'] }), !paused && handleRef.current && handleRef.current.active() > 0 && (_jsxs(Text, { color: colors.success, children: [_jsx(Spinner, { type: "dots" }), " tailing"] }))] }), _jsxs(Box, { flexDirection: "column", height: pickerH, marginBottom: 1, borderStyle: pickerFocused ? 'round' : 'single', borderColor: pickerFocused ? colors.primary : colors.muted, children: [_jsx(Box, { paddingX: 1, children: _jsx(Text, { bold: true, color: colors.muted, children: "Sources [Tab to switch focus, Space toggle, a all/none]" }) }), _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [allSources.slice(0, pickerH - 2).map((src, i) => {
+                                const k = `${src.app}/${src.container}`;
+                                const checked = selected.has(k);
+                                const cursor = pickerFocused && i === pickerIndex ? '>' : ' ';
+                                return (_jsxs(Text, { color: checked ? colors.success : colors.muted, children: [cursor, " ", checked ? '☑' : '☐', " ", redact(src.app), "/", src.container] }, k));
+                            }), allSources.length > pickerH - 2 && (_jsxs(Text, { color: colors.muted, children: ["\u2026 ", allSources.length - (pickerH - 2), " more"] }))] })] }), _jsxs(Box, { flexDirection: "column", height: logsH, borderStyle: !pickerFocused ? 'round' : 'single', borderColor: !pickerFocused ? colors.primary : colors.muted, children: [_jsx(Box, { paddingX: 1, children: _jsxs(Text, { bold: true, color: colors.muted, children: ["Logs [p pause \u00B7 c clear \u00B7 L level cycle \u00B7 last ", visibleLogs.length, "/", filteredLines.length, "]"] }) }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: visibleLogs.map(line => {
+                            const label = `${line.app}/${line.container}`.padEnd(maxLabelLen);
+                            const colour = colourForSource(`${line.app}/${line.container}`);
+                            const ts = line.ts.toISOString().slice(11, 19); // HH:MM:SS
+                            return (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: colors.muted, children: [ts, " "] }), _jsx(Text, { color: colour, children: label }), _jsxs(Text, { children: [" ", line.text] })] }, line.id));
+                        }) })] })] }));
+}

package/dist/tui/views/SecretEdit.js

@@ -1,5 +1,5 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { Box, Text } from 'ink';
 import TextInput from 'ink-text-input';
 import { useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
@@ -16,6 +16,13 @@ export function SecretEdit() {
     const [value, setValue] = useState('');
     const [phase, setPhase] = useState(isNew ? 'key' : 'value');
     const [status, setStatus] = useState(null);
+    const timerRef = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, []);
     useEffect(() => {
         if (!isNew && selectedApp && selectedSecret) {
             try {
@@ -34,7 +41,7 @@ export function SecretEdit() {
         const result = secrets.saveSecret(selectedApp, keyName, value);
         if (result.ok) {
             setStatus('Saved and re-sealed');
-            setTimeout(() => {
+            timerRef.current = setTimeout(() => {
                 dispatch({ type: 'GO_BACK' });
             }, 500);
         }
@@ -53,5 +60,5 @@ export function SecretEdit() {
     return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { bold: true, color: colors.primary, children: [isNew ? 'Add Secret' : 'Edit Secret', " - ", selectedApp] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: colors.muted, children: "Key:   " }), isNew && phase === 'key' ? (_jsx(TextInput, { value: keyName, onChange: setKeyName, onSubmit: () => {
                                     if (keyName)
                                         setPhase('value');
-                                } })) : (_jsx(Text, { bold: true, children: keyName }))] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.muted, children: "Value: " }), phase === 'value' ? (_jsx(TextInput, { value: value, onChange: setValue, onSubmit: save })) : (_jsx(Text, { color: colors.muted, children: "(press Enter on key first)" }))] })] }), status && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: status.startsWith('Error') ? colors.error : colors.success, children: status }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "Enter to save | Esc to cancel" }) })] }));
+                                } })) : (_jsx(Text, { bold: true, children: keyName }))] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.muted, children: "Value: " }), phase === 'value' ? (_jsx(TextInput, { value: value, onChange: setValue, onSubmit: save, mask: "*" })) : (_jsx(Text, { color: colors.muted, children: "(press Enter on key first)" }))] })] }), status && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: status.startsWith('Error') ? colors.error : colors.success, children: status }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "Enter to save | Esc to cancel" }) })] }));
 }

package/dist/tui/views/SecretsView.js

@@ -56,6 +56,8 @@ export function SecretsView() {
             }
         }
         else if (subView === 'secret-list') {
+            if (secrets.secrets.length === 0)
+                return false;
             if (input === 'j' || key.downArrow) {
                 dispatch({ type: 'SET_INDEX', view: 'secrets', index: Math.min(selectedIndex + 1, secrets.secrets.length - 1) });
                 return true;
@@ -80,15 +82,16 @@ export function SecretsView() {
             }
             if (input === 'd' && selectedApp && secrets.secrets[selectedIndex]) {
                 const secretKey = secrets.secrets[selectedIndex].key;
+                const appName = selectedApp;
                 dispatch({
                     type: 'CONFIRM',
                     action: {
                         label: `Delete secret "${secretKey}"?`,
-                        description: `This will remove ${secretKey} from ${redact(selectedApp)}'s vault.`,
+                        description: `This will remove ${secretKey} from ${redact(appName)}'s vault.`,
                         onConfirm: () => {
-                            const result = secrets.deleteSecret(selectedApp, secretKey);
+                            const result = secrets.deleteSecret(appName, secretKey);
                             if (result.ok) {
-                                secrets.loadAppSecrets(selectedApp);
+                                secrets.loadAppSecrets(appName);
                                 secrets.refresh();
                             }
                             else {

package/dist/ui/prompt.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Plain-text and hidden-input prompts, no external deps.
+ *
+ * promptHidden uses raw mode + manual char-by-char read so the echoed value
+ * never appears on the terminal — important for pasting secrets and for
+ * tools like `script` / asciinema.
+ */
+export declare function prompt(message: string, defaultValue?: string): Promise<string>;
+/**
+ * String variant — convenience wrapper around the Buffer variant. Use the
+ * Buffer variant directly if you want the strongest in-memory guarantees;
+ * this one converts to string and the result lives in the V8 heap until GC.
+ */
+export declare function promptHidden(message: string): Promise<string>;
+/**
+ * Buffer-based hidden input. Returns the raw input bytes in a Buffer the
+ * caller is expected to zero out (`buf.fill(0)`) when finished — see
+ * `withSecretBuffer` for an automated pattern.
+ *
+ * Why Buffer (not string)?
+ *   - Node strings are immutable + interned in V8 heap; you can't zero them.
+ *     Once a secret string exists, it sits in the heap until GC.
+ *   - Buffer is a writable byte array. Calling `buf.fill(0)` overwrites the
+ *     bytes in-place; subsequent heap dumps and core dumps contain zeros.
+ *
+ * Hardening:
+ *   - Buffer is grown by `Buffer.concat` and the intermediate buffers are
+ *     zeroed before being released.
+ *   - Non-TTY fallback uses `terminal: false` so readline can never promote
+ *     stdout to terminal mode and echo the value.
+ *   - End/error/SIGINT all reject + restore terminal state and zero the
+ *     in-flight buffer so a death never leaves bytes behind.
+ *
+ * KNOWN LIMITATION: any string copy made downstream (e.g. `buf.toString()`
+ * for regex validation) lives in V8 heap until GC. Convert as late as
+ * possible and let the string go out of scope ASAP.
+ */
+export declare function promptHiddenBuffer(message: string): Promise<Buffer>;
+/**
+ * Recommended pattern for handling a secret in memory: read into a Buffer,
+ * pass to your callback, zero on exit (success or throw). Use this instead
+ * of `promptHidden` when the value will be processed by code under your
+ * control end-to-end.
+ *
+ * Example:
+ *   await withSecretBuffer('Paste new STRIPE_SECRET_KEY', async (buf) => {
+ *     const asString = buf.toString('utf8');   // brief string copy
+ *     await sealApp(app, applyRotation(...));   // age-encrypt happens here
+ *     // String copy is unreferenced from this point; buf is zeroed on exit.
+ *   });
+ */
+export declare function withSecretBuffer<T>(message: string, fn: (value: Buffer) => Promise<T>): Promise<T>;

package/dist/ui/prompt.js

@@ -0,0 +1,169 @@
+/**
+ * Plain-text and hidden-input prompts, no external deps.
+ *
+ * promptHidden uses raw mode + manual char-by-char read so the echoed value
+ * never appears on the terminal — important for pasting secrets and for
+ * tools like `script` / asciinema.
+ */
+import * as readline from 'node:readline';
+export async function prompt(message, defaultValue) {
+    const hint = defaultValue !== undefined ? ` [${defaultValue}]` : '';
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(`${message}${hint}: `, answer => {
+            rl.close();
+            const trimmed = answer.trim();
+            resolve(trimmed === '' && defaultValue !== undefined ? defaultValue : trimmed);
+        });
+    });
+}
+/**
+ * String variant — convenience wrapper around the Buffer variant. Use the
+ * Buffer variant directly if you want the strongest in-memory guarantees;
+ * this one converts to string and the result lives in the V8 heap until GC.
+ */
+export async function promptHidden(message) {
+    const buf = await promptHiddenBuffer(message);
+    try {
+        return buf.toString('utf8');
+    }
+    finally {
+        buf.fill(0);
+    }
+}
+/**
+ * Buffer-based hidden input. Returns the raw input bytes in a Buffer the
+ * caller is expected to zero out (`buf.fill(0)`) when finished — see
+ * `withSecretBuffer` for an automated pattern.
+ *
+ * Why Buffer (not string)?
+ *   - Node strings are immutable + interned in V8 heap; you can't zero them.
+ *     Once a secret string exists, it sits in the heap until GC.
+ *   - Buffer is a writable byte array. Calling `buf.fill(0)` overwrites the
+ *     bytes in-place; subsequent heap dumps and core dumps contain zeros.
+ *
+ * Hardening:
+ *   - Buffer is grown by `Buffer.concat` and the intermediate buffers are
+ *     zeroed before being released.
+ *   - Non-TTY fallback uses `terminal: false` so readline can never promote
+ *     stdout to terminal mode and echo the value.
+ *   - End/error/SIGINT all reject + restore terminal state and zero the
+ *     in-flight buffer so a death never leaves bytes behind.
+ *
+ * KNOWN LIMITATION: any string copy made downstream (e.g. `buf.toString()`
+ * for regex validation) lives in V8 heap until GC. Convert as late as
+ * possible and let the string go out of scope ASAP.
+ */
+export function promptHiddenBuffer(message) {
+    if (!process.stdin.isTTY) {
+        return new Promise((resolve, reject) => {
+            const rl = readline.createInterface({ input: process.stdin, terminal: false });
+            process.stdout.write(message + ': ');
+            let done = false;
+            const finish = (cb) => { if (done)
+                return; done = true; rl.close(); cb(); };
+            rl.once('line', line => finish(() => resolve(Buffer.from(line, 'utf8'))));
+            rl.once('close', () => finish(() => reject(new Error('Cancelled (stdin closed)'))));
+            rl.once('error', err => finish(() => reject(err)));
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const stdin = process.stdin;
+        process.stdout.write(message + ': ');
+        // Pre-allocate; grow geometrically to avoid quadratic Buffer.concat.
+        let buf = Buffer.alloc(64);
+        let len = 0;
+        let settled = false;
+        const wasRaw = stdin.isRaw;
+        const grow = (need) => {
+            if (len + need <= buf.length)
+                return;
+            const next = Buffer.alloc(Math.max(buf.length * 2, len + need));
+            buf.copy(next);
+            buf.fill(0); // zero the old buffer before releasing
+            buf = next;
+        };
+        const cleanup = () => {
+            stdin.removeListener('data', onData);
+            stdin.removeListener('end', onEnd);
+            stdin.removeListener('error', onError);
+            process.removeListener('SIGINT', onSigint);
+            try {
+                stdin.setRawMode(wasRaw);
+            }
+            catch { /* terminal may be gone */ }
+            stdin.pause();
+        };
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            fn();
+        };
+        const wipeAndReject = (err) => {
+            buf.fill(0);
+            settle(() => reject(err));
+        };
+        const onData = (chunk) => {
+            for (let i = 0; i < chunk.length; i++) {
+                const c = chunk[i];
+                if (c === 0x0d || c === 0x0a) { // \r \n
+                    process.stdout.write('\n');
+                    const out = Buffer.alloc(len);
+                    buf.copy(out, 0, 0, len);
+                    buf.fill(0);
+                    settle(() => resolve(out));
+                    return;
+                }
+                else if (c === 0x03) { // Ctrl-C
+                    process.stdout.write('\n');
+                    wipeAndReject(new Error('Cancelled'));
+                    return;
+                }
+                else if (c === 0x7f || c === 0x08) { // backspace
+                    if (len > 0) {
+                        len -= 1;
+                        buf[len] = 0;
+                    }
+                }
+                else if (c >= 0x20) { // printable
+                    grow(1);
+                    buf[len++] = c;
+                }
+            }
+        };
+        const onEnd = () => wipeAndReject(new Error('Cancelled (stdin ended)'));
+        const onError = (err) => wipeAndReject(err);
+        const onSigint = () => { process.stdout.write('\n'); wipeAndReject(new Error('Cancelled (SIGINT)')); };
+        stdin.setRawMode(true);
+        stdin.resume();
+        // Note: do NOT setEncoding — we want raw bytes, not auto-decoded strings.
+        stdin.on('data', onData);
+        stdin.on('end', onEnd);
+        stdin.on('error', onError);
+        process.on('SIGINT', onSigint);
+    });
+}
+/**
+ * Recommended pattern for handling a secret in memory: read into a Buffer,
+ * pass to your callback, zero on exit (success or throw). Use this instead
+ * of `promptHidden` when the value will be processed by code under your
+ * control end-to-end.
+ *
+ * Example:
+ *   await withSecretBuffer('Paste new STRIPE_SECRET_KEY', async (buf) => {
+ *     const asString = buf.toString('utf8');   // brief string copy
+ *     await sealApp(app, applyRotation(...));   // age-encrypt happens here
+ *     // String copy is unreferenced from this point; buf is zeroed on exit.
+ *   });
+ */
+export async function withSecretBuffer(message, fn) {
+    const buf = await promptHiddenBuffer(message);
+    try {
+        return await fn(buf);
+    }
+    finally {
+        buf.fill(0);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthesketh/fleet",
-  "version": "1.2.0",
+  "version": "1.7.0",
   "description": "Docker production management CLI + MCP server for Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -10,12 +10,12 @@
   "files": [
     "dist/",
     "data/registry.example.json",
+    "scripts/guard/",
     "LICENSE",
     "README.md"
   ],
-  "workspaces": ["packages/*"],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc-alias",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
     "prepublishOnly": "npm run build"
@@ -48,33 +48,46 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.8.0",
-    "@matthesketh/ink-breadcrumb": "*",
-    "@matthesketh/ink-gauge": "*",
-    "@matthesketh/ink-input-dispatcher": "*",
-    "@matthesketh/ink-keybinding-help": "*",
-    "@matthesketh/ink-log-viewer": "*",
-    "@matthesketh/ink-modal": "*",
-    "@matthesketh/ink-pipeline": "*",
-    "@matthesketh/ink-rule": "*",
-    "@matthesketh/ink-scrollable-list": "*",
-    "@matthesketh/ink-split-pane": "*",
-    "@matthesketh/ink-status-bar": "*",
-    "@matthesketh/ink-table": "*",
-    "@matthesketh/ink-tabs": "*",
-    "@matthesketh/ink-toast": "*",
-    "@matthesketh/ink-viewport": "*",
+    "@matthesketh/ink-breadcrumb": "^0.1.0",
+    "@matthesketh/ink-chart": "0.1.0",
+    "@matthesketh/ink-form": "0.1.0",
+    "@matthesketh/ink-fuzzy-select": "0.1.0",
+    "@matthesketh/ink-gauge": "^0.1.0",
+    "@matthesketh/ink-input-dispatcher": "^0.1.0",
+    "@matthesketh/ink-keybinding-help": "^0.1.0",
+    "@matthesketh/ink-log-viewer": "^0.1.0",
+    "@matthesketh/ink-modal": "^0.1.0",
+    "@matthesketh/ink-pipeline": "^0.1.0",
+    "@matthesketh/ink-rule": "^0.1.0",
+    "@matthesketh/ink-scrollable-list": "^0.1.1",
+    "@matthesketh/ink-split-pane": "^0.1.0",
+    "@matthesketh/ink-stable-state": "^0.1.0",
+    "@matthesketh/ink-status-bar": "^0.1.0",
+    "@matthesketh/ink-table": "^0.1.0",
+    "@matthesketh/ink-tabs": "^0.1.0",
+    "@matthesketh/ink-task-list": "0.1.0",
+    "@matthesketh/ink-timeline": "0.1.0",
+    "@matthesketh/ink-toast": "^0.1.0",
+    "@matthesketh/ink-viewport": "^0.1.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "better-sqlite3": "12.9.0",
+    "chokidar": "5.0.0",
     "ink": "^5.2.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
+    "proper-lockfile": "4.1.2",
     "react": "^18.3.1",
     "zod": "^3.24.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "7.6.13",
     "@types/node": "20.17.0",
+    "@types/proper-lockfile": "4.1.4",
     "@types/react": "^18.3.28",
-    "tsx": "4.19.2",
+    "ink-testing-library": "^4.0.0",
+    "tsc-alias": "1.8.16",
+    "tsx": "4.21.0",
     "typescript": "5.6.3",
     "vitest": "4.0.18"
   }
-}
+}