cvc-tui 0.4.3 → 0.4.5

package/dist/app/createSlashHandler.js

@@ -0,0 +1,101 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { parseSlashCommand } from '../domain/slash.js';
+import { asCommandDispatch, rpcErrorMessage } from '../lib/rpc.js';
+import { findSlashCommand } from './slash/registry.js';
+import { getUiState } from './uiStore.js';
+export function createSlashHandler(ctx) {
+    const { gw } = ctx.gateway;
+    const { catalog } = ctx.local;
+    const { page, send, sys } = ctx.transcript;
+    const handler = (cmd) => {
+        const flight = ++ctx.slashFlightRef.current;
+        const ui = getUiState();
+        const sid = ui.sid;
+        const parsed = parseSlashCommand(cmd);
+        const argTail = parsed.arg ? ` ${parsed.arg}` : '';
+        const stale = () => flight !== ctx.slashFlightRef.current || getUiState().sid !== sid;
+        const guarded = (fn) => (r) => {
+            if (!stale() && r) {
+                fn(r);
+            }
+        };
+        const guardedErr = (e) => {
+            if (!stale()) {
+                sys(`error: ${rpcErrorMessage(e)}`);
+            }
+        };
+        const runCtx = { ...ctx, flight, guarded, guardedErr, sid, stale, ui };
+        const found = findSlashCommand(parsed.name);
+        if (found) {
+            found.run(parsed.arg, runCtx, cmd);
+            return true;
+        }
+        if (catalog?.canon) {
+            const needle = `/${parsed.name}`.toLowerCase();
+            const exact = Object.entries(catalog.canon).find(([alias]) => alias.toLowerCase() === needle)?.[1];
+            if (exact) {
+                if (exact.toLowerCase() !== needle) {
+                    return handler(`${exact}${argTail}`);
+                }
+            }
+            else {
+                const matches = [
+                    ...new Set(Object.entries(catalog.canon)
+                        .filter(([alias]) => alias.startsWith(needle))
+                        .map(([, canon]) => canon))
+                ];
+                if (matches.length === 1 && matches[0].toLowerCase() !== needle) {
+                    return handler(`${matches[0]}${argTail}`);
+                }
+                if (matches.length > 1) {
+                    sys(`ambiguous command: ${matches.slice(0, 6).join(', ')}${matches.length > 6 ? ', …' : ''}`);
+                    return true;
+                }
+            }
+        }
+        gw.request('slash.exec', { command: cmd.slice(1), session_id: sid })
+            .then(r => {
+            if (stale()) {
+                return;
+            }
+            const body = r?.output || `/${parsed.name}: no output`;
+            const text = r?.warning ? `warning: ${r.warning}\n${body}` : body;
+            const long = text.length > 180 || text.split('\n').filter(Boolean).length > 2;
+            long ? page(text, parsed.name[0].toUpperCase() + parsed.name.slice(1)) : sys(text);
+        })
+            .catch(() => {
+            gw.request('command.dispatch', { arg: parsed.arg, name: parsed.name, session_id: sid })
+                .then((raw) => {
+                if (stale()) {
+                    return;
+                }
+                const d = asCommandDispatch(raw);
+                if (!d) {
+                    return sys('error: invalid response: command.dispatch');
+                }
+                if (d.type === 'exec' || d.type === 'plugin') {
+                    return sys(d.output || '(no output)');
+                }
+                if (d.type === 'alias') {
+                    return handler(`/${d.target}${argTail}`);
+                }
+                if (d.type === 'skill') {
+                    sys(`⚡ loading skill: ${d.name}`);
+                    return d.message?.trim() ? send(d.message) : sys(`/${parsed.name}: skill payload missing message`);
+                }
+                if (d.type === 'send') {
+                    if (d.notice?.trim()) {
+                        sys(d.notice);
+                    }
+                    return d.message?.trim() ? send(d.message) : sys(`/${parsed.name}: empty message`);
+                }
+            })
+                .catch(guardedErr);
+        });
+        return true;
+    };
+    return handler;
+}

package/dist/app/delegationStore.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { atom } from 'nanostores';
+const buildState = () => ({
+    maxConcurrentChildren: null,
+    maxSpawnDepth: null,
+    paused: false,
+    updatedAt: null
+});
+export const $delegationState = atom(buildState());
+export const getDelegationState = () => $delegationState.get();
+export const patchDelegationState = (next) => $delegationState.set({ ...$delegationState.get(), ...next });
+export const resetDelegationState = () => $delegationState.set(buildState());
+// ── Overlay accordion open-state ──────────────────────────────────────
+//
+// Lifted out of OverlaySection's local useState so collapse choices
+// survive:
+//   - navigating to a different subagent (Detail remounts)
+//   - switching list ↔ detail mode (Detail unmounts in list mode)
+//   - walking history (←/→)
+// Keyed by section title; missing entries fall back to the section's
+// `defaultOpen` prop.
+export const $overlaySectionsOpen = atom({});
+export const toggleOverlaySection = (title, defaultOpen) => {
+    const state = $overlaySectionsOpen.get();
+    const current = title in state ? state[title] : defaultOpen;
+    $overlaySectionsOpen.set({ ...state, [title]: !current });
+};
+export const getOverlaySectionOpen = (title, defaultOpen) => {
+    const state = $overlaySectionsOpen.get();
+    return title in state ? state[title] : defaultOpen;
+};
+/** Merge a raw RPC response into the store.  Tolerant of partial/omitted fields. */
+export const applyDelegationStatus = (r) => {
+    if (!r) {
+        return;
+    }
+    const patch = { updatedAt: Date.now() };
+    if (typeof r.max_spawn_depth === 'number') {
+        patch.maxSpawnDepth = r.max_spawn_depth;
+    }
+    if (typeof r.max_concurrent_children === 'number') {
+        patch.maxConcurrentChildren = r.max_concurrent_children;
+    }
+    if (typeof r.paused === 'boolean') {
+        patch.paused = r.paused;
+    }
+    patchDelegationState(patch);
+};

package/dist/app/gatewayContext.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { createContext, useContext } from 'react';
+const GatewayContext = createContext(null);
+export function GatewayProvider({ children, value }) {
+    return _jsx(GatewayContext.Provider, { value: value, children: children });
+}
+export function useGateway() {
+    const value = useContext(GatewayContext);
+    if (!value) {
+        throw new Error('GatewayContext missing');
+    }
+    return value;
+}

package/dist/app/historyStore.js

@@ -0,0 +1,123 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// History store — persists user input to ~/.cvc/agent_history.
+// One entry per line, dedup against immediate previous, max 10000.
+import { atom } from 'nanostores';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+export const HISTORY_MAX = 10000;
+function defaultHistoryPath() {
+    return path.join(os.homedir(), '.cvc', 'agent_history');
+}
+let historyPath = defaultHistoryPath();
+/** Used by tests to redirect persistence. */
+export function setHistoryPath(p) {
+    historyPath = p;
+}
+export function getHistoryPath() {
+    return historyPath;
+}
+export const $history = atom([]);
+/**
+ * Cursor pointing into history while user is browsing with Up/Down.
+ * `null` means "not browsing" (i.e. at the live edit buffer).
+ */
+export const $historyCursor = atom(null);
+/** Snapshot of the live buffer so we can restore it after browsing. */
+export const $historyDraft = atom('');
+export function loadHistory() {
+    try {
+        if (!fs.existsSync(historyPath)) {
+            $history.set([]);
+            return [];
+        }
+        const raw = fs.readFileSync(historyPath, 'utf8');
+        // Drop empty trailing line, ignore blank lines.
+        const lines = raw.split('\n').filter((l) => l.length > 0);
+        $history.set(lines);
+        return lines;
+    }
+    catch {
+        $history.set([]);
+        return [];
+    }
+}
+/** Append an entry, dedup-against-previous, cap at HISTORY_MAX, persist. */
+export function pushHistory(entry) {
+    const trimmed = entry.replace(/\s+$/g, '');
+    if (!trimmed)
+        return;
+    const cur = $history.get();
+    if (cur.length > 0 && cur[cur.length - 1] === trimmed) {
+        // Dedup consecutive duplicates without rewriting the file.
+        return;
+    }
+    let next = [...cur, trimmed];
+    if (next.length > HISTORY_MAX) {
+        next = next.slice(next.length - HISTORY_MAX);
+    }
+    $history.set(next);
+    persist();
+}
+export function persist() {
+    try {
+        fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+        fs.writeFileSync(historyPath, $history.get().join('\n') + '\n', 'utf8');
+    }
+    catch {
+        // Best-effort — never crash the UI on history I/O failure.
+    }
+}
+/**
+ * Reverse-incremental search. Returns up to `limit` matches, most-recent-first.
+ */
+export function searchHistory(query, limit = 50) {
+    if (!query)
+        return [];
+    const q = query.toLowerCase();
+    const out = [];
+    const cur = $history.get();
+    for (let i = cur.length - 1; i >= 0 && out.length < limit; i--) {
+        if (cur[i].toLowerCase().includes(q))
+            out.push(cur[i]);
+    }
+    return out;
+}
+/** Move history cursor toward older entries; returns the entry text or null. */
+export function historyPrev(currentDraft) {
+    const h = $history.get();
+    if (h.length === 0)
+        return null;
+    let idx = $historyCursor.get();
+    if (idx === null) {
+        $historyDraft.set(currentDraft);
+        idx = h.length - 1;
+    }
+    else if (idx > 0) {
+        idx -= 1;
+    }
+    $historyCursor.set(idx);
+    return h[idx];
+}
+/** Move history cursor toward newer entries; returns the entry text or null on fall-through. */
+export function historyNext() {
+    const h = $history.get();
+    const idx = $historyCursor.get();
+    if (idx === null)
+        return null;
+    if (idx >= h.length - 1) {
+        // Fell off the end: restore draft.
+        $historyCursor.set(null);
+        return $historyDraft.get();
+    }
+    const next = idx + 1;
+    $historyCursor.set(next);
+    return h[next];
+}
+export function resetHistoryBrowse() {
+    $historyCursor.set(null);
+    $historyDraft.set('');
+}

package/dist/app/inputBuffer.js

@@ -0,0 +1,120 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// Pure text-buffer helpers for the multi-line composer.
+// Kept side-effect-free so they can be unit-tested without Ink/React.
+export function emptyBuffer() {
+    return { text: '', cursor: 0 };
+}
+export function insert(buf, s) {
+    const text = buf.text.slice(0, buf.cursor) + s + buf.text.slice(buf.cursor);
+    return { text, cursor: buf.cursor + s.length };
+}
+export function backspace(buf) {
+    if (buf.cursor === 0)
+        return buf;
+    const text = buf.text.slice(0, buf.cursor - 1) + buf.text.slice(buf.cursor);
+    return { text, cursor: buf.cursor - 1 };
+}
+export function del(buf) {
+    if (buf.cursor >= buf.text.length)
+        return buf;
+    const text = buf.text.slice(0, buf.cursor) + buf.text.slice(buf.cursor + 1);
+    return { text, cursor: buf.cursor };
+}
+export function moveLeft(buf) {
+    return { ...buf, cursor: Math.max(0, buf.cursor - 1) };
+}
+export function moveRight(buf) {
+    return { ...buf, cursor: Math.min(buf.text.length, buf.cursor + 1) };
+}
+export function moveHome(buf) {
+    // Move to start of current logical line.
+    const before = buf.text.slice(0, buf.cursor);
+    const nl = before.lastIndexOf('\n');
+    return { ...buf, cursor: nl < 0 ? 0 : nl + 1 };
+}
+export function moveEnd(buf) {
+    const after = buf.text.slice(buf.cursor);
+    const nl = after.indexOf('\n');
+    return { ...buf, cursor: nl < 0 ? buf.text.length : buf.cursor + nl };
+}
+/** Lines split on \n (keeps empty trailing line). */
+export function lines(text) {
+    return text.split('\n');
+}
+/** Convert cursor offset to {row, col} on logical lines. */
+export function cursorRowCol(buf) {
+    const before = buf.text.slice(0, buf.cursor);
+    const ls = before.split('\n');
+    return { row: ls.length - 1, col: ls[ls.length - 1].length };
+}
+/** Move cursor up one logical line, preserving column when possible. */
+export function moveUp(buf) {
+    const { row, col } = cursorRowCol(buf);
+    if (row === 0)
+        return buf;
+    const ls = lines(buf.text);
+    const targetCol = Math.min(col, ls[row - 1].length);
+    // Compute new offset: sum of lines 0..row-2 + their newlines + targetCol.
+    let off = 0;
+    for (let i = 0; i < row - 1; i++)
+        off += ls[i].length + 1;
+    off += targetCol;
+    return { ...buf, cursor: off };
+}
+export function moveDown(buf) {
+    const { row, col } = cursorRowCol(buf);
+    const ls = lines(buf.text);
+    if (row >= ls.length - 1)
+        return buf;
+    const targetCol = Math.min(col, ls[row + 1].length);
+    let off = 0;
+    for (let i = 0; i < row + 1; i++)
+        off += ls[i].length + 1;
+    off += targetCol;
+    return { ...buf, cursor: off };
+}
+/** True when the cursor is on the first logical line. */
+export function onFirstLine(buf) {
+    return cursorRowCol(buf).row === 0;
+}
+/** True when the cursor is on the last logical line. */
+export function onLastLine(buf) {
+    return cursorRowCol(buf).row === lines(buf.text).length - 1;
+}
+/**
+ * Word-wrap a logical line into visual rows of width `cols`.
+ * Returns array of strings (each ≤ cols chars). Tries to break at spaces.
+ */
+export function wrapLine(line, cols) {
+    if (cols <= 0)
+        return [line];
+    if (line.length <= cols)
+        return [line];
+    const out = [];
+    let rest = line;
+    while (rest.length > cols) {
+        let cut = cols;
+        // Look for a space to break at, within a small window.
+        const window = rest.slice(0, cols);
+        const lastSpace = window.lastIndexOf(' ');
+        if (lastSpace > Math.floor(cols * 0.5)) {
+            cut = lastSpace + 1;
+        }
+        out.push(rest.slice(0, cut));
+        rest = rest.slice(cut);
+    }
+    if (rest.length)
+        out.push(rest);
+    return out;
+}
+/** Wrap the full text, returning visual rows. */
+export function wrapText(text, cols) {
+    return text.split('\n').flatMap((l) => (l.length === 0 ? [''] : wrapLine(l, cols)));
+}
+/** Stats for the dim status footer. */
+export function bufferStats(text) {
+    return { chars: text.length, lineCount: text.split('\n').length };
+}

package/dist/app/inputSelectionStore.js

@@ -0,0 +1,8 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { atom } from 'nanostores';
+export const $inputSelection = atom(null);
+export const setInputSelection = (next) => $inputSelection.set(next);
+export const getInputSelection = () => $inputSelection.get();

package/dist/app/inputStore.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// Composer state — kept in a nanostore so any subsystem can read/write
+// without prop-drilling. Holds the active text buffer + completion state.
+import { atom } from 'nanostores';
+import { emptyBuffer } from './inputBuffer.js';
+export const $buffer = atom(emptyBuffer());
+export const $completion = atom({
+    active: false,
+    prefix: '',
+    candidates: [],
+    index: 0,
+    start: 0,
+});
+export function resetCompletion() {
+    $completion.set({ active: false, prefix: '', candidates: [], index: 0, start: 0 });
+}
+export function setBuffer(b) {
+    $buffer.set(b);
+    // Any non-Tab edit should reset the completion cycle.
+    resetCompletion();
+}
+/** Direct setter that does not reset completion (used by the cycle itself). */
+export function setBufferRaw(b) {
+    $buffer.set(b);
+}

package/dist/app/interfaces.js

@@ -0,0 +1,6 @@
+// Single source of truth for indicator style names.  Union type is
+// derived from this tuple so adding/removing a style only touches one
+// line — `useConfigSync` (validation) and `session.ts` (slash arg
+// validation + usage hint) both import it.
+export const INDICATOR_STYLES = ['ascii', 'emoji', 'kaomoji', 'unicode'];
+export const DEFAULT_INDICATOR_STYLE = 'kaomoji';

package/dist/app/overlayStore.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { atom, computed } from 'nanostores';
+const buildOverlayState = () => ({
+    agents: false,
+    agentsInitialHistoryIndex: 0,
+    approval: null,
+    clarify: null,
+    confirm: null,
+    modelPicker: false,
+    pager: null,
+    picker: false,
+    secret: null,
+    skillsHub: false,
+    sudo: null
+});
+export const $overlayState = atom(buildOverlayState());
+export const $isBlocked = computed($overlayState, ({ agents, approval, clarify, confirm, modelPicker, pager, picker, secret, skillsHub, sudo }) => Boolean(agents || approval || clarify || confirm || modelPicker || pager || picker || secret || skillsHub || sudo));
+export const getOverlayState = () => $overlayState.get();
+export const patchOverlayState = (next) => $overlayState.set(typeof next === 'function' ? next($overlayState.get()) : { ...$overlayState.get(), ...next });
+/** Full reset — used by session/turn teardown and tests. */
+export const resetOverlayState = () => $overlayState.set(buildOverlayState());
+/**
+ * Soft reset: drop FLOW-scoped overlays (approval / clarify / confirm / sudo
+ * / secret / pager) but PRESERVE user-toggled ones — agents dashboard, model
+ * picker, skills hub, session picker.  Those are opened deliberately and
+ * shouldn't vanish when a turn ends.  Called from turnController.idle() on
+ * every turn completion / interrupt; the old "reset everything" behaviour
+ * silently closed /agents the moment delegation finished.
+ */
+export const resetFlowOverlays = () => $overlayState.set({
+    ...buildOverlayState(),
+    agents: $overlayState.get().agents,
+    agentsInitialHistoryIndex: $overlayState.get().agentsInitialHistoryIndex,
+    modelPicker: $overlayState.get().modelPicker,
+    picker: $overlayState.get().picker,
+    skillsHub: $overlayState.get().skillsHub
+});

package/dist/app/promptStore.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// Prompt store — confirmation + secret prompts requested by any subsystem.
+// The composer hides while a prompt is active; the prompt overlay owns input.
+import { atom } from 'nanostores';
+export const $prompt = atom(null);
+let counter = 0;
+function nextId() {
+    counter += 1;
+    return `prompt_${Date.now()}_${counter}`;
+}
+/** Request a yes/no confirmation. Resolves with `true`/`false`, or `null` on Esc. */
+export function requestConfirm(prompt, opts = {}) {
+    return new Promise((resolve) => {
+        $prompt.set({
+            id: nextId(),
+            kind: 'confirm',
+            prompt,
+            destructive: opts.destructive,
+            resolve: (v) => resolve(v),
+        });
+    });
+}
+/** Request a secret. Resolves with the entered string, or `null` on Esc. */
+export function requestSecret(prompt, opts = {}) {
+    return new Promise((resolve) => {
+        $prompt.set({
+            id: nextId(),
+            kind: 'secret',
+            prompt,
+            mask: opts.mask !== false,
+            resolve: (v) => resolve(v),
+        });
+    });
+}
+export function resolveActivePrompt(value) {
+    const cur = $prompt.get();
+    if (!cur)
+        return;
+    cur.resolve(value);
+    $prompt.set(null);
+}

package/dist/app/queueStore.js

@@ -0,0 +1,25 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// Queue store — submissions made while a turn is streaming are queued
+// and flushed when the active turn ends. Composer shows `[queued: N]`.
+import { atom } from 'nanostores';
+export const $queue = atom([]);
+export function enqueue(text) {
+    const t = text.replace(/\s+$/g, '');
+    if (!t)
+        return;
+    $queue.set([...$queue.get(), t]);
+}
+export function dequeueAll() {
+    const cur = $queue.get();
+    $queue.set([]);
+    return cur;
+}
+export function queueLength() {
+    return $queue.get().length;
+}
+export function clearQueue() {
+    $queue.set([]);
+}

package/dist/app/scroll.js

@@ -0,0 +1,44 @@
+function scrollBoundsForDelta(s, cur, delta) {
+    const viewport = Math.max(0, s.getViewportHeight());
+    const cachedHeight = Math.max(viewport, s.getScrollHeight());
+    let max = Math.max(0, cachedHeight - viewport);
+    // getScrollHeight() is render-time cached. After the streaming tail is
+    // committed into virtual history, the Yoga height can be fresher than the
+    // cached value; if we clamp only against the cached fake bottom, wheel-down
+    // becomes a no-op and no render is scheduled to reveal the real tail.
+    if (delta > 0 && cur + delta >= max - 1) {
+        const freshHeight = Math.max(viewport, s.getFreshScrollHeight());
+        max = Math.max(0, freshHeight - viewport);
+    }
+    return { max, viewport };
+}
+export function scrollWithSelectionBy(delta, { scrollRef, selection }) {
+    const s = scrollRef.current;
+    if (!s) {
+        return;
+    }
+    const cur = s.getScrollTop() + s.getPendingDelta();
+    const { max, viewport } = scrollBoundsForDelta(s, cur, delta);
+    const actual = Math.max(0, Math.min(max, cur + delta)) - cur;
+    if (actual === 0) {
+        return;
+    }
+    const sel = selection.getState();
+    const top = s.getViewportTop();
+    const bottom = top + viewport - 1;
+    if (sel?.anchor &&
+        sel.focus &&
+        sel.anchor.row >= top &&
+        sel.anchor.row <= bottom &&
+        (sel.isDragging || (sel.focus.row >= top && sel.focus.row <= bottom))) {
+        const shift = sel.isDragging ? selection.shiftAnchor : selection.shiftSelection;
+        if (actual > 0) {
+            selection.captureScrolledRows(top, top + actual - 1, 'above');
+        }
+        else {
+            selection.captureScrolledRows(bottom + actual + 1, bottom, 'below');
+        }
+        shift(-actual, top, bottom);
+    }
+    s.scrollBy(actual);
+}

package/dist/app/setupHandoff.js

@@ -0,0 +1,28 @@
+import { patchUiState } from './uiStore.js';
+export async function runExternalSetup({ args, ctx, done, launcher, suspend }) {
+    const { gateway, session, transcript } = ctx;
+    transcript.sys(`launching \`hermes ${args.join(' ')}\`…`);
+    patchUiState({ status: 'setup running…' });
+    let result = { code: null };
+    await suspend(async () => {
+        result = await launcher(args);
+    });
+    if (result.error) {
+        transcript.sys(`error launching hermes: ${result.error}`);
+        patchUiState({ status: 'setup required' });
+        return;
+    }
+    if (result.code !== 0) {
+        transcript.sys(`hermes ${args[0]} exited with code ${result.code}`);
+        patchUiState({ status: 'setup required' });
+        return;
+    }
+    const setup = await gateway.rpc('setup.status', {});
+    if (setup?.provider_configured === false) {
+        transcript.sys('still no provider configured');
+        patchUiState({ status: 'setup required' });
+        return;
+    }
+    transcript.sys(done);
+    session.newSession();
+}