@stigg/terminal 0.0.1-alpha

package/dist/ui/tui/screens/DebugScreen.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { Colors } from "../../theme.js";
+import { KeyMatch, } from "../hooks/keyboard-hints-utils.js";
+import { useKeyBindings } from "../hooks/useKeyBindings.js";
+import { PromptLabel } from "../primitives/PromptLabel.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 }) {
+    useKeyBindings("debug", [
+        {
+            match: KeyMatch.AnyChar,
+            label: "any key",
+            action: "menu",
+            handler: onDone,
+        },
+    ]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PromptLabel, { children: "debug \u00B7 audit + usage logs" }), _jsx(Box, { marginTop: 1, 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: Colors.accent, 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/tui/screens/EnvScreen.d.ts

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

package/dist/ui/tui/screens/EnvScreen.js

@@ -0,0 +1,192 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useState } from 'react';
+import { listApiKeys } from '../../../api/client.js';
+import { formatApiKeyShort } from '../../../api/format-key.js';
+import { loadSession } from '../../../auth/storage.js';
+import { getClientById } from '../../../mcp/clients/index.js';
+import { loadSetup, saveSetup } from '../../../setup/storage.js';
+import { useAsyncEffect } from '../../hooks/useAsyncEffect.js';
+import { Colors } from '../../theme.js';
+import { KeyMatch } from '../hooks/keyboard-hints-utils.js';
+import { useKeyBindings } from '../hooks/useKeyBindings.js';
+import { PickerMenu } from '../primitives/PickerMenu.js';
+import { PromptLabel } from '../primitives/PromptLabel.js';
+import { Spinner } from '../primitives/Spinner.js';
+function buildCredentialLabel(key) {
+    return `API key  ${key.name} (${formatApiKeyShort(key)})`;
+}
+function timeAgo(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+    if (days < 1)
+        return 'today';
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}
+async function rewriteMcpForScoped(credential, clientIds) {
+    const results = [];
+    for (const id of clientIds) {
+        const client = getClientById(id);
+        if (!client)
+            continue;
+        if (!(await client.hasExistingEntry()))
+            continue;
+        const r = await client.addServer(credential);
+        if (r.ok)
+            results.push(client.toWriteResult(r));
+    }
+    return results;
+}
+export function EnvScreen({ onDone }) {
+    const [phase, setPhase] = useState({ kind: 'loading' });
+    useAsyncEffect(async (signal) => {
+        const setup = await loadSetup();
+        if (signal.cancelled)
+            return;
+        if (!setup) {
+            setPhase({ kind: 'missing' });
+            return;
+        }
+        if (!setup.environments || setup.environments.length === 0) {
+            setPhase({ kind: 'no-snapshot' });
+            return;
+        }
+        setPhase({ kind: 'env-picker', setup, envs: setup.environments });
+    }, [], (err) => setPhase({
+        kind: 'error',
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    const backBinding = [
+        {
+            match: [KeyMatch.Escape, KeyMatch.Return],
+            label: 'enter',
+            action: 'back',
+            priority: 30,
+            handler: onDone,
+        },
+    ];
+    useKeyBindings('env-back', backBinding, {
+        isActive: phase.kind === 'missing' ||
+            phase.kind === 'no-snapshot' ||
+            phase.kind === 'no-keys' ||
+            phase.kind === 'saved' ||
+            phase.kind === 'error',
+    });
+    if (phase.kind === 'loading') {
+        return _jsx(Spinner, { label: "Loading environments\u2026" });
+    }
+    if (phase.kind === 'keys-loading') {
+        return _jsx(Spinner, { label: `Loading API keys for ${phase.env.name}…` });
+    }
+    if (phase.kind === 'rewriting') {
+        return _jsx(Spinner, { label: `Switching to ${phase.env.name}…` });
+    }
+    if (phase.kind === 'missing') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PromptLabel, { children: "No active Stigg setup" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Run ", _jsx(Text, { color: Colors.accent, children: "terminal init" }), " first to sign in and pick an environment."] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press enter to go back" }) })] }));
+    }
+    if (phase.kind === 'no-snapshot') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PromptLabel, { children: "No environment snapshot" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Your saved setup is from an older version of terminal. Run", ' ', _jsx(Text, { color: Colors.accent, children: "terminal init" }), " once to refresh the environment list."] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press enter to go back" }) })] }));
+    }
+    if (phase.kind === 'error') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: Colors.error, children: "\u2717 Could not switch environment" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: phase.message }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press enter to go back" }) })] }));
+    }
+    if (phase.kind === 'no-keys') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(PromptLabel, { children: ["No API keys in ", phase.env.name] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Create an API key for this environment in the Stigg dashboard (settings \u2192 API keys), then come back and run ", _jsx(Text, { color: Colors.accent, children: "terminal env" }), " again."] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press enter to go back" }) })] }));
+    }
+    if (phase.kind === 'saved') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PromptLabel, { children: "Environment switched" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Active environment is now ", _jsx(Text, { color: Colors.accent, children: phase.env.name }), "."] }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Active key is now ", _jsx(Text, { color: Colors.accent, children: phase.key.name }), " (", formatApiKeyShort(phase.key), ")."] }) }), phase.writes.length > 0 ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: phase.writes.map((w, i) => (_jsxs(Text, { color: Colors.success, children: ['  ✓ ', w.path, w.backedUpTo ? (_jsxs(Text, { dimColor: true, children: ['  (backup: ', w.backedUpTo, ')'] })) : null] }, i))) })) : (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "No MCP entries needed an update." }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press enter to go back" }) })] }));
+    }
+    if (phase.kind === 'env-picker') {
+        const options = phase.envs.map((e) => ({
+            label: e.id === phase.setup.environmentId ? `${e.name}  (current)` : e.name,
+            value: e.id,
+        }));
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(PickerMenu, { id: "env-picker", message: "Switch active environment", options: options, defaultValue: phase.setup.environmentId, onSelect: (v) => {
+                    const env = phase.envs.find((e) => e.id === v);
+                    if (!env)
+                        return;
+                    void (async () => {
+                        setPhase({ kind: 'keys-loading', setup: phase.setup, env });
+                        try {
+                            const session = await loadSession();
+                            if (!session) {
+                                setPhase({
+                                    kind: 'error',
+                                    message: 'Session missing — run reset & init from the menu.',
+                                });
+                                return;
+                            }
+                            const keys = await listApiKeys(session.access_token, phase.setup.accountId, env.id);
+                            if (keys.length === 0) {
+                                setPhase({ kind: 'no-keys', setup: phase.setup, env });
+                                return;
+                            }
+                            setPhase({
+                                kind: 'keys-picker',
+                                setup: phase.setup,
+                                env,
+                                keys,
+                            });
+                        }
+                        catch (err) {
+                            setPhase({
+                                kind: 'error',
+                                message: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                    })();
+                } }) }));
+    }
+    // phase.kind === "keys-picker"
+    const keyOptions = phase.keys.map((k) => ({
+        label: `${k.name.padEnd(20)} ${formatApiKeyShort(k).padEnd(15)}  ${k.keyType.padEnd(7)} ${timeAgo(k.createdAt)}`,
+        value: k.id,
+    }));
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(PickerMenu, { id: "env-key-picker", message: `Pick an API key for ${phase.env.name}`, options: keyOptions, onSelect: (v) => {
+                const key = phase.keys.find((k) => k.id === v);
+                if (!key || !key.value)
+                    return;
+                void (async () => {
+                    setPhase({
+                        kind: 'rewriting',
+                        setup: phase.setup,
+                        env: phase.env,
+                        key,
+                    });
+                    try {
+                        const credential = {
+                            value: key.value,
+                            accountId: phase.setup.accountId,
+                            environmentId: phase.env.id,
+                            environmentSlug: phase.env.slug,
+                        };
+                        const writes = await rewriteMcpForScoped(credential, phase.setup.clients ?? ['claude-code', 'cursor']);
+                        await saveSetup({
+                            ...phase.setup,
+                            environment: phase.env.name,
+                            environmentId: phase.env.id,
+                            credentialLabel: buildCredentialLabel(key),
+                        });
+                        setPhase({
+                            kind: 'saved',
+                            setup: phase.setup,
+                            env: phase.env,
+                            key,
+                            writes,
+                        });
+                    }
+                    catch (err) {
+                        setPhase({
+                            kind: 'error',
+                            message: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                })();
+            } }) }));
+}

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LaunchRequest } from '../../../launch/agent.js';
+interface Props {
+    onDone: () => void;
+    onLaunch: (req: LaunchRequest) => void;
+    callbackPort?: number;
+}
+export declare function InitScreen({ onDone, onLaunch, callbackPort }: Props): React.ReactElement;
+export {};

package/dist/ui/tui/screens/InitScreen.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useMemo, useReducer } from 'react';
+import { getAllClients } from '../../../mcp/clients/index.js';
+import { INITIAL_STATE, wizardReducer } from '../../state.js';
+import { Colors, Icons } from '../../theme.js';
+import { ContextStrip } from '../components/ContextStrip.js';
+import { KeyMatch } from '../hooks/keyboard-hints-utils.js';
+import { useKeyBindings } from '../hooks/useKeyBindings.js';
+import { AccountStep } from '../steps/AccountStep.js';
+import { ApiKeyStep } from '../steps/ApiKeyStep.js';
+import { ClientsStep } from '../steps/ClientsStep.js';
+import { EnvironmentStep } from '../steps/EnvironmentStep.js';
+import { LoginStep } from '../steps/LoginStep.js';
+import { SkillsStep } from '../steps/SkillsStep.js';
+import { SummaryStep } from '../steps/SummaryStep.js';
+import { WritingStep } from '../steps/WritingStep.js';
+function stepPath(state) {
+    const path = ['login'];
+    const hideAccount = state.accounts != null && state.accounts.length === 1;
+    if (!hideAccount)
+        path.push('account');
+    path.push('environment', 'apiKey', 'clients');
+    if ((state.selectedClients?.length ?? 0) > 0)
+        path.push('skills');
+    path.push('writing');
+    path.push('summary');
+    return path;
+}
+function stepNumber(state) {
+    const path = stepPath(state);
+    const idx = path.indexOf(state.step);
+    const total = path.length;
+    return { current: idx >= 0 ? idx + 1 : 1, total };
+}
+function contextEntries(state) {
+    const entries = [];
+    if (state.session) {
+        entries.push({ label: 'user', value: state.session.email });
+    }
+    if (state.account) {
+        entries.push({ label: 'account', value: state.account.displayName });
+    }
+    if (state.environment) {
+        entries.push({ label: 'environment', value: state.environment.name });
+    }
+    if (state.selectedKey) {
+        entries.push({
+            label: 'key',
+            value: `${state.selectedKey.name}  (sk_…${state.selectedKey.lastFour})`,
+        });
+    }
+    return entries;
+}
+function renderStep(state, dispatch, clients, onDone, onLaunch, callbackPort) {
+    switch (state.step) {
+        case 'login':
+            return _jsx(LoginStep, { dispatch: dispatch, callbackPort: callbackPort });
+        case 'account':
+            return _jsx(AccountStep, { state: state, dispatch: dispatch });
+        case 'environment':
+            return _jsx(EnvironmentStep, { state: state, dispatch: dispatch });
+        case 'apiKey':
+            return _jsx(ApiKeyStep, { state: state, dispatch: dispatch });
+        case 'clients':
+            return _jsx(ClientsStep, { state: state, dispatch: dispatch, clients: clients });
+        case 'skills':
+            return _jsx(SkillsStep, { dispatch: dispatch });
+        case 'writing':
+            return _jsx(WritingStep, { state: state, dispatch: dispatch, clients: clients });
+        case 'summary':
+            return _jsx(SummaryStep, { state: state, onDone: onDone, onLaunch: onLaunch });
+    }
+}
+export function InitScreen({ onDone, onLaunch, callbackPort }) {
+    const [state, dispatch] = useReducer(wizardReducer, INITIAL_STATE);
+    const clients = useMemo(() => getAllClients(), []);
+    const canGoBack = state.step !== 'summary' && state.history.length > 0;
+    const escBinding = [
+        {
+            match: KeyMatch.Escape,
+            label: 'esc',
+            action: canGoBack ? 'back' : 'menu',
+            priority: 30,
+            handler: () => {
+                if (state.step === 'summary')
+                    return;
+                if (state.history.length > 0) {
+                    dispatch({ type: 'BACK' });
+                }
+                else {
+                    onDone();
+                }
+            },
+        },
+    ];
+    useKeyBindings('init-host', escBinding);
+    const isSummary = state.step === 'summary';
+    const { current, total } = stepNumber(state);
+    const contextRows = contextEntries(state);
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [!isSummary && (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: Colors.accent, children: "Set up Stigg" }), _jsx(Text, { dimColor: true, children: `  ·  step ${current} of ${total}` })] }), _jsx(Box, { height: 1 }), _jsx(ContextStrip, { entries: contextRows }), contextRows.length > 0 && _jsx(Box, { height: 1 })] })), renderStep(state, dispatch, clients, onDone, onLaunch, callbackPort), state.error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.error, children: [Icons.cross, " ", state.error] }) }))] }));
+}

package/dist/ui/tui/screens/MenuScreen.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export type MenuChoice = 'init' | 'env' | 'dash' | 'exit';
+interface Props {
+    onPick: (choice: MenuChoice) => void;
+}
+export declare function MenuScreen({ onPick }: Props): React.ReactElement;
+export {};

package/dist/ui/tui/screens/MenuScreen.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp } from 'ink';
+import { useEffect, useState } from 'react';
+import { clearSession } from '../../../auth/storage.js';
+import { clearSetup, loadSetup } from '../../../setup/storage.js';
+import { ContextStrip } from '../components/ContextStrip.js';
+import { PickerMenu } from '../primitives/PickerMenu.js';
+function setupEntries(setup) {
+    return [
+        { label: 'user', value: setup.user },
+        {
+            label: 'account',
+            value: setup.account,
+            hint: setup.accountId || undefined,
+        },
+        { label: 'credential', value: setup.credentialLabel },
+        {
+            label: 'environment',
+            value: setup.environment,
+            hint: setup.environmentId || undefined,
+        },
+    ];
+}
+export function MenuScreen({ onPick }) {
+    const { exit } = useApp();
+    const [setup, setSetup] = useState(null);
+    const [loadedSetup, setLoadedSetup] = useState(false);
+    useEffect(() => {
+        let cancelled = false;
+        void loadSetup().then((s) => {
+            if (cancelled)
+                return;
+            setSetup(s);
+            setLoadedSetup(true);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const initOption = setup
+        ? {
+            value: 'init',
+            label: 'reset & init  Clear saved Stigg setup, then re-run init',
+        }
+        : {
+            value: 'init',
+            label: 'init          Set up Stigg — auth, MCP, skills',
+        };
+    const options = [initOption];
+    if (setup) {
+        options.push({
+            value: 'env',
+            label: 'env           Switch the active Stigg environment',
+        });
+    }
+    options.push({
+        value: 'dash',
+        label: 'dash          Open the Stigg dashboard in your browser',
+    }, {
+        value: 'exit',
+        label: 'exit          Quit terminal',
+    });
+    const handleSelect = async (value) => {
+        if (value === 'exit') {
+            exit();
+            return;
+        }
+        if (value === 'init' && setup) {
+            // "reset & init": wipe local credentials + setup before re-entering wizard.
+            try {
+                await clearSession();
+                await clearSetup();
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+            setSetup(null);
+        }
+        onPick(value);
+    };
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", flexGrow: 1, children: [loadedSetup && setup && (_jsx(Box, { marginTop: 1, children: _jsx(ContextStrip, { entries: setupEntries(setup) }) })), _jsx(Box, { marginTop: 3, children: _jsx(Text, { children: "What do you want to do?" }) }), _jsx(Box, { marginTop: 2, children: _jsx(PickerMenu, { id: "menu", numbered: true, options: options, onSelect: (value) => {
+                        void handleSelect(value);
+                    } }) })] }));
+}

package/dist/ui/tui/start-tui.d.ts

@@ -0,0 +1,11 @@
+import type { LaunchRequest } from '../../launch/agent.js';
+import { type AppScreen } from './App.js';
+export interface StartTuiOptions {
+    initialScreen?: AppScreen;
+    callbackPort?: number;
+}
+export interface StartTuiResult {
+    /** Set when the user chose to hand off into an agent from the summary screen. */
+    launch?: LaunchRequest;
+}
+export declare function startTUI(opts?: StartTuiOptions): Promise<StartTuiResult>;

package/dist/ui/tui/start-tui.js

@@ -0,0 +1,72 @@
+import { render } from 'ink';
+import { createElement } from 'react';
+import { SHELL_BG_RGB } from '../theme.js';
+import { App } from './App.js';
+const ENTER_ALT = '\x1b[?1049h';
+const LEAVE_ALT = '\x1b[?1049l';
+const CLEAR = '\x1b[2J';
+const CURSOR_HOME = '\x1b[H';
+const RESET = '\x1b[0m';
+const SHOW_CURSOR = '\x1b[?25h';
+const HIDE_CURSOR = '\x1b[?25l';
+const BG = `\x1b[48;2;${SHELL_BG_RGB[0]};${SHELL_BG_RGB[1]};${SHELL_BG_RGB[2]}m`;
+export async function startTUI(opts = {}) {
+    if (!process.stdin.isTTY) {
+        throw new Error('terminal HUD requires a TTY');
+    }
+    process.stdout.write(ENTER_ALT + BG + CLEAR + CURSOR_HOME + HIDE_CURSOR);
+    let launch;
+    const { waitUntilExit, unmount } = render(createElement(App, {
+        initialScreen: opts.initialScreen ?? 'menu',
+        callbackPort: opts.callbackPort,
+        onLaunchAgent: (req) => {
+            launch = req;
+        },
+    }), { exitOnCtrlC: true });
+    let cleaned = false;
+    // Named handlers so we can detach them on teardown. Detaching is essential
+    // before handing the TTY to a spawned agent: with stdio:'inherit' a Ctrl-C in
+    // the agent is delivered to this process group too, and a lingering SIGINT /
+    // uncaughtException handler would tear the parent down out from under the child.
+    const onExit = () => cleanup();
+    const onSigint = () => {
+        cleanup();
+        process.exit(130);
+    };
+    const onSigterm = () => {
+        cleanup();
+        process.exit(143);
+    };
+    const onUncaught = (err) => {
+        cleanup();
+        console.error(err);
+        process.exit(1);
+    };
+    function cleanup() {
+        if (cleaned)
+            return;
+        cleaned = true;
+        process.off('exit', onExit);
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+        process.off('uncaughtException', onUncaught);
+        try {
+            unmount();
+        }
+        catch {
+            /* ignore */
+        }
+        process.stdout.write(RESET + SHOW_CURSOR + LEAVE_ALT);
+    }
+    process.on('exit', onExit);
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    process.on('uncaughtException', onUncaught);
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        cleanup();
+    }
+    return { launch };
+}

package/dist/ui/tui/steps/AccountStep.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Action, WizardState } from '../../state.js';
+interface Props {
+    state: WizardState;
+    dispatch: React.Dispatch<Action>;
+}
+export declare function AccountStep({ state, dispatch }: Props): React.ReactElement;
+export {};

package/dist/ui/tui/steps/AccountStep.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { useEffect } from 'react';
+import { listAccounts } from '../../../api/client.js';
+import { useAsyncEffect } from '../../hooks/useAsyncEffect.js';
+import { PickerMenu } from '../primitives/PickerMenu.js';
+import { Spinner } from '../primitives/Spinner.js';
+export function AccountStep({ state, dispatch }) {
+    useAsyncEffect(async (signal) => {
+        if (state.accounts || !state.session)
+            return;
+        const accounts = await listAccounts(state.session.accessToken);
+        if (signal.cancelled)
+            return;
+        dispatch({ type: 'ACCOUNTS_LOADED', accounts });
+    }, [state.session?.accessToken], (err) => dispatch({
+        type: 'ERROR',
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    useEffect(() => {
+        if (state.accounts &&
+            state.accounts.length === 1 &&
+            !state.account &&
+            state.step === 'account') {
+            dispatch({ type: 'PICK_ACCOUNT', account: state.accounts[0] });
+        }
+    }, [state.accounts, state.account, state.step, dispatch]);
+    if (!state.accounts) {
+        return _jsx(Spinner, { label: "Loading accounts\u2026" });
+    }
+    if (state.accounts.length === 1) {
+        return _jsx(Spinner, { label: `Using ${state.accounts[0].displayName}…` });
+    }
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(PickerMenu, { id: "account", message: "Which account?", options: state.accounts.map((a) => ({
+                label: a.displayName,
+                value: a.id,
+            })), onSelect: (v) => {
+                const account = state.accounts?.find((a) => a.id === v);
+                if (account)
+                    dispatch({ type: 'PICK_ACCOUNT', account });
+            } }) }));
+}

package/dist/ui/tui/steps/ApiKeyStep.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Action, WizardState } from '../../state.js';
+interface Props {
+    state: WizardState;
+    dispatch: React.Dispatch<Action>;
+}
+export declare function ApiKeyStep({ state, dispatch }: Props): React.ReactElement;
+export {};

package/dist/ui/tui/steps/ApiKeyStep.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { listApiKeys } from '../../../api/client.js';
+import { formatApiKeyShort } from '../../../api/format-key.js';
+import { useAsyncEffect } from '../../hooks/useAsyncEffect.js';
+import { Colors } from '../../theme.js';
+import { PickerMenu } from '../primitives/PickerMenu.js';
+import { PromptLabel } from '../primitives/PromptLabel.js';
+import { Spinner } from '../primitives/Spinner.js';
+function timeAgo(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+    if (days < 1)
+        return 'today';
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}
+export function ApiKeyStep({ state, dispatch }) {
+    useAsyncEffect(async (signal) => {
+        if (state.apiKeys || !state.session || !state.environment || !state.account) {
+            return;
+        }
+        const keys = await listApiKeys(state.session.accessToken, state.account.id, state.environment.id);
+        if (signal.cancelled)
+            return;
+        dispatch({ type: 'KEYS_LOADED', apiKeys: keys });
+    }, [state.session?.accessToken, state.account?.id, state.environment?.id], (err) => dispatch({
+        type: 'ERROR',
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    if (!state.apiKeys) {
+        return _jsx(Spinner, { label: `Loading API keys for ${state.environment?.name}…` });
+    }
+    if (state.apiKeys.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(PromptLabel, { children: ["No API keys in ", state.environment?.name] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Create an API key for this environment in the Stigg dashboard (Settings \u2192 API keys), then press ", _jsx(Text, { color: Colors.accent, children: "esc" }), " to back up and try again."] }) })] }));
+    }
+    const handleSelect = (value) => {
+        const key = state.apiKeys?.find((k) => k.id === value);
+        if (!key || !key.value)
+            return;
+        dispatch({ type: 'PICK_KEY', key, credentialValue: key.value });
+    };
+    const options = state.apiKeys.map((k) => ({
+        label: `${k.name.padEnd(20)} ${formatApiKeyShort(k).padEnd(15)}  ${k.keyType.padEnd(7)} ${timeAgo(k.createdAt)}`,
+        value: k.id,
+    }));
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(PickerMenu, { id: "apikey", message: `Pick an API key for ${state.environment?.name}`, options: options, onSelect: handleSelect }) }));
+}

package/dist/ui/tui/steps/ClientsStep.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type McpClient } from '../../../mcp/clients/index.js';
+import type { Action, WizardState } from '../../state.js';
+interface Props {
+    state: WizardState;
+    dispatch: React.Dispatch<Action>;
+    clients: readonly McpClient[];
+}
+export declare function ClientsStep({ state, dispatch, clients }: Props): React.ReactElement;
+export {};