@matthesketh/fleet 1.1.0 → 1.6.0

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.1.0",
+  "version": "1.6.0",
   "description": "Docker production management CLI + MCP server for Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc-alias",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
     "prepublishOnly": "npm run build"
@@ -47,18 +47,46 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.8.0",
+    "@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"
   }
-}
+}

package/dist/commands/motd.d.ts

@@ -1 +0,0 @@
-export declare function motdInstallCommand(): void;

package/dist/commands/motd.js

@@ -1,10 +0,0 @@
-import { writeFileSync, chmodSync } from 'node:fs';
-import { generateMotdScript } from '../templates/motd.js';
-import { success } from '../ui/output.js';
-const MOTD_PATH = '/etc/update-motd.d/50-fleet-status';
-export function motdInstallCommand() {
-    const script = generateMotdScript();
-    writeFileSync(MOTD_PATH, script);
-    chmodSync(MOTD_PATH, 0o755);
-    success(`Installed MOTD script at ${MOTD_PATH}`);
-}

package/dist/templates/motd.d.ts

@@ -1 +0,0 @@
-export declare function generateMotdScript(): string;

package/dist/templates/motd.js

@@ -1,7 +0,0 @@
-export function generateMotdScript() {
-    return `#!/bin/bash
-# Fleet service health check — installed by "fleet motd install"
-# Shows service status on SSH login
-/usr/bin/node /home/matt/fleet/dist/index.js watchdog --motd 2>/dev/null || echo "  Fleet: health check failed to run"
-`;
-}

package/dist/tui/components/AppList.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-interface AppListItem {
-    name: string;
-    label?: string;
-}
-interface AppListProps {
-    items: AppListItem[];
-    onSelect: (item: AppListItem) => void;
-    renderItem?: (item: AppListItem, selected: boolean) => React.JSX.Element;
-}
-export declare function AppList({ items, onSelect, renderItem }: AppListProps): React.JSX.Element;
-export {};

package/dist/tui/components/AppList.js

@@ -1,32 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { colors } from '../theme.js';
-export function AppList({ items, onSelect, renderItem }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    useInput((input, key) => {
-        if (items.length === 0)
-            return;
-        if (input === 'j' || key.downArrow) {
-            setSelectedIndex(prev => Math.min(prev + 1, items.length - 1));
-        }
-        else if (input === 'k' || key.upArrow) {
-            setSelectedIndex(prev => Math.max(prev - 1, 0));
-        }
-        else if (key.return) {
-            if (items[selectedIndex]) {
-                onSelect(items[selectedIndex]);
-            }
-        }
-    });
-    if (items.length === 0) {
-        return _jsx(Text, { color: colors.muted, children: "No items" });
-    }
-    return (_jsx(Box, { flexDirection: "column", children: items.map((item, i) => {
-            const selected = i === selectedIndex;
-            if (renderItem) {
-                return (_jsxs(Box, { children: [_jsx(Text, { color: colors.primary, children: selected ? '> ' : '  ' }), renderItem(item, selected)] }, item.name));
-            }
-            return (_jsxs(Text, { bold: selected, color: selected ? colors.primary : colors.text, children: [selected ? '> ' : '  ', item.label ?? item.name] }, item.name));
-        }) }));
-}

package/dist/tui/hooks/use-keyboard.d.ts

@@ -1 +0,0 @@
-export declare function useKeyboard(): void;

package/dist/tui/hooks/use-keyboard.js

@@ -1,44 +0,0 @@
-import { useInput } from 'ink';
-import { useAppState, useAppDispatch, nextTopView } from '../state.js';
-export function useKeyboard() {
-    const state = useAppState();
-    const dispatch = useAppDispatch();
-    useInput((input, key) => {
-        // Confirm dialog takes priority
-        if (state.confirmAction) {
-            if (input === 'y' || input === 'Y') {
-                state.confirmAction.onConfirm();
-                dispatch({ type: 'CANCEL_CONFIRM' });
-            }
-            else if (input === 'n' || input === 'N' || key.escape) {
-                dispatch({ type: 'CANCEL_CONFIRM' });
-            }
-            return;
-        }
-        // Redact toggle (not in text-input views)
-        if (input === 'x' && state.currentView !== 'secret-edit') {
-            dispatch({ type: 'TOGGLE_REDACT' });
-            return;
-        }
-        // Quit
-        if (input === 'q') {
-            process.exit(0);
-        }
-        // Tab cycles top-level views (only from top-level views)
-        if (key.tab) {
-            const topViews = ['dashboard', 'health', 'secrets'];
-            const base = topViews.includes(state.currentView)
-                ? state.currentView
-                : state.previousView ?? 'dashboard';
-            dispatch({ type: 'NAVIGATE', view: nextTopView(base) });
-            return;
-        }
-        // Escape goes back
-        if (key.escape) {
-            if (state.previousView) {
-                dispatch({ type: 'GO_BACK' });
-            }
-            return;
-        }
-    });
-}