@leg3ndy/otto-bridge 0.9.2 → 1.0.1

package/dist/cli_terminal.js

@@ -0,0 +1,668 @@
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { defaultDeviceName, getBridgeConfigPath, loadBridgeConfig, resolveApiBaseUrl, resolveExecutorConfig, } from "./config.js";
+import { streamDeviceCliChat, } from "./chat_cli_client.js";
+import { formatManagedBridgeExtensionStatus, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
+import { pairDevice } from "./pairing.js";
+import { BridgeRuntime, } from "./runtime.js";
+import { cancelRuntimeCliJob, confirmRuntimeCliJob, getRuntimeCliJob, } from "./runtime_cli_client.js";
+import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_API_BASE_URL, } from "./types.js";
+const ANSI = {
+    reset: "\u001b[0m",
+    dim: "\u001b[2m",
+    bold: "\u001b[1m",
+    coral: "\u001b[38;5;216m",
+    blue: "\u001b[38;5;111m",
+    teal: "\u001b[38;5;80m",
+    amber: "\u001b[38;5;221m",
+    red: "\u001b[38;5;203m",
+    green: "\u001b[38;5;114m",
+    white: "\u001b[38;5;255m",
+};
+const OTTOAI_BANNER = [
+    " ██████╗ ████████╗████████╗ ██████╗      █████╗ ██╗",
+    "██╔═══██╗╚══██╔══╝╚══██╔══╝██╔═══██╗    ██╔══██╗██║",
+    "██║   ██║   ██║      ██║   ██║   ██║    ███████║██║",
+    "██║   ██║   ██║      ██║   ██║   ██║    ██╔══██║██║",
+    "╚██████╔╝   ██║      ██║   ╚██████╔╝    ██║  ██║██║",
+    " ╚═════╝    ╚═╝      ╚═╝    ╚═════╝     ╚═╝  ╚═╝╚═╝",
+];
+class CliRuntimeSession {
+    config;
+    runtime = null;
+    runtimeTask = null;
+    status = "offline";
+    detail = "Aguardando pairing.";
+    lastError = null;
+    constructor(config) {
+        this.config = config;
+    }
+    handleRuntimeEvent(event) {
+        switch (event.type) {
+            case "starting":
+                this.status = "starting";
+                this.detail = "Conectando o runtime local do Otto Bridge...";
+                return;
+            case "connected":
+                this.status = "online";
+                this.detail = "Runtime conectado ao backend e pronto para handoff local.";
+                return;
+            case "server_hello":
+                this.status = "online";
+                this.detail = "Handshake com o backend concluído.";
+                return;
+            case "reconnecting":
+                this.status = "reconnecting";
+                this.detail = `Reconectando em ${Math.max(1, Math.round(event.delayMs / 1000))}s...`;
+                return;
+            case "socket_error":
+                this.status = "error";
+                this.lastError = event.message;
+                this.detail = truncate(event.message || "Falha de conexão do runtime.", 160);
+                return;
+            case "socket_closed":
+                if (this.status !== "error") {
+                    this.status = "offline";
+                    this.detail = `Socket fechado (code=${event.code}).`;
+                }
+                return;
+            case "update_required":
+            case "update_available":
+                this.detail = truncate(event.message || this.detail, 160);
+                return;
+            default:
+                return;
+        }
+    }
+    async ensureStarted() {
+        if (this.runtimeTask) {
+            return;
+        }
+        this.status = "starting";
+        this.detail = "Subindo runtime local do Otto Bridge...";
+        this.runtime = new BridgeRuntime(this.config, undefined, {
+            logger: {
+                info: () => undefined,
+                warn: () => undefined,
+                error: () => undefined,
+                event: (event) => {
+                    this.handleRuntimeEvent(event);
+                },
+            },
+        });
+        this.runtimeTask = this.runtime.start().catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            this.status = "error";
+            this.lastError = detail;
+            this.detail = truncate(detail || "Falha ao iniciar o runtime.", 160);
+        });
+        await delay(350);
+    }
+    async replaceConfig(nextConfig) {
+        await this.stop();
+        this.config = nextConfig;
+        this.status = "offline";
+        this.detail = "Reinicializando runtime com o novo pairing...";
+        this.lastError = null;
+        await this.ensureStarted();
+    }
+    async stop() {
+        const runtime = this.runtime;
+        const runtimeTask = this.runtimeTask;
+        this.runtime = null;
+        this.runtimeTask = null;
+        if (runtime) {
+            await runtime.stop().catch(() => undefined);
+        }
+        if (runtimeTask) {
+            await runtimeTask.catch(() => undefined);
+        }
+        if (this.status !== "error") {
+            this.status = "offline";
+            this.detail = "Runtime local desligado.";
+        }
+    }
+    getStatusLabel() {
+        if (this.status === "online") {
+            return "online";
+        }
+        if (this.status === "starting") {
+            return "starting";
+        }
+        if (this.status === "reconnecting") {
+            return "reconnecting";
+        }
+        if (this.status === "error") {
+            return "error";
+        }
+        return "offline";
+    }
+    getStatusDetail() {
+        return this.detail;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+}
+function style(text, color, enabled = true) {
+    if (!enabled) {
+        return text;
+    }
+    return `${color}${text}${ANSI.reset}`;
+}
+function supportsAnsi() {
+    return Boolean(output.isTTY);
+}
+function renderBanner() {
+    const enabled = supportsAnsi();
+    const lines = OTTOAI_BANNER.map((line) => style(line, ANSI.coral, enabled));
+    const title = `${BRIDGE_PACKAGE_NAME} v${BRIDGE_VERSION}`;
+    const subtitle = "Terminal bridge, pairing wizard and local Otto console";
+    return [
+        lines.join("\n"),
+        "",
+        `${style("OTTO BRIDGE", ANSI.blue, enabled)} ${style(title, ANSI.white, enabled)}`,
+        `${style(subtitle, ANSI.dim, enabled)}`,
+    ].join("\n");
+}
+function printSection(title) {
+    const enabled = supportsAnsi();
+    console.log(`\n${style(title, ANSI.blue, enabled)}`);
+}
+function printMuted(message) {
+    console.log(style(message, ANSI.dim, supportsAnsi()));
+}
+function printSuccess(message) {
+    console.log(style(message, ANSI.green, supportsAnsi()));
+}
+function printWarning(message) {
+    console.log(style(message, ANSI.amber, supportsAnsi()));
+}
+function printError(message) {
+    console.log(style(message, ANSI.red, supportsAnsi()));
+}
+function normalizeText(value) {
+    return String(value || "").trim();
+}
+function truncate(text, max = 180) {
+    const value = normalizeText(text);
+    if (value.length <= max) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function createPromptInterface() {
+    return createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+}
+async function ask(rl, label, options) {
+    const defaultValue = normalizeText(options?.defaultValue);
+    const suffix = defaultValue ? ` ${style(`[${defaultValue}]`, ANSI.dim, supportsAnsi())}` : "";
+    const answer = normalizeText(await rl.question(`${style("›", ANSI.coral, supportsAnsi())} ${label}${suffix}: `));
+    if (answer) {
+        return answer;
+    }
+    if (defaultValue) {
+        return defaultValue;
+    }
+    if (options?.allowEmpty) {
+        return "";
+    }
+    return await ask(rl, label, options);
+}
+async function askYesNo(rl, question, defaultValue = true) {
+    const answer = normalizeText(await rl.question(`${style("?", ANSI.blue, supportsAnsi())} ${question} ${style(defaultValue ? "[Y/n]" : "[y/N]", ANSI.dim, supportsAnsi())}: `)).toLowerCase();
+    if (!answer) {
+        return defaultValue;
+    }
+    return ["y", "yes", "s", "sim"].includes(answer);
+}
+async function pauseForEnter(rl, message = "Pressione Enter para continuar") {
+    await rl.question(`${style("↵", ANSI.dim, supportsAnsi())} ${message}`);
+}
+async function chooseExecutor(rl, current) {
+    const defaultType = current?.type || resolveExecutorConfig().type;
+    console.log([
+        `${style("1.", ANSI.coral, supportsAnsi())} native-macos ${style("(Mac real, runtime local)", ANSI.dim, supportsAnsi())}`,
+        `${style("2.", ANSI.coral, supportsAnsi())} mock ${style("(ambiente de teste)", ANSI.dim, supportsAnsi())}`,
+    ].join("\n"));
+    const selection = await ask(rl, "Executor", {
+        defaultValue: defaultType === "mock" ? "2" : "1",
+    });
+    if (selection === "2" || selection.toLowerCase() === "mock") {
+        return { type: "mock" };
+    }
+    return { type: "native-macos" };
+}
+function extractBridgeHandoffSummary(payload) {
+    const narrationContext = payload.narration_context && typeof payload.narration_context === "object"
+        ? payload.narration_context
+        : {};
+    const plan = payload.plan && typeof payload.plan === "object"
+        ? payload.plan
+        : {};
+    const job = payload.job && typeof payload.job === "object"
+        ? payload.job
+        : {};
+    return normalizeText(narrationContext.summary
+        || plan.summary
+        || plan.assistant_message
+        || extractJobSummary(job));
+}
+function extractJobStepId(job) {
+    return normalizeText(job.runtime_current_step_id
+        || (job.payload && typeof job.payload === "object" ? job.payload.runtime_current_step_id : "")
+        || ((job.payload && typeof job.payload === "object")
+            ? (job.payload.runtime_state?.current_step_id)
+            : "")
+        || "");
+}
+function extractJobSummary(job) {
+    const payload = job.payload && typeof job.payload === "object"
+        ? job.payload
+        : {};
+    const result = job.result && typeof job.result === "object"
+        ? job.result
+        : {};
+    const outcome = result.outcome && typeof result.outcome === "object"
+        ? result.outcome
+        : {};
+    return normalizeText(result.summary
+        || outcome.summary
+        || payload.kernel_intro_summary
+        || payload.kernel_confirmation_summary
+        || payload.planner_summary);
+}
+function extractConfirmationPrompt(job) {
+    const confirmationContext = job.confirmation_context && typeof job.confirmation_context === "object"
+        ? job.confirmation_context
+        : {};
+    const payload = job.payload && typeof job.payload === "object"
+        ? job.payload
+        : {};
+    return normalizeText(confirmationContext.message
+        || payload.kernel_confirmation_summary
+        || payload.confirmation_message) || "O Otto está aguardando sua confirmação para continuar.";
+}
+function renderStatusOverview(config, runtimeSession) {
+    return [
+        `${style("Device", ANSI.blue, supportsAnsi())}: ${config.deviceName}`,
+        `${style("Device ID", ANSI.blue, supportsAnsi())}: ${config.deviceId}`,
+        `${style("API", ANSI.blue, supportsAnsi())}: ${config.apiBaseUrl}`,
+        `${style("Executor", ANSI.blue, supportsAnsi())}: ${config.executor.type}`,
+        `${style("Approval", ANSI.blue, supportsAnsi())}: ${config.approvalMode}`,
+        `${style("Runtime", ANSI.blue, supportsAnsi())}: ${runtimeSession?.getStatusLabel() || "offline"}`,
+        ...(runtimeSession?.getStatusDetail()
+            ? [`${style("Runtime note", ANSI.blue, supportsAnsi())}: ${runtimeSession.getStatusDetail()}`]
+            : []),
+        `${style("Config", ANSI.blue, supportsAnsi())}: ${getBridgeConfigPath()}`,
+    ];
+}
+async function printExtensionsOverview(config) {
+    printSection("Extensions");
+    if (!config.installedExtensions.length) {
+        printMuted("Nenhuma extensão instalada neste bridge.");
+        return;
+    }
+    for (const extension of config.installedExtensions) {
+        if (!isManagedBridgeExtensionSlug(extension)) {
+            console.log(`- ${extension}`);
+            continue;
+        }
+        const state = await loadManagedBridgeExtensionState(extension);
+        const status = state ? formatManagedBridgeExtensionStatus(state.status) : "sem estado salvo";
+        console.log(`- ${extension}: ${status}`);
+        if (state?.notes) {
+            printMuted(`  ${truncate(state.notes, 140)}`);
+        }
+    }
+}
+async function runSetupWizard(rl, options) {
+    printSection(options?.postinstall ? "Setup Inicial" : "Pairing Setup");
+    printMuted("Cole o pairing code gerado na interface web do Otto.");
+    const existingConfig = await loadBridgeConfig();
+    if (existingConfig) {
+        const keepExisting = await askYesNo(rl, `Já existe um pairing salvo para ${existingConfig.deviceName}. Quer substituir esse vínculo`, false);
+        if (!keepExisting) {
+            return { config: existingConfig, openConsole: false };
+        }
+    }
+    const apiBaseUrl = resolveApiBaseUrl(await ask(rl, "API base URL", {
+        defaultValue: existingConfig?.apiBaseUrl || DEFAULT_API_BASE_URL,
+    }));
+    const pairingCode = await ask(rl, "Pairing code", {
+        allowEmpty: Boolean(options?.postinstall),
+    });
+    if (!pairingCode) {
+        printMuted("Setup adiado. Quando quiser, rode `otto-bridge setup`.");
+        return { config: existingConfig || null, openConsole: false };
+    }
+    const deviceName = await ask(rl, "Nome do dispositivo", {
+        defaultValue: existingConfig?.deviceName || defaultDeviceName(),
+    });
+    const executor = await chooseExecutor(rl, existingConfig?.executor);
+    printMuted("Solicitando pairing ao backend e aguardando aprovação...");
+    const config = await pairDevice({
+        apiBaseUrl,
+        pairingCode,
+        deviceName,
+        executor,
+    });
+    printSuccess(`Bridge pareado com sucesso como ${config.deviceName}.`);
+    printMuted(`Config salvo em ${getBridgeConfigPath()}`);
+    const openConsole = await askYesNo(rl, "Abrir o Otto Console agora", true);
+    return { config, openConsole };
+}
+async function followConsoleJob(rl, config, jobId) {
+    let lastStatus = "";
+    let lastStepId = "";
+    let awaitingDecision = false;
+    for (;;) {
+        const envelope = await getRuntimeCliJob(config, jobId);
+        const job = envelope.job || {};
+        const status = normalizeText(job.status).toLowerCase() || "unknown";
+        const stepId = extractJobStepId(job);
+        if (status !== lastStatus || stepId !== lastStepId) {
+            const statusLabel = `${status}${stepId ? ` · ${stepId}` : ""}`;
+            console.log(`${style("runtime", ANSI.teal, supportsAnsi())} ${statusLabel}`);
+            lastStatus = status;
+            lastStepId = stepId;
+        }
+        if (status === "confirm_required" && !awaitingDecision) {
+            awaitingDecision = true;
+            console.log(style(extractConfirmationPrompt(job), ANSI.amber, supportsAnsi()));
+            const approve = await askYesNo(rl, "Aprovar este passo", true);
+            if (approve) {
+                await confirmRuntimeCliJob(config, jobId, "approve");
+            }
+            else {
+                const reject = await askYesNo(rl, "Rejeitar explicitamente este passo", true);
+                if (reject) {
+                    await confirmRuntimeCliJob(config, jobId, "reject");
+                }
+                else {
+                    await cancelRuntimeCliJob(config, jobId, "Cancelado no Otto Console");
+                }
+            }
+            awaitingDecision = false;
+            continue;
+        }
+        if (status === "completed" || status === "failed" || status === "cancelled") {
+            const summary = extractJobSummary(job)
+                || (status === "completed"
+                    ? "Execução local concluída."
+                    : status === "failed"
+                        ? "Execução local falhou."
+                        : "Execução local cancelada.");
+            console.log(`${style("otto", ANSI.coral, supportsAnsi())} ${summary}`);
+            return summary;
+        }
+        await delay(1400);
+    }
+}
+async function runOttoConsole(rl, config, runtimeSession, options) {
+    printSection("Otto Console");
+    printMuted("Este console usa o mesmo runtime local já ligado pelo `otto-bridge`.");
+    printMuted(`Runtime: ${runtimeSession.getStatusLabel()} · ${runtimeSession.getStatusDetail()}`);
+    const sessionId = randomUUID();
+    const conversation = [];
+    const printConsoleHelp = () => {
+        printMuted("Comandos: /help, /clear, /status, /exit");
+    };
+    const handlePrompt = async (promptText) => {
+        const normalizedPrompt = normalizeText(promptText);
+        if (!normalizedPrompt) {
+            return;
+        }
+        if (normalizedPrompt === "/help") {
+            printConsoleHelp();
+            return;
+        }
+        if (normalizedPrompt === "/clear") {
+            conversation.splice(0, conversation.length);
+            printMuted("Contexto local do console limpo.");
+            return;
+        }
+        if (normalizedPrompt === "/status") {
+            renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
+            const runtimeFailure = runtimeSession.getLastError();
+            if (runtimeFailure) {
+                printWarning(`Runtime reportou erro: ${runtimeFailure}`);
+            }
+            return;
+        }
+        if (normalizedPrompt === "/exit") {
+            throw new Error("__OTTO_CONSOLE_EXIT__");
+        }
+        conversation.push({ role: "user", content: normalizedPrompt });
+        while (conversation.length > 18) {
+            conversation.shift();
+        }
+        console.log(`${style("você", ANSI.white, supportsAnsi())} ${normalizedPrompt}`);
+        let streamedAssistant = "";
+        let assistantPrefixPrinted = false;
+        let handoffPayload = null;
+        await streamDeviceCliChat(config, {
+            messages: conversation,
+            session_id: sessionId,
+        }, async (event) => {
+            const chunkType = normalizeText(event.chunk_type).toLowerCase();
+            const eventType = normalizeText(event.type).toLowerCase();
+            if (chunkType === "bridge_handoff") {
+                handoffPayload = event;
+                return;
+            }
+            if (chunkType === "search_status") {
+                const status = normalizeText(event.status);
+                if (status) {
+                    printMuted(`Busca: ${status}`);
+                }
+                return;
+            }
+            const errorMessage = normalizeText(event.error || (eventType === "error" ? event.content : ""));
+            if (errorMessage) {
+                throw new Error(errorMessage);
+            }
+            const contentChunk = typeof event.content === "string" ? event.content : "";
+            if (!contentChunk) {
+                return;
+            }
+            if (!assistantPrefixPrinted) {
+                output.write(`${style("otto", ANSI.coral, supportsAnsi())} `);
+                assistantPrefixPrinted = true;
+            }
+            output.write(contentChunk);
+            streamedAssistant += contentChunk;
+        });
+        if (assistantPrefixPrinted) {
+            output.write("\n");
+        }
+        let finalAssistantSummary = normalizeText(streamedAssistant);
+        if (handoffPayload) {
+            const handoffData = handoffPayload;
+            const bridgeSummary = extractBridgeHandoffSummary(handoffData);
+            if (bridgeSummary) {
+                console.log(`${style("otto", ANSI.coral, supportsAnsi())} ${bridgeSummary}`);
+            }
+            const job = handoffData.job && typeof handoffData.job === "object"
+                ? handoffData.job
+                : null;
+            const jobId = normalizeText(job?.id);
+            if (jobId) {
+                finalAssistantSummary = await followConsoleJob(rl, config, jobId);
+            }
+            else if (bridgeSummary) {
+                finalAssistantSummary = bridgeSummary;
+            }
+        }
+        if (finalAssistantSummary) {
+            conversation.push({ role: "assistant", content: finalAssistantSummary });
+            while (conversation.length > 18) {
+                conversation.shift();
+            }
+        }
+    };
+    printConsoleHelp();
+    if (options?.initialPrompt) {
+        await handlePrompt(options.initialPrompt);
+    }
+    for (;;) {
+        const promptText = await ask(rl, "OTTO", { allowEmpty: true });
+        try {
+            await handlePrompt(promptText);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "__OTTO_CONSOLE_EXIT__") {
+                break;
+            }
+            throw error;
+        }
+    }
+}
+async function printStatusView(rl, config, runtimeSession) {
+    printSection("Bridge Status");
+    renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
+    await printExtensionsOverview(config);
+    await pauseForEnter(rl);
+}
+async function pickHomeChoice(rl, paired) {
+    printSection("Home");
+    const options = paired
+        ? [
+            `${style("1.", ANSI.coral, supportsAnsi())} Otto Console`,
+            `${style("2.", ANSI.coral, supportsAnsi())} Re-pair / setup`,
+            `${style("3.", ANSI.coral, supportsAnsi())} Status do bridge`,
+            `${style("4.", ANSI.coral, supportsAnsi())} Extensões instaladas`,
+            `${style("5.", ANSI.coral, supportsAnsi())} Sair`,
+        ]
+        : [
+            `${style("1.", ANSI.coral, supportsAnsi())} Pairing setup`,
+            `${style("2.", ANSI.coral, supportsAnsi())} Sair`,
+        ];
+    console.log(options.join("\n"));
+    const answer = await ask(rl, "Escolha");
+    if (!paired) {
+        return answer === "1" ? "setup" : "exit";
+    }
+    if (answer === "1")
+        return "console";
+    if (answer === "2")
+        return "setup";
+    if (answer === "3")
+        return "status";
+    if (answer === "4")
+        return "extensions";
+    return "exit";
+}
+export async function launchInteractiveCli(options) {
+    const rl = await createPromptInterface();
+    let runtimeSession = null;
+    try {
+        console.clear();
+        console.log(renderBanner());
+        let config = await loadBridgeConfig();
+        if (!config) {
+            const setup = await runSetupWizard(rl, options);
+            config = setup.config;
+            if (config && setup.openConsole) {
+                runtimeSession = new CliRuntimeSession(config);
+                await runtimeSession.ensureStarted();
+                await runOttoConsole(rl, config, runtimeSession);
+            }
+            if (!config) {
+                return;
+            }
+        }
+        runtimeSession = runtimeSession || new CliRuntimeSession(config);
+        await runtimeSession.ensureStarted();
+        for (;;) {
+            console.log("");
+            renderStatusOverview(config, runtimeSession).forEach((line) => console.log(line));
+            const choice = await pickHomeChoice(rl, true);
+            if (choice === "exit") {
+                break;
+            }
+            if (choice === "setup") {
+                const setup = await runSetupWizard(rl);
+                if (setup.config) {
+                    config = setup.config;
+                    if (runtimeSession) {
+                        await runtimeSession.replaceConfig(setup.config);
+                    }
+                    else {
+                        runtimeSession = new CliRuntimeSession(setup.config);
+                        await runtimeSession.ensureStarted();
+                    }
+                }
+                if (setup.config && setup.openConsole && runtimeSession) {
+                    await runOttoConsole(rl, setup.config, runtimeSession);
+                }
+                continue;
+            }
+            if (choice === "console" && runtimeSession) {
+                await runOttoConsole(rl, config, runtimeSession);
+                continue;
+            }
+            if (choice === "status" && runtimeSession) {
+                await printStatusView(rl, config, runtimeSession);
+                continue;
+            }
+            if (choice === "extensions") {
+                await printExtensionsOverview(config);
+                await pauseForEnter(rl);
+            }
+        }
+    }
+    finally {
+        await runtimeSession?.stop().catch(() => undefined);
+        rl.close();
+    }
+}
+export async function runSetupCommand(options) {
+    const rl = await createPromptInterface();
+    let runtimeSession = null;
+    try {
+        console.clear();
+        console.log(renderBanner());
+        const setup = await runSetupWizard(rl, options);
+        if (setup.config && setup.openConsole) {
+            runtimeSession = new CliRuntimeSession(setup.config);
+            await runtimeSession.ensureStarted();
+            await runOttoConsole(rl, setup.config, runtimeSession);
+        }
+    }
+    finally {
+        await runtimeSession?.stop().catch(() => undefined);
+        rl.close();
+    }
+}
+export async function runConsoleCommand(initialPrompt) {
+    const rl = await createPromptInterface();
+    let runtimeSession = null;
+    try {
+        console.clear();
+        console.log(renderBanner());
+        let config = await loadBridgeConfig();
+        if (!config) {
+            const setup = await runSetupWizard(rl);
+            if (!setup.config) {
+                return;
+            }
+            config = setup.config;
+        }
+        runtimeSession = new CliRuntimeSession(config);
+        await runtimeSession.ensureStarted();
+        await runOttoConsole(rl, config, runtimeSession, { initialPrompt });
+    }
+    finally {
+        await runtimeSession?.stop().catch(() => undefined);
+        rl.close();
+    }
+}