@visorcraft/idlehands 0.9.1

package/dist/cli/setup.js

@@ -0,0 +1,815 @@
+/**
+ * Interactive first-run setup wizard (full-screen TUI).
+ *
+ * `idlehands setup` walks the user through configuring their endpoint,
+ * model, working directory, and approval mode — then writes config.json.
+ *
+ * Returns 'run' if the user chose to launch Idle Hands, 'exit' otherwise.
+ */
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { defaultConfigPath, ensureConfigDir } from '../config.js';
+import { parseUserIds, validateBotConfig, maskToken, serviceState, hasSystemd, migrateOldServices, installBotService, checkLingerEnabled, } from './bot.js';
+import { HIDE_CURSOR, SHOW_CURSOR, ERASE_LINE, enterFullScreen as enterFullScreenBase, leaveFullScreen as leaveFullScreenBase, clearScreen, } from '../tui/screen.js';
+// ── ANSI codes ───────────────────────────────────────────────────────
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const MAGENTA = '\x1b[35m';
+const RESET = '\x1b[0m';
+// ── ASCII art ────────────────────────────────────────────────────────
+// ANSI Shadow logo (74 chars wide — fits 80-col terminals with indent)
+const LOGO_WIDE = [
+    `${CYAN} ██╗██████╗ ██╗     ███████╗${RESET}    ${BOLD}██╗  ██╗ █████╗ ███╗   ██╗██████╗ ███████╗${RESET}`,
+    `${CYAN} ██║██╔══██╗██║     ██╔════╝${RESET}    ${BOLD}██║  ██║██╔══██╗████╗  ██║██╔══██╗██╔════╝${RESET}`,
+    `${CYAN} ██║██║  ██║██║     █████╗${RESET}      ${BOLD}███████║███████║██╔██╗ ██║██║  ██║███████╗${RESET}`,
+    `${CYAN} ██║██║  ██║██║     ██╔══╝${RESET}      ${BOLD}██╔══██║██╔══██║██║╚██╗██║██║  ██║╚════██║${RESET}`,
+    `${CYAN} ██║██████╔╝███████╗███████╗${RESET}    ${BOLD}██║  ██║██║  ██║██║ ╚████║██████╔╝███████║${RESET}`,
+    `${CYAN} ╚═╝╚═════╝ ╚══════╝╚══════╝${RESET}    ${BOLD}╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═════╝ ╚══════╝${RESET}`,
+];
+// Compact fallback for narrow terminals
+const LOGO_NARROW = [
+    `  ${CYAN}${BOLD}I D L E${RESET}   ${BOLD}H A N D S${RESET}`,
+];
+// ── Screen helpers ───────────────────────────────────────────────────
+let inAltScreen = false;
+function enterFullScreen() {
+    enterFullScreenBase();
+    inAltScreen = true;
+}
+function leaveFullScreen() {
+    leaveFullScreenBase();
+    inAltScreen = false;
+}
+function drawHeader(stepLabel) {
+    clearScreen();
+    const cols = process.stdout.columns ?? 80;
+    const logo = cols >= 78 ? LOGO_WIDE : LOGO_NARROW;
+    console.log();
+    for (const line of logo) {
+        console.log(line);
+    }
+    console.log(`  ${DIM}Local-first coding agent${RESET}`);
+    if (stepLabel) {
+        console.log();
+        const bar = '─'.repeat(Math.min(cols - 4, 60));
+        console.log(`  ${DIM}${bar}${RESET}`);
+        console.log(`  ${BOLD}${stepLabel}${RESET}`);
+    }
+    console.log();
+}
+// ── Input helpers ────────────────────────────────────────────────────
+function info(text) {
+    console.log(`  ${DIM}${text}${RESET}`);
+}
+function success(text) {
+    console.log(`  ${GREEN}✓${RESET} ${text}`);
+}
+function warn(text) {
+    console.log(`  ${YELLOW}⚠${RESET} ${text}`);
+}
+async function ask(rl, prompt, fallback = '') {
+    process.stdout.write(SHOW_CURSOR);
+    const hint = fallback ? ` ${DIM}[${fallback}]${RESET}` : '';
+    const ans = (await rl.question(`  ${prompt}${hint}: `)).trim();
+    return ans || fallback;
+}
+async function pause() {
+    return new Promise((resolve) => {
+        const wasRaw = process.stdin.isRaw;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdout.write(`  ${DIM}Press any key to continue...${RESET}`);
+        const onData = (buf) => {
+            const key = buf.toString();
+            if (key === '\x03') {
+                process.stdin.removeListener('data', onData);
+                process.stdin.setRawMode(wasRaw ?? false);
+                leaveFullScreen();
+                process.exit(0);
+            }
+            process.stdin.removeListener('data', onData);
+            process.stdin.setRawMode(wasRaw ?? false);
+            resolve();
+        };
+        process.stdin.on('data', onData);
+    });
+}
+async function askYN(rl, prompt, defaultYes = true) {
+    process.stdout.write(SHOW_CURSOR);
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    const ans = (await rl.question(`  ${prompt} ${DIM}[${hint}]${RESET}: `)).trim().toLowerCase();
+    if (!ans)
+        return defaultYes;
+    return ans.startsWith('y');
+}
+// ── Arrow-key selector ───────────────────────────────────────────────
+function MOVE_UP(n) {
+    return n > 0 ? `\x1b[${n}A` : '';
+}
+async function selectChoice(choices, defaultValue) {
+    const defaultIdx = Math.max(0, choices.findIndex((c) => c.value === defaultValue));
+    let selected = defaultIdx;
+    function render(firstDraw) {
+        // +2 for the blank line + hint line after choices
+        if (!firstDraw) {
+            process.stdout.write(MOVE_UP(choices.length + 2));
+        }
+        const maxLen = Math.max(...choices.map((c) => c.value.length));
+        for (let i = 0; i < choices.length; i++) {
+            const c = choices[i];
+            const arrow = i === selected ? `${GREEN}❯${RESET}` : ' ';
+            const padded = c.value.padEnd(maxLen);
+            const label = i === selected ? `${BOLD}${padded}${RESET}` : `${DIM}${padded}${RESET}`;
+            const desc = c.desc ? `  ${DIM}${c.desc}${RESET}` : '';
+            process.stdout.write(`${ERASE_LINE}  ${arrow} ${label}${desc}\n`);
+        }
+        process.stdout.write(`${ERASE_LINE}\n`);
+        process.stdout.write(`${ERASE_LINE}  ${DIM}↑/↓ to move, Enter to select${RESET}\n`);
+    }
+    process.stdout.write('\n');
+    process.stdout.write(HIDE_CURSOR);
+    render(true);
+    return new Promise((resolve) => {
+        const wasRaw = process.stdin.isRaw;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const onData = (buf) => {
+            const key = buf.toString();
+            if (key === '\x1b[A' || key === 'k') {
+                selected = (selected - 1 + choices.length) % choices.length;
+                render(false);
+            }
+            else if (key === '\x1b[B' || key === 'j') {
+                selected = (selected + 1) % choices.length;
+                render(false);
+            }
+            else if (key === '\r' || key === '\n') {
+                cleanup();
+                resolve(choices[selected].value);
+            }
+            else if (key === '\x03') {
+                process.stdin.removeListener('data', onData);
+                process.stdin.setRawMode(wasRaw ?? false);
+                leaveFullScreen();
+                process.exit(0);
+            }
+        };
+        function cleanup() {
+            process.stdin.removeListener('data', onData);
+            process.stdin.setRawMode(wasRaw ?? false);
+            process.stdout.write(MOVE_UP(1));
+            process.stdout.write(`${ERASE_LINE}  ${GREEN}✓${RESET} ${choices[selected].value}\n`);
+        }
+        process.stdin.on('data', onData);
+    });
+}
+// ── Runtime detection ────────────────────────────────────────────────
+async function getActiveRuntimeEndpoint() {
+    try {
+        const { loadActiveRuntime } = await import('../runtime/executor.js');
+        const active = await loadActiveRuntime();
+        return active?.endpoint ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Fullscreen TUI runtime add forms ─────────────────────────────────
+async function addHostTUI(rl, existing) {
+    const editing = !!existing;
+    drawHeader(editing ? `Runtime — Edit Host: ${existing.id}` : 'Runtime — Add Host');
+    info('A host is a machine that runs inference.');
+    if (!editing)
+        info('Where is this host?');
+    const currentTransport = existing?.transport === 'ssh' ? 'remote' : 'local';
+    const transportLabel = await selectChoice([
+        { value: 'local', desc: 'This machine' },
+        { value: 'remote', desc: 'A remote server on your network' },
+    ], currentTransport);
+    const transport = (transportLabel === 'remote' ? 'ssh' : 'local');
+    console.log();
+    const id = await ask(rl, 'Host id (e.g. my-gpu-box)', existing?.id ?? '');
+    if (!id)
+        return null;
+    const displayName = await ask(rl, 'Display name', existing?.display_name ?? id);
+    let connection = {};
+    if (transport === 'ssh') {
+        console.log();
+        connection.host = await ask(rl, 'SSH hostname or IP', existing?.connection?.host ?? '');
+        const portStr = await ask(rl, 'SSH port', String(existing?.connection?.port ?? 22));
+        connection.port = Number(portStr) || 22;
+        const user = await ask(rl, 'SSH user', existing?.connection?.user ?? '');
+        if (user)
+            connection.user = user;
+        const keyPath = await ask(rl, 'SSH key path', existing?.connection?.key_path ?? '');
+        if (keyPath)
+            connection.key_path = keyPath;
+    }
+    console.log();
+    const gpuRaw = await ask(rl, 'GPU tags, comma-separated (e.g. RTX 4090)', existing?.capabilities?.gpu?.join(', ') ?? '');
+    const gpu = gpuRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    const backendsRaw = await ask(rl, 'Supported backends, comma-separated (e.g. cuda,rocm,vulkan)', existing?.capabilities?.backends?.join(', ') ?? '');
+    const backends = backendsRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    console.log();
+    const stopCmd = await ask(rl, 'Stop model command', existing?.model_control?.stop_cmd ?? 'pkill -f llama-server || true');
+    const healthCmd = await ask(rl, 'Health check command', existing?.health?.check_cmd ?? 'true');
+    return {
+        id,
+        display_name: displayName,
+        enabled: existing?.enabled ?? true,
+        transport,
+        connection,
+        capabilities: { gpu, backends },
+        health: { check_cmd: healthCmd, timeout_sec: existing?.health?.timeout_sec ?? 5 },
+        model_control: { stop_cmd: stopCmd, cleanup_cmd: existing?.model_control?.cleanup_cmd ?? null },
+    };
+}
+async function addBackendTUI(rl, hosts, existing) {
+    const editing = !!existing;
+    drawHeader(editing ? `Runtime — Edit Backend: ${existing.id}` : 'Runtime — Add Backend');
+    info('A backend is a GPU compute layer for running inference.');
+    console.log();
+    const id = await ask(rl, 'Backend id (e.g. vulkan-radv)', existing?.id ?? '');
+    if (!id)
+        return null;
+    const displayName = await ask(rl, 'Display name', existing?.display_name ?? id);
+    const type = await selectChoice([
+        { value: 'vulkan', desc: 'Vulkan (RADV, etc.)' },
+        { value: 'rocm', desc: 'AMD ROCm' },
+        { value: 'cuda', desc: 'NVIDIA CUDA' },
+        { value: 'metal', desc: 'Apple Metal' },
+        { value: 'cpu', desc: 'CPU only' },
+        { value: 'custom', desc: 'Custom backend' },
+    ], existing?.type ?? 'vulkan');
+    let hostFilters = existing?.host_filters ?? 'any';
+    if (hosts.length > 1) {
+        console.log();
+        const currentFilters = Array.isArray(hostFilters) ? hostFilters.join(', ') : 'any';
+        const filtersRaw = await ask(rl, `Host filter (any, or: ${hosts.join(', ')})`, currentFilters);
+        hostFilters = filtersRaw === 'any' ? 'any' : filtersRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    }
+    console.log();
+    const verifyCmd = await ask(rl, 'Verify command (optional, exit 0 = OK)', existing?.verify_cmd ?? '');
+    console.log();
+    info('Environment variables passed to all models on this backend.');
+    info('Example: VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/radeon_icd.x86_64.json');
+    const existingEnvStr = existing?.env
+        ? Object.entries(existing.env).map(([k, v]) => `${k}=${v}`).join(' ')
+        : '';
+    const envRaw = await ask(rl, 'Environment (KEY=VALUE, space-separated)', existingEnvStr);
+    const env = {};
+    if (envRaw) {
+        for (const pair of envRaw.split(/\s+/)) {
+            const eqIdx = pair.indexOf('=');
+            if (eqIdx > 0)
+                env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+        }
+    }
+    info('Extra CLI args passed to all models on this backend.');
+    info('Example: -fa 1 -mmp 0 -ub 2048 -ctk q4_0 -ctv q4_0 -ngl 0');
+    const existingArgsStr = existing?.args?.join(' ') ?? '';
+    const argsRaw = await ask(rl, 'Extra args (space-separated)', existingArgsStr);
+    const args = argsRaw ? argsRaw.split(/\s+/).filter(Boolean) : [];
+    return {
+        id,
+        display_name: displayName,
+        enabled: existing?.enabled ?? true,
+        type,
+        host_filters: hostFilters,
+        apply_cmd: existing?.apply_cmd ?? null,
+        verify_cmd: verifyCmd || null,
+        rollback_cmd: existing?.rollback_cmd ?? null,
+        ...(Object.keys(env).length > 0 ? { env } : {}),
+        ...(args.length > 0 ? { args } : {}),
+    };
+}
+async function addModelTUI(rl, hosts, backends, existing) {
+    const editing = !!existing;
+    drawHeader(editing ? `Runtime — Edit Model: ${existing.id}` : 'Runtime — Add Model');
+    info('A model is a GGUF (or other format) with launch and probe commands.');
+    info('Template variables: {backend_env}, {source}, {port}, {backend_args}, {host}');
+    console.log();
+    const id = await ask(rl, 'Model id (e.g. qwen3-coder-q4)', existing?.id ?? '');
+    if (!id)
+        return null;
+    const displayName = await ask(rl, 'Display name', existing?.display_name ?? id);
+    const source = await ask(rl, 'Model source (file path or URL)', existing?.source ?? '');
+    console.log();
+    const defaultStart = 'nohup {backend_env} llama-server -m {source} --port {port} --ctx-size 131072 {backend_args} --host 0.0.0.0 > /tmp/llama-server.log 2>&1 &';
+    const startCmd = await ask(rl, 'Start command (runs on host)', existing?.launch?.start_cmd ?? defaultStart);
+    const probeCmd = await ask(rl, 'Probe command (runs on host)', existing?.launch?.probe_cmd ?? 'curl -fsS http://127.0.0.1:{port}/health');
+    const probeTimeoutStr = await ask(rl, 'Probe timeout (seconds)', String(existing?.launch?.probe_timeout_sec ?? 60));
+    const probeTimeout = Math.max(5, Number(probeTimeoutStr) || 60);
+    const portStr = await ask(rl, 'Default port', String(existing?.runtime_defaults?.port ?? 8080));
+    const port = Number(portStr) || 8080;
+    let hostPolicy = existing?.host_policy ?? 'any';
+    let backendPolicy = existing?.backend_policy ?? 'any';
+    if (hosts.length > 1) {
+        console.log();
+        const currentHp = Array.isArray(hostPolicy) ? hostPolicy.join(', ') : 'any';
+        const hp = await ask(rl, `Host policy (any, or: ${hosts.join(', ')})`, currentHp);
+        hostPolicy = hp === 'any' ? 'any' : hp.split(',').map((s) => s.trim()).filter(Boolean);
+    }
+    if (backends.length > 1) {
+        const currentBp = Array.isArray(backendPolicy) ? backendPolicy.join(', ') : 'any';
+        const bp = await ask(rl, `Backend policy (any, or: ${backends.join(', ')})`, currentBp);
+        backendPolicy = bp === 'any' ? 'any' : bp.split(',').map((s) => s.trim()).filter(Boolean);
+    }
+    return {
+        id,
+        display_name: displayName,
+        enabled: existing?.enabled ?? true,
+        source,
+        host_policy: hostPolicy,
+        backend_policy: backendPolicy,
+        launch: {
+            start_cmd: startCmd,
+            probe_cmd: probeCmd,
+            probe_timeout_sec: probeTimeout,
+            probe_interval_ms: existing?.launch?.probe_interval_ms ?? 1000,
+        },
+        runtime_defaults: { port },
+        split_policy: existing?.split_policy ?? null,
+    };
+}
+// ── Main wizard ──────────────────────────────────────────────────────
+// ── Bot setup helper (used by Step 5) ────────────────────────────────
+async function setupBot(rl, target, defaultDir, existing) {
+    const isTg = target === 'Telegram';
+    drawHeader(`Step 5 of 5 — Bot Setup: ${target}`);
+    info(isTg ? 'You need a bot token from @BotFather on Telegram.' : 'You need a bot token from the Discord Developer Portal.');
+    info(`Allowed user IDs restrict who can ${isTg ? 'talk to' : 'use'} the bot.`);
+    console.log();
+    const token = await ask(rl, 'Bot token', existing?.token ?? '');
+    if (!token.trim()) {
+        warn(`No token provided. Skipping ${target}.`);
+        await pause();
+        return existing;
+    }
+    const usersStr = await ask(rl, 'Allowed user IDs (comma-separated)', existing?.allowed_users?.join(', ') ?? '');
+    const users = parseUserIds(usersStr);
+    if (users.length === 0) {
+        warn(`No valid user IDs. Skipping ${target}.`);
+        await pause();
+        return existing;
+    }
+    let guildId;
+    if (!isTg) {
+        const gid = await ask(rl, 'Guild/server ID (blank for DM-only)', existing?.guild_id ?? '');
+        guildId = gid.trim() || undefined;
+    }
+    const dir = await ask(rl, 'Default working directory', existing?.default_dir ?? defaultDir);
+    const cfg = {
+        token: token.trim(), allowed_users: users, default_dir: dir.trim() || defaultDir,
+        ...(guildId ? { guild_id: guildId, allow_guilds: true } : {}),
+    };
+    const err = validateBotConfig(cfg);
+    if (err) {
+        warn(err);
+        await pause();
+        return existing;
+    }
+    return cfg;
+}
+export async function runSetup(existingConfigPath) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.error('Setup requires an interactive terminal.');
+        process.exit(1);
+    }
+    const configPath = existingConfigPath ?? defaultConfigPath();
+    let existingConfig = null;
+    try {
+        const raw = await fs.readFile(configPath, 'utf8');
+        existingConfig = JSON.parse(raw);
+    }
+    catch { /* no config yet */ }
+    const { loadRuntimes, saveRuntimes } = await import('../runtime/store.js');
+    enterFullScreen();
+    const exitHandler = () => { if (inAltScreen)
+        leaveFullScreen(); };
+    process.on('exit', exitHandler);
+    const rl = readline.createInterface({ input, output });
+    let result = 'exit';
+    let runtimeReady = false;
+    try {
+        // ── 1. Runtime (hosts → backends → models → select) ───────────
+        let runtimes;
+        try {
+            runtimes = await loadRuntimes();
+        }
+        catch {
+            runtimes = { schema_version: 1, hosts: [], backends: [], models: [] };
+        }
+        // ── 1a. Hosts ──────────────────────────────────────────────────
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            runtimes = await loadRuntimes().catch(() => runtimes);
+            drawHeader('Step 1 of 6 — Runtime: Hosts');
+            if (runtimes.hosts.length === 0) {
+                info('No hosts configured yet.');
+            }
+            else {
+                for (const h of runtimes.hosts) {
+                    const loc = h.transport === 'ssh'
+                        ? `${h.connection?.user ? h.connection.user + '@' : ''}${h.connection?.host ?? '?'}`
+                        : 'local';
+                    success(`${h.id} ${DIM}(${loc})${RESET}`);
+                }
+            }
+            console.log();
+            const hostChoices = [
+                ...runtimes.hosts.map((h) => ({ value: `edit:${h.id}`, desc: `Edit ${h.display_name}` })),
+                { value: 'add', desc: 'Add a new host' },
+                { value: 'continue', desc: 'Continue →' },
+            ];
+            const hostAction = await selectChoice(hostChoices, runtimes.hosts.length > 0 ? 'continue' : 'add');
+            if (hostAction === 'continue')
+                break;
+            if (hostAction === 'add') {
+                const host = await addHostTUI(rl);
+                if (host) {
+                    runtimes.hosts.push(host);
+                    await saveRuntimes(runtimes);
+                }
+            }
+            else if (hostAction.startsWith('edit:')) {
+                const idx = runtimes.hosts.findIndex((h) => h.id === hostAction.slice(5));
+                if (idx >= 0) {
+                    const updated = await addHostTUI(rl, runtimes.hosts[idx]);
+                    if (updated) {
+                        runtimes.hosts[idx] = updated;
+                        await saveRuntimes(runtimes);
+                    }
+                }
+            }
+        }
+        // ── 1b. Backends ───────────────────────────────────────────────
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            runtimes = await loadRuntimes().catch(() => runtimes);
+            const hostIds = runtimes.hosts.map((h) => h.id);
+            drawHeader('Step 1 of 6 — Runtime: Backends');
+            if (runtimes.backends.length === 0) {
+                info('No backends configured yet.');
+            }
+            else {
+                for (const b of runtimes.backends) {
+                    const envCount = b.env ? Object.keys(b.env).length : 0;
+                    const extra = [b.type, envCount > 0 ? `${envCount} env` : '', b.args?.length ? `${b.args.length} args` : '']
+                        .filter(Boolean).join(', ');
+                    success(`${b.id} ${DIM}(${extra})${RESET}`);
+                }
+            }
+            console.log();
+            const backendChoices = [
+                ...runtimes.backends.map((b) => ({ value: `edit:${b.id}`, desc: `Edit ${b.display_name}` })),
+                { value: 'add', desc: 'Add a new backend' },
+                { value: 'continue', desc: 'Continue →' },
+            ];
+            const backendAction = await selectChoice(backendChoices, runtimes.backends.length > 0 ? 'continue' : 'add');
+            if (backendAction === 'continue')
+                break;
+            if (backendAction === 'add') {
+                const backend = await addBackendTUI(rl, hostIds);
+                if (backend) {
+                    runtimes.backends.push(backend);
+                    await saveRuntimes(runtimes);
+                }
+            }
+            else if (backendAction.startsWith('edit:')) {
+                const idx = runtimes.backends.findIndex((b) => b.id === backendAction.slice(5));
+                if (idx >= 0) {
+                    const updated = await addBackendTUI(rl, hostIds, runtimes.backends[idx]);
+                    if (updated) {
+                        runtimes.backends[idx] = updated;
+                        await saveRuntimes(runtimes);
+                    }
+                }
+            }
+        }
+        // ── 1c. Models ─────────────────────────────────────────────────
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            runtimes = await loadRuntimes().catch(() => runtimes);
+            const hostIds = runtimes.hosts.map((h) => h.id);
+            const backendIds = runtimes.backends.map((b) => b.id);
+            drawHeader('Step 1 of 6 — Runtime: Models');
+            if (runtimes.models.length === 0) {
+                info('No models configured yet.');
+            }
+            else {
+                for (const m of runtimes.models) {
+                    const port = m.runtime_defaults?.port ?? 8080;
+                    success(`${m.id} ${DIM}(port ${port})${RESET}`);
+                }
+            }
+            console.log();
+            const modelChoices = [
+                ...runtimes.models.map((m) => ({ value: `edit:${m.id}`, desc: `Edit ${m.display_name}` })),
+                { value: 'add', desc: 'Add a new model' },
+                { value: 'continue', desc: 'Continue →' },
+            ];
+            const modelAction = await selectChoice(modelChoices, runtimes.models.length > 0 ? 'continue' : 'add');
+            if (modelAction === 'continue')
+                break;
+            if (modelAction === 'add') {
+                const model = await addModelTUI(rl, hostIds, backendIds);
+                if (model) {
+                    runtimes.models.push(model);
+                    await saveRuntimes(runtimes);
+                }
+            }
+            else if (modelAction.startsWith('edit:')) {
+                const idx = runtimes.models.findIndex((m) => m.id === modelAction.slice(5));
+                if (idx >= 0) {
+                    const updated = await addModelTUI(rl, hostIds, backendIds, runtimes.models[idx]);
+                    if (updated) {
+                        runtimes.models[idx] = updated;
+                        await saveRuntimes(runtimes);
+                    }
+                }
+            }
+        }
+        // ── 1d. Select a model ─────────────────────────────────────────
+        runtimes = await loadRuntimes();
+        const enabledModels = runtimes.models.filter((m) => m.enabled);
+        if (enabledModels.length > 0) {
+            drawHeader('Runtime — Start Model');
+            let modelId;
+            if (enabledModels.length === 1) {
+                modelId = enabledModels[0].id;
+                info(`Starting model: ${BOLD}${modelId}${RESET}`);
+            }
+            else {
+                info('Which model should we start?');
+                console.log();
+                modelId = await selectChoice(enabledModels.map((m) => ({ value: m.id, desc: m.display_name })), enabledModels[0].id);
+            }
+            console.log();
+            info('Starting inference server...');
+            console.log();
+            try {
+                const { plan } = await import('../runtime/planner.js');
+                const { execute, loadActiveRuntime } = await import('../runtime/executor.js');
+                const active = await loadActiveRuntime();
+                const planResult = plan({ modelId, mode: 'live' }, runtimes, active);
+                if (!planResult.ok) {
+                    warn(`Plan failed: ${planResult.reason}`);
+                }
+                else if (planResult.reuse) {
+                    success('Runtime already active and healthy.');
+                    runtimeReady = true;
+                }
+                else {
+                    const execResult = await execute(planResult, {
+                        onStep: (step, status, detail) => {
+                            if (status === 'start')
+                                process.stdout.write(`  ${DIM}${step.description}...${RESET}`);
+                            else if (status === 'done')
+                                process.stdout.write(` ${GREEN}✓${RESET}\n`);
+                            else if (status === 'error') {
+                                process.stdout.write(` ${RED}✗${RESET}\n`);
+                                if (detail) {
+                                    for (const line of detail.split('\n').slice(0, 8)) {
+                                        console.log(`    ${RED}${line}${RESET}`);
+                                    }
+                                }
+                            }
+                        },
+                        force: true,
+                    });
+                    if (execResult.ok) {
+                        console.log();
+                        success('Inference server started!');
+                        runtimeReady = true;
+                    }
+                    else {
+                        console.log();
+                        warn(`Failed to start: ${execResult.error || 'unknown error'}`);
+                    }
+                }
+            }
+            catch (e) {
+                warn(`Error: ${e?.message ?? String(e)}`);
+            }
+            console.log();
+            await pause();
+        }
+        // ── 2. Working directory ───────────────────────────────────────
+        drawHeader('Step 2 of 6 — Working Directory');
+        info('Where Idle Hands reads/writes files by default.');
+        info('You can always override with --dir or /dir in a session.');
+        console.log();
+        const currentDir = existingConfig?.dir || process.cwd();
+        const dir = await ask(rl, 'Working directory', currentDir);
+        const resolvedDir = path.resolve(dir.replace(/^~/, process.env.HOME ?? '~'));
+        // ── 3. Approval mode ──────────────────────────────────────────
+        drawHeader('Step 3 of 6 — Approval Mode');
+        info('Controls how much the agent can do without asking you first.');
+        const currentApproval = existingConfig?.approval_mode || 'auto-edit';
+        const approvalMode = await selectChoice([
+            { value: 'plan', desc: 'Read-only. Edits and commands recorded as plans.' },
+            { value: 'default', desc: 'Confirms both file edits and shell commands.' },
+            { value: 'auto-edit', desc: 'File edits automatic. Shell commands need confirmation.' },
+            { value: 'yolo', desc: 'Everything automatic. Trusted codebases only.' },
+        ], currentApproval);
+        // ── 4. Response Timeout ─────────────────────────────────────
+        drawHeader('Step 4 of 6 — Limits');
+        info('How long to wait for model responses and how many tool rounds per prompt.');
+        console.log();
+        const currentResponseTimeout = existingConfig?.response_timeout ?? 600;
+        const responseTimeoutStr = await ask(rl, 'Response timeout in seconds (how long to wait for a reply)', String(currentResponseTimeout));
+        const responseTimeout = Math.max(10, parseInt(responseTimeoutStr, 10) || 300);
+        const currentMaxIter = existingConfig?.max_iterations ?? 100;
+        const maxIterStr = await ask(rl, 'Max tool rounds per prompt (higher = more complex tasks)', String(currentMaxIter));
+        const maxIterations = Math.max(1, parseInt(maxIterStr, 10) || 100);
+        // ── 5. Theme ──────────────────────────────────────────────────
+        drawHeader('Step 5 of 6 — Theme');
+        const currentTheme = existingConfig?.theme || 'default';
+        const theme = await selectChoice([
+            { value: 'default', desc: 'Standard colors' },
+            { value: 'dark', desc: 'High contrast for dark terminals' },
+            { value: 'light', desc: 'For light terminal backgrounds' },
+            { value: 'minimal', desc: 'Stripped-down, less color' },
+            { value: 'hacker', desc: 'Green on black' },
+        ], currentTheme);
+        // ── 5. Bot Setup ──────────────────────────────────────────────
+        const existingTg = existingConfig?.bot?.telegram;
+        const existingDc = existingConfig?.bot?.discord;
+        let botTelegram = (existingTg?.token && existingTg?.allowed_users?.length)
+            ? { token: existingTg.token, allowed_users: existingTg.allowed_users, default_dir: existingTg.default_dir ?? '' }
+            : null;
+        let botDiscord = (existingDc?.token && existingDc?.allowed_users?.length)
+            ? { token: existingDc.token, allowed_users: existingDc.allowed_users, default_dir: existingDc.default_dir ?? '', guild_id: existingDc.guild_id, allow_guilds: existingDc.allow_guilds }
+            : null;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            drawHeader('Step 6 of 6 — Bot Setup');
+            info('Configure chat bot frontends (Telegram, Discord).');
+            console.log();
+            const botChoices = [];
+            if (botTelegram) {
+                botChoices.push({ value: 'edit-tg', desc: `\x1b[32m✓\x1b[0m Telegram (${maskToken(botTelegram.token)}, ${botTelegram.allowed_users.length} user${botTelegram.allowed_users.length === 1 ? '' : 's'}) — Edit` });
+            }
+            else {
+                botChoices.push({ value: 'add-tg', desc: 'Set up Telegram bot' });
+            }
+            if (botDiscord) {
+                botChoices.push({ value: 'edit-dc', desc: `\x1b[32m✓\x1b[0m Discord (${maskToken(botDiscord.token)}, ${botDiscord.allowed_users.length} user${botDiscord.allowed_users.length === 1 ? '' : 's'}) — Edit` });
+            }
+            else {
+                botChoices.push({ value: 'add-dc', desc: 'Set up Discord bot' });
+            }
+            botChoices.push({ value: 'continue', desc: (botTelegram || botDiscord) ? 'Continue →' : 'Skip — no bots' });
+            const botAction = await selectChoice(botChoices, 'continue');
+            if (botAction === 'continue')
+                break;
+            if (botAction === 'add-tg' || botAction === 'edit-tg') {
+                botTelegram = await setupBot(rl, 'Telegram', resolvedDir, botTelegram);
+            }
+            if (botAction === 'add-dc' || botAction === 'edit-dc') {
+                botDiscord = await setupBot(rl, 'Discord', resolvedDir, botDiscord);
+            }
+        }
+        // ── Summary + Write ───────────────────────────────────────────
+        drawHeader('Setup Complete');
+        const activeEndpoint = await getActiveRuntimeEndpoint();
+        const endpoint = activeEndpoint || existingConfig?.endpoint || 'http://127.0.0.1:8080/v1';
+        if (activeEndpoint) {
+            console.log(`  Endpoint:      ${CYAN}${activeEndpoint}${RESET} ${DIM}(from runtime)${RESET}`);
+        }
+        else {
+            console.log(`  Endpoint:      ${DIM}(will be set when a model is started)${RESET}`);
+        }
+        console.log(`  Directory:     ${CYAN}${resolvedDir}${RESET}`);
+        console.log(`  Approval mode: ${CYAN}${approvalMode}${RESET}`);
+        console.log(`  Theme:         ${CYAN}${theme}${RESET}`);
+        if (botTelegram) {
+            console.log(`  Telegram bot:  ${GREEN}✓${RESET} ${DIM}(token: ${maskToken(botTelegram.token)}, ${botTelegram.allowed_users.length} user${botTelegram.allowed_users.length === 1 ? '' : 's'})${RESET}`);
+        }
+        if (botDiscord) {
+            console.log(`  Discord bot:   ${GREEN}✓${RESET} ${DIM}(token: ${maskToken(botDiscord.token)}, ${botDiscord.allowed_users.length} user${botDiscord.allowed_users.length === 1 ? '' : 's'}${botDiscord.guild_id ? `, guild: ${botDiscord.guild_id}` : ''})${RESET}`);
+        }
+        console.log(`  Config file:   ${DIM}${configPath}${RESET}`);
+        console.log();
+        const confirmed = await askYN(rl, 'Write this config?', true);
+        if (!confirmed) {
+            console.log(`\n  ${DIM}Cancelled. No changes written.${RESET}\n`);
+        }
+        else {
+            const finalConfig = existingConfig ? { ...existingConfig } : {};
+            finalConfig.endpoint = endpoint;
+            finalConfig.model = '';
+            finalConfig.dir = resolvedDir;
+            finalConfig.approval_mode = approvalMode;
+            finalConfig.no_confirm = approvalMode === 'yolo';
+            finalConfig.response_timeout = responseTimeout;
+            finalConfig.max_iterations = maxIterations;
+            finalConfig.theme = theme;
+            if (finalConfig.max_tokens === undefined)
+                finalConfig.max_tokens = 16384;
+            if (finalConfig.temperature === undefined)
+                finalConfig.temperature = 0.2;
+            if (finalConfig.timeout === undefined)
+                finalConfig.timeout = 600;
+            if (finalConfig.max_iterations === undefined)
+                finalConfig.max_iterations = 100;
+            if (finalConfig.mode === undefined)
+                finalConfig.mode = 'code';
+            // Bot config
+            if (botTelegram) {
+                finalConfig.bot = finalConfig.bot ?? {};
+                finalConfig.bot.telegram = {
+                    ...(finalConfig.bot.telegram ?? {}),
+                    token: botTelegram.token,
+                    allowed_users: botTelegram.allowed_users,
+                    default_dir: botTelegram.default_dir,
+                };
+            }
+            if (botDiscord) {
+                finalConfig.bot = finalConfig.bot ?? {};
+                finalConfig.bot.discord = {
+                    ...(finalConfig.bot.discord ?? {}),
+                    token: botDiscord.token,
+                    allowed_users: botDiscord.allowed_users,
+                    default_dir: botDiscord.default_dir,
+                    guild_id: botDiscord.guild_id,
+                    allow_guilds: botDiscord.allow_guilds,
+                };
+            }
+            await ensureConfigDir(configPath);
+            await fs.writeFile(configPath, JSON.stringify(finalConfig, null, 2) + '\n', 'utf8');
+            success('Config saved!');
+        }
+        // ── Service installation ─────────────────────────────────────
+        if ((botTelegram || botDiscord) && confirmed && hasSystemd()) {
+            drawHeader('Background Service');
+            const oldMigrated = await migrateOldServices();
+            if (oldMigrated.length > 0)
+                info(`Migrated old service(s): ${oldMigrated.join(', ')}`);
+            const st = serviceState();
+            if (st.active) {
+                info('Bot service is already running.');
+                if (await askYN(rl, 'Restart to apply new config?', true)) {
+                    (await import('node:child_process')).spawnSync('systemctl', ['--user', 'restart', st.name], { stdio: 'pipe' });
+                    success('Service restarted.');
+                }
+            }
+            else {
+                info('Install a background service so your bot(s) run automatically.');
+                info('Uses systemd user service — no sudo required.');
+                console.log();
+                if (await askYN(rl, 'Install and start service?', true)) {
+                    await installBotService();
+                    success('Service installed and started!');
+                    info('View logs: journalctl --user -u idlehands-bot.service -f');
+                    if (!checkLingerEnabled())
+                        warn('Linger not enabled. Run: loginctl enable-linger');
+                }
+            }
+            console.log();
+            await pause();
+        }
+        // ── Final action ──────────────────────────────────────────────
+        const defaultAction = (confirmed && runtimeReady) ? 'run' : 'exit';
+        const action = await selectChoice([
+            { value: 'run', desc: 'Start Idle Hands' },
+            { value: 'exit', desc: 'Return to terminal' },
+        ], defaultAction);
+        result = action;
+    }
+    finally {
+        try {
+            rl.close();
+        }
+        catch { }
+        if (inAltScreen)
+            leaveFullScreen();
+        process.removeListener('exit', exitHandler);
+    }
+    return result;
+}
+// ── Guided runtime onboarding (CLI fallback) ─────────────────────────
+/** Called from index.ts when createSession fails — suggests setup. */
+export async function guidedRuntimeOnboarding() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const { loadRuntimes } = await import('../runtime/store.js');
+    try {
+        const rt = await loadRuntimes();
+        if (rt.hosts.length > 0 && rt.backends.length > 0 && rt.models.length > 0)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    console.log(`\n  ${YELLOW}⚠${RESET} No models found. Run ${BOLD}idlehands setup${RESET} for guided configuration.\n`);
+    return false;
+}
+//# sourceMappingURL=setup.js.map