@stigg/terminal 0.0.1-alpha

package/dist/ui/components/JsonPreview.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const COLOR = {
+    add: "green",
+    remove: "red",
+    context: undefined,
+    header: "cyan",
+};
+const PREFIX = {
+    add: "+ ",
+    remove: "- ",
+    context: "  ",
+    header: "",
+};
+export function JsonPreview({ lines, title, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { dimColor: true, children: title }), lines.map((line, i) => {
+                const color = COLOR[line.kind];
+                return (_jsxs(Text, { color: color, dimColor: line.kind === "context", children: [PREFIX[line.kind], line.text] }, i));
+            })] }));
+}
+export function jsonToDiffLines(entry, serverName) {
+    const text = JSON.stringify({ [serverName]: entry }, null, 2);
+    const lines = text.split("\n").slice(1, -1);
+    return lines.map((line) => ({ kind: "add", text: line.replace(/^  /, "") }));
+}

package/dist/ui/components/SectionTitle.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface SectionTitleProps {
+    children: React.ReactNode;
+}
+export declare function SectionTitle({ children, }: SectionTitleProps): React.ReactElement;
+export {};

package/dist/ui/components/SectionTitle.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function SectionTitle({ children, }) {
+    return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: children }) }));
+}

package/dist/ui/hooks/useAsyncEffect.d.ts

@@ -0,0 +1,3 @@
+export declare function useAsyncEffect(fn: (signal: {
+    cancelled: boolean;
+}) => Promise<void>, deps: unknown[], onError?: (err: unknown) => void): void;

package/dist/ui/hooks/useAsyncEffect.js

@@ -0,0 +1,20 @@
+import { useEffect } from 'react';
+export function useAsyncEffect(fn, deps, onError) {
+    useEffect(() => {
+        const signal = { cancelled: false };
+        fn(signal).catch((err) => {
+            if (signal.cancelled)
+                return;
+            if (onError) {
+                onError(err);
+                return;
+            }
+            // Last resort. Step components should pass onError so the error lands
+            // in wizard state rather than scribbling above the Ink frame.
+            process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+        });
+        return () => {
+            signal.cancelled = true;
+        };
+    }, deps);
+}

package/dist/ui/hooks/useResize.d.ts

@@ -0,0 +1,4 @@
+export declare function useResize(): {
+    cols: number;
+    rows: number;
+};

package/dist/ui/hooks/useResize.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from "react";
+export function useResize() {
+    const [size, setSize] = useState(() => ({
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    }));
+    useEffect(() => {
+        const handler = () => {
+            setSize({
+                cols: process.stdout.columns ?? 80,
+                rows: process.stdout.rows ?? 24,
+            });
+        };
+        process.stdout.on("resize", handler);
+        return () => {
+            process.stdout.off("resize", handler);
+        };
+    }, []);
+    return size;
+}

package/dist/ui/hud.d.ts

@@ -0,0 +1,15 @@
+import { type StartTuiResult } from './tui/start-tui.js';
+export type HudScreen = 'menu' | 'init' | 'dash' | 'env';
+export interface HudOptions {
+    initialScreen?: HudScreen;
+    /** Fixed loopback port for the OAuth callback in the `init` flow. */
+    callbackPort?: number;
+}
+export declare function runHud(options?: HudOptions): Promise<StartTuiResult>;
+/**
+ * Run the HUD and, if the user chose to hand off into an agent from the summary
+ * screen, spawn it once the TUI has fully torn down. Exits the process with the
+ * agent's exit code. On launch failure, prints the seed prompt so the user can
+ * paste it manually, then exits non-zero.
+ */
+export declare function runHudThenMaybeLaunch(options?: HudOptions): Promise<void>;

package/dist/ui/hud.js

@@ -0,0 +1,30 @@
+import pc from 'picocolors';
+import { launchAgent } from '../launch/agent.js';
+import { startTUI } from './tui/start-tui.js';
+export async function runHud(options = {}) {
+    return startTUI({
+        initialScreen: options.initialScreen,
+        callbackPort: options.callbackPort,
+    });
+}
+/**
+ * Run the HUD and, if the user chose to hand off into an agent from the summary
+ * screen, spawn it once the TUI has fully torn down. Exits the process with the
+ * agent's exit code. On launch failure, prints the seed prompt so the user can
+ * paste it manually, then exits non-zero.
+ */
+export async function runHudThenMaybeLaunch(options = {}) {
+    const { launch } = await runHud(options);
+    if (!launch)
+        return;
+    try {
+        const code = await launchAgent(launch);
+        process.exit(code);
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\n${pc.red('✗')} Could not launch your agent: ${reason}\n\n` +
+            `Paste this into your agent to get started:\n${launch.prompt}\n`);
+        process.exit(1);
+    }
+}

package/dist/ui/ink-theme.d.ts

@@ -0,0 +1,2 @@
+import { type Theme } from "@inkjs/ui";
+export declare const cyberdeckTheme: Theme;

package/dist/ui/ink-theme.js

@@ -0,0 +1,34 @@
+import { defaultTheme, extendTheme } from "@inkjs/ui";
+import { BRAND_LIME } from "./theme.js";
+const FOCUS = BRAND_LIME.brightest;
+const SELECTED = BRAND_LIME.primary;
+function labelStyle(props) {
+    if (props.isFocused)
+        return { color: FOCUS };
+    if (props.isSelected)
+        return { color: SELECTED };
+    return {};
+}
+export const cyberdeckTheme = extendTheme(defaultTheme, {
+    components: {
+        Select: {
+            styles: {
+                focusIndicator: () => ({ color: FOCUS }),
+                selectedIndicator: () => ({ color: SELECTED }),
+                label: labelStyle,
+            },
+        },
+        MultiSelect: {
+            styles: {
+                focusIndicator: () => ({ color: FOCUS }),
+                selectedIndicator: () => ({ color: SELECTED }),
+                label: labelStyle,
+            },
+        },
+        Spinner: {
+            styles: {
+                frame: () => ({ color: FOCUS }),
+            },
+        },
+    },
+});

package/dist/ui/intro/LogoView.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface LogoProps {
+    /**
+     * Width in terminal cells available to the logo row. Use the shell's
+     * clamped content width — NOT raw terminal columns — so the tail extends
+     * to the shell's right edge instead of overflowing past it and pushing
+     * the STIGG glyphs off the left when the parent centers the row.
+     */
+    containerWidth: number;
+}
+export declare function Logo({ containerWidth }: LogoProps): React.ReactElement;
+export {};

package/dist/ui/intro/LogoView.js

@@ -0,0 +1,226 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useEffect, useRef, useState } from 'react';
+import { BRAND_LIME, Colors, shouldRenderAnimation } from '../theme.js';
+import { BlinkingLabel } from '../tui/primitives/BlinkingLabel.js';
+import { isLogoCellFilled, LOGO_COLS, LOGO_LINES, LOGO_ROWS, logoCellAt } from './logo.js';
+const TERMINAL_LABEL_TEXT = 'terminal';
+const TERMINAL_LABEL_EMOJI = '⚡';
+const TERMINAL_LABEL_WIDTH = 10; // 8 chars + 2-cell emoji
+const LABEL_GAP = 2;
+const TAIL_ORIGIN_COL = LOGO_COLS + LABEL_GAP + TERMINAL_LABEL_WIDTH;
+const RAIN_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*<>?{}[]/=+-*';
+const GRADIENT_PALETTE = [
+    BRAND_LIME.brightest,
+    BRAND_LIME.primary,
+    BRAND_LIME.mid,
+    BRAND_LIME.forest,
+    BRAND_LIME.deep,
+];
+const FRAME_MS = 80;
+const GRADIENT_TICK_MS = 1800;
+const LETTER_ANIMATION_MS = 1400; // duration of the slide-down animation itself
+const LETTER_LOOP_MS = 5000; // total cycle: animate, then idle, then pick next letter
+const RAIN_GREEN = '#39ff66';
+const PARTICLE_CHARS = ['.', "'", '·', '*', '✦', '˖'];
+const PARTICLE_BASE_COLORS = [
+    '#ffffff', // white
+    '#dcdcff', // pale lavender
+    '#cce6ff', // pale blue
+    '#fff5d6', // pale warm
+    '#aaaaaa', // distant gray
+];
+const PARTICLE_COUNT = 18;
+const PARTICLE_MIN_SPEED = 0.3;
+const PARTICLE_MAX_SPEED = 1.4;
+const PARTICLE_MIN_BRIGHTNESS = 0.2;
+const RIGHT_MARGIN = 2;
+const GREEN_FLASH_CHANCE_PER_FRAME = 0.004; // ~1 flash/sec across all particles
+const GREEN_FLASH_MIN_MS = 350;
+const GREEN_FLASH_MAX_MS = 750;
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function spawnParticle(startCol) {
+    return {
+        row: Math.floor(Math.random() * LOGO_ROWS),
+        col: startCol,
+        char: pick(PARTICLE_CHARS),
+        baseColor: pick(PARTICLE_BASE_COLORS),
+        speed: PARTICLE_MIN_SPEED + Math.random() * (PARTICLE_MAX_SPEED - PARTICLE_MIN_SPEED),
+        twinklePhase: Math.random() * Math.PI * 2,
+        twinkleSpeed: 0.05 + Math.random() * 0.15,
+        greenUntil: 0,
+    };
+}
+function scaleColor(hex, factor) {
+    const r = Math.max(0, Math.min(255, Math.round(parseInt(hex.slice(1, 3), 16) * factor)));
+    const g = Math.max(0, Math.min(255, Math.round(parseInt(hex.slice(3, 5), 16) * factor)));
+    const b = Math.max(0, Math.min(255, Math.round(parseInt(hex.slice(5, 7), 16) * factor)));
+    return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
+}
+function randChar() {
+    return RAIN_CHARS.charAt(Math.floor(Math.random() * RAIN_CHARS.length));
+}
+function ansi(hex, ch) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[1;38;2;${r};${g};${b}m${ch}\x1b[0m`;
+}
+/**
+ * Hard-coded column ranges for each letter of STIGG in the ANSI Shadow font.
+ *
+ * Layout (col 0 is a leading space):
+ *   [space] S(1-8) T(9-17) I(18-20) G(21-29) G(30-38)
+ */
+const LETTER_RANGES = [
+    [1, 8], // S
+    [9, 17], // T
+    [18, 20], // I
+    [21, 29], // G
+    [30, 38], // G
+];
+/**
+ * For a cell inside an animating letter, work out what should be displayed
+ * given the animation progress p ∈ [0, 1].
+ *
+ * Tape layout (top → bottom, 3 × LOGO_ROWS tall):
+ *   [ original (the "rebuilt" copy)
+ *     rain     (the matrix-style filler)
+ *     original (the starting copy) ]
+ *
+ * Viewport (LOGO_ROWS tall) starts at the bottom of the tape and scrolls UP
+ * to the top as p goes 0 → 1. So:
+ *   p = 0   → viewport shows the bottom ORIG (letter intact)
+ *   p = 0.5 → viewport shows RAIN (chars decomposed and sliding)
+ *   p = 1   → viewport shows the top ORIG (letter rebuilt, loop ready)
+ */
+function visibleChar(row, col, progress) {
+    const totalScroll = 2 * LOGO_ROWS;
+    const viewportTop = Math.floor((1 - progress) * totalScroll);
+    const tapeIndex = viewportTop + row;
+    if (tapeIndex < LOGO_ROWS) {
+        return { ch: logoCellAt(tapeIndex, col), rain: false };
+    }
+    if (tapeIndex < 2 * LOGO_ROWS) {
+        return { ch: randChar(), rain: true };
+    }
+    const adjusted = tapeIndex - 2 * LOGO_ROWS;
+    return { ch: logoCellAt(adjusted, col), rain: false };
+}
+export function Logo({ containerWidth }) {
+    const animate = shouldRenderAnimation();
+    const startedAtRef = useRef(Date.now());
+    const letterIndexRef = useRef(0);
+    const particlesRef = useRef(null);
+    const [, setTick] = useState(0);
+    if (animate && particlesRef.current === null) {
+        const span = Math.max(20, containerWidth - TAIL_ORIGIN_COL - RIGHT_MARGIN);
+        const initial = [];
+        for (let i = 0; i < PARTICLE_COUNT; i++) {
+            const p = spawnParticle(TAIL_ORIGIN_COL);
+            p.col = TAIL_ORIGIN_COL + Math.random() * span;
+            initial.push(p);
+        }
+        particlesRef.current = initial;
+    }
+    useEffect(() => {
+        if (!animate)
+            return;
+        const id = setInterval(() => {
+            const elapsed = Date.now() - startedAtRef.current;
+            if (elapsed >= LETTER_LOOP_MS && LETTER_RANGES.length > 0) {
+                startedAtRef.current = Date.now();
+                let next = Math.floor(Math.random() * LETTER_RANGES.length);
+                if (LETTER_RANGES.length > 1 && next === letterIndexRef.current) {
+                    next = (next + 1) % LETTER_RANGES.length;
+                }
+                letterIndexRef.current = next;
+            }
+            if (particlesRef.current) {
+                const maxCol = Math.max(TAIL_ORIGIN_COL + 4, containerWidth - RIGHT_MARGIN);
+                const tickNow = Date.now();
+                for (const p of particlesRef.current) {
+                    p.col += p.speed;
+                    p.twinklePhase += p.twinkleSpeed;
+                    if (p.greenUntil <= tickNow && Math.random() < GREEN_FLASH_CHANCE_PER_FRAME) {
+                        p.greenUntil =
+                            tickNow +
+                                GREEN_FLASH_MIN_MS +
+                                Math.random() * (GREEN_FLASH_MAX_MS - GREEN_FLASH_MIN_MS);
+                    }
+                    if (p.col >= maxCol) {
+                        const next = spawnParticle(TAIL_ORIGIN_COL);
+                        p.row = next.row;
+                        p.col = TAIL_ORIGIN_COL;
+                        p.char = next.char;
+                        p.baseColor = next.baseColor;
+                        p.speed = next.speed;
+                        p.twinklePhase = next.twinklePhase;
+                        p.twinkleSpeed = next.twinkleSpeed;
+                        p.greenUntil = next.greenUntil;
+                    }
+                }
+            }
+            setTick((t) => t + 1);
+        }, FRAME_MS);
+        return () => clearInterval(id);
+    }, [animate, containerWidth]);
+    const now = Date.now();
+    const gradientPhase = animate ? Math.floor(now / GRADIENT_TICK_MS) % GRADIENT_PALETTE.length : 0;
+    const activeRange = animate && LETTER_RANGES.length > 0
+        ? LETTER_RANGES[letterIndexRef.current % LETTER_RANGES.length]
+        : null;
+    const animProgress = activeRange != null ? Math.min(1, (now - startedAtRef.current) / LETTER_ANIMATION_MS) : 0;
+    const renderedLines = [];
+    for (let row = 0; row < LOGO_ROWS; row++) {
+        const chars = [...(LOGO_LINES[row] ?? '')];
+        const lineColor = GRADIENT_PALETTE[(gradientPhase + row) % GRADIENT_PALETTE.length];
+        let line = '';
+        for (let col = 0; col < chars.length; col++) {
+            const isInActiveLetter = activeRange !== null && col >= activeRange[0] && col <= activeRange[1];
+            if (isInActiveLetter && isLogoCellFilled(row, col)) {
+                const { ch, rain } = visibleChar(row, col, animProgress);
+                if (ch === ' ') {
+                    line += ' ';
+                }
+                else if (rain) {
+                    line += ansi(RAIN_GREEN, ch);
+                }
+                else {
+                    line += ansi(lineColor, ch);
+                }
+                continue;
+            }
+            const ch = chars[col];
+            if (ch === ' ') {
+                line += ' ';
+            }
+            else {
+                line += ansi(lineColor, ch);
+            }
+        }
+        renderedLines.push(line);
+    }
+    const tailWidth = Math.max(0, containerWidth - TAIL_ORIGIN_COL - RIGHT_MARGIN);
+    const tailCells = Array.from({ length: LOGO_ROWS }, () => Array.from({ length: tailWidth }, () => ' '));
+    if (animate && particlesRef.current && tailWidth > 0) {
+        const renderNow = Date.now();
+        for (const p of particlesRef.current) {
+            const colInTail = Math.floor(p.col) - TAIL_ORIGIN_COL;
+            if (colInTail < 0 || colInTail >= tailWidth)
+                continue;
+            if (p.row < 0 || p.row >= LOGO_ROWS)
+                continue;
+            const pulse = (Math.sin(p.twinklePhase) + 1) / 2;
+            const brightness = PARTICLE_MIN_BRIGHTNESS + (1 - PARTICLE_MIN_BRIGHTNESS) * pulse;
+            const isGreenFlash = p.greenUntil > renderNow;
+            const baseColor = isGreenFlash ? BRAND_LIME.primary : p.baseColor;
+            tailCells[p.row][colInTail] = ansi(scaleColor(baseColor, brightness), p.char);
+        }
+    }
+    const tailRows = tailCells.map((cells) => cells.join(''));
+    const labelRow = LOGO_ROWS - 1; // align label baseline with bottom of STIGG ascii
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexDirection: "column", children: renderedLines.map((line, i) => (_jsx(Text, { children: line }, i))) }), _jsx(Box, { flexDirection: "column", marginLeft: LABEL_GAP, width: TERMINAL_LABEL_WIDTH, children: Array.from({ length: LOGO_ROWS }, (_, i) => i === labelRow ? (_jsxs(Text, { bold: true, color: Colors.accent, children: [TERMINAL_LABEL_TEXT, _jsx(BlinkingLabel, { text: TERMINAL_LABEL_EMOJI, padWidth: 2, bold: true })] }, i)) : (_jsx(Text, { children: ' '.repeat(TERMINAL_LABEL_WIDTH) }, i))) }), _jsx(Box, { flexDirection: "column", children: tailRows.map((line, i) => (_jsx(Text, { children: line }, i))) })] }));
+}

package/dist/ui/intro/MatrixIntro.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface Props {
+    onComplete: () => void;
+}
+export declare function MatrixIntro({ onComplete }: Props): React.ReactElement;
+export {};

package/dist/ui/intro/MatrixIntro.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import pc from "picocolors";
+import { useEffect, useRef, useState } from "react";
+import { BRAND_LIME, shouldRenderAnimation } from "../theme.js";
+import { Logo, computeWaveTail, renderLeafLines } from "./LogoView.js";
+import { isLogoCellFilled, LOGO_COLS, LOGO_ROWS, SUBTITLE, logoCellAt, } from "./logo.js";
+const RAIN_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*<>?{}[]/=+-*";
+const FRAME_MS = 60;
+const TAIL_LEN = 4;
+const MAX_DURATION_MS = 1500;
+function randChar() {
+    return RAIN_CHARS.charAt(Math.floor(Math.random() * RAIN_CHARS.length));
+}
+function brand(hex, ch) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[1;38;2;${r};${g};${b}m${ch}\x1b[0m`;
+}
+export function MatrixIntro({ onComplete }) {
+    const animate = shouldRenderAnimation();
+    const completedRef = useRef(false);
+    const [, setTick] = useState(0);
+    const headsRef = useRef(Array.from({ length: LOGO_COLS }, () => Math.floor(-Math.random() * LOGO_ROWS * 1.8)));
+    const speedRef = useRef(Array.from({ length: LOGO_COLS }, () => 0.6 + Math.random() * 0.6));
+    const complete = () => {
+        if (completedRef.current)
+            return;
+        completedRef.current = true;
+        onComplete();
+    };
+    useEffect(() => {
+        if (!animate) {
+            const id = setTimeout(complete, 250);
+            return () => clearTimeout(id);
+        }
+        const start = Date.now();
+        const id = setInterval(() => {
+            for (let i = 0; i < LOGO_COLS; i++) {
+                headsRef.current[i] += speedRef.current[i];
+            }
+            setTick((t) => t + 1);
+            if (Date.now() - start >= MAX_DURATION_MS) {
+                clearInterval(id);
+                complete();
+            }
+        }, FRAME_MS);
+        return () => clearInterval(id);
+    }, [animate]);
+    if (!animate) {
+        return _jsx(Logo, {});
+    }
+    const lines = [];
+    for (let row = 0; row < LOGO_ROWS; row++) {
+        let line = "";
+        for (let col = 0; col < LOGO_COLS; col++) {
+            const head = headsRef.current[col];
+            const headRow = Math.floor(head);
+            const logoCh = logoCellAt(row, col);
+            const isFilled = isLogoCellFilled(row, col);
+            if (row < headRow - TAIL_LEN) {
+                line += isFilled ? brand(BRAND_LIME.brightest, logoCh) : " ";
+            }
+            else if (row === headRow) {
+                line += brand(BRAND_LIME.primary, randChar());
+            }
+            else if (row < headRow && row >= headRow - TAIL_LEN) {
+                line += pc.green(randChar());
+            }
+            else {
+                line += " ";
+            }
+        }
+        lines.push(line);
+    }
+    const tailRows = computeWaveTail(Date.now());
+    const leafLines = renderLeafLines();
+    return (_jsxs(Box, { flexDirection: "column", children: [leafLines.map((line, i) => (_jsx(Text, { children: line }, `leaf-${i}`))), _jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsx(Text, { dimColor: true, children: SUBTITLE }) }), lines.map((line, i) => (_jsx(Text, { children: line + (tailRows[i] ?? "") }, `cd-${i}`)))] }));
+}

package/dist/ui/intro/logo.d.ts

@@ -0,0 +1,6 @@
+export declare const LOGO_LINES: string[];
+export declare const LOGO_ROWS: number;
+export declare const LOGO_COLS: number;
+export declare const SUBTITLE = "stigg \u00B7";
+export declare function logoCellAt(row: number, col: number): string;
+export declare function isLogoCellFilled(row: number, col: number): boolean;

package/dist/ui/intro/logo.js

@@ -0,0 +1,21 @@
+export const LOGO_LINES = [
+    ' ███████╗████████╗██╗ ██████╗  ██████╗ ',
+    ' ██╔════╝╚══██╔══╝██║██╔════╝ ██╔════╝ ',
+    ' ███████╗   ██║   ██║██║  ███╗██║  ███╗',
+    ' ╚════██║   ██║   ██║██║   ██║██║   ██║',
+    ' ███████║   ██║   ██║╚██████╔╝╚██████╔╝',
+    ' ╚══════╝   ╚═╝   ╚═╝ ╚═════╝  ╚═════╝ ',
+];
+export const LOGO_ROWS = LOGO_LINES.length;
+export const LOGO_COLS = Math.max(...LOGO_LINES.map((l) => [...l].length));
+export const SUBTITLE = 'stigg ·';
+export function logoCellAt(row, col) {
+    const line = LOGO_LINES[row];
+    if (!line)
+        return ' ';
+    const chars = [...line];
+    return chars[col] ?? ' ';
+}
+export function isLogoCellFilled(row, col) {
+    return logoCellAt(row, col) !== ' ';
+}

package/dist/ui/messages.d.ts

@@ -0,0 +1,5 @@
+export declare const messages: {
+    readonly writes: {
+        readonly abortMalformed: (file: string) => string;
+    };
+};

package/dist/ui/messages.js

@@ -0,0 +1,5 @@
+export const messages = {
+    writes: {
+        abortMalformed: (file) => `${file} isn't valid JSON. Fix it manually first, then re-run \`terminal init\`.`,
+    },
+};

package/dist/ui/screens/DashScreen.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface Props {
+    onDone: () => void;
+}
+export declare function DashScreen({ onDone }: Props): React.ReactElement;
+export {};

package/dist/ui/screens/DashScreen.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import open from "open";
+import { useEffect, useState } from "react";
+import { Card } from "../components/Card.js";
+import { Footer } from "../components/Footer.js";
+const DASHBOARD_URL = "https://app.stigg.io";
+export function DashScreen({ onDone }) {
+    const [phase, setPhase] = useState("opening");
+    useEffect(() => {
+        let cancelled = false;
+        open(DASHBOARD_URL)
+            .then(() => {
+            if (!cancelled)
+                setPhase("launched");
+        })
+            .catch(() => {
+            if (!cancelled)
+                setPhase("failed");
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    useInput(() => onDone());
+    return (_jsx(Card, { title: "stigg \u00B7 cyberdeck \u00B7 dash", footer: _jsx(Footer, { hints: [{ key: "any key", label: "back to menu" }] }), children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Opening ", _jsx(Text, { color: "cyan", children: DASHBOARD_URL }), " in your browser\u2026"] }), _jsxs(Box, { marginTop: 1, children: [phase === "opening" && _jsx(Text, { dimColor: true, children: "(launching)" }), phase === "launched" && (_jsx(Text, { color: "green", children: "\u2713 Browser launched." })), phase === "failed" && (_jsx(Text, { color: "yellow", children: "Couldn't open a browser automatically \u2014 open the URL above manually." }))] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "(placeholder \u2014 the real command will surface usage, recent entitlement events, and active subscriptions inline.)" }) })] }) }));
+}

package/dist/ui/screens/DebugScreen.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface Props {
+    onDone: () => void;
+}
+export declare function DebugScreen({ onDone }: Props): React.ReactElement;
+export {};

package/dist/ui/screens/DebugScreen.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { Card } from "../components/Card.js";
+import { Footer } from "../components/Footer.js";
+const SAMPLE_LOGS = [
+    {
+        time: "16:42:13.221",
+        level: "INFO",
+        source: "feature.access",
+        message: "customer=acme_corp has_access=true plan=growth feature=ai_credits",
+    },
+    {
+        time: "16:42:14.034",
+        level: "INFO",
+        source: "usage.report",
+        message: "customer=acme_corp feature=api_calls value=1 source=mcp",
+    },
+    {
+        time: "16:42:18.512",
+        level: "WARN",
+        source: "entitlement.exceeded",
+        message: "customer=acme_corp feature=api_calls usage=1001 limit=1000 reset_at=2026-07-01",
+    },
+    {
+        time: "16:42:21.118",
+        level: "INFO",
+        source: "subscription.updated",
+        message: "customer=acme_corp from=growth to=growth_v2 status=active",
+    },
+];
+const LEVEL_COLOR = {
+    INFO: "green",
+    WARN: "yellow",
+    ERROR: "red",
+};
+export function DebugScreen({ onDone }) {
+    useInput(() => onDone());
+    return (_jsx(Card, { title: "stigg \u00B7 cyberdeck \u00B7 debug", footer: _jsx(Footer, { hints: [{ key: "any key", label: "back to menu" }] }), children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Streaming audit + usage logs (placeholder, sample output)\u2026" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: SAMPLE_LOGS.map((log, i) => (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: log.time }), "  ", _jsx(Text, { color: LEVEL_COLOR[log.level], children: log.level.padEnd(5) }), "  ", _jsx(Text, { color: "cyan", children: log.source.padEnd(22) }), "  ", log.message] }, i))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "(placeholder \u2014 the real command will live-tail audit + usage events with `--since`, `--follow`, `--filter` flags.)" }) })] }) }));
+}

package/dist/ui/screens/InitScreen.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface Props {
+    onDone: () => void;
+}
+export declare function InitScreen({ onDone }: Props): React.ReactElement;
+export {};