@leg3ndy/otto-bridge 0.9.1 → 1.0.0

package/dist/cli_terminal.js

@@ -0,0 +1,490 @@
+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 { formatManagedBridgeExtensionStatus, isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
+import { pairDevice } from "./pairing.js";
+import { BridgeRuntime } from "./runtime.js";
+import { cancelRuntimeCliJob, confirmRuntimeCliJob, getRuntimeCliJob, submitRuntimeCliAssistantPrompt, } 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 = [
+    " ██████╗ ████████╗████████╗ ██████╗      █████╗ ██╗",
+    "██╔═══██╗╚══██╔══╝╚══██╔══╝██╔═══██╗    ██╔══██╗██║",
+    "██║   ██║   ██║      ██║   ██║   ██║    ███████║██║",
+    "██║   ██║   ██║      ██║   ██║   ██║    ██╔══██║██║",
+    "╚██████╔╝   ██║      ██║   ╚██████╔╝    ██║  ██║██║",
+    " ╚═════╝    ╚═╝      ╚═╝    ╚═════╝     ╚═╝  ╚═╝╚═╝",
+];
+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 extractResponseSummary(response) {
+    const narrationContext = response.narration_context && typeof response.narration_context === "object"
+        ? response.narration_context
+        : {};
+    const plan = response.plan && typeof response.plan === "object"
+        ? response.plan
+        : {};
+    return normalizeText(narrationContext.summary
+        || plan.summary
+        || plan.assistant_message);
+}
+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) {
+    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("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, options) {
+    printSection("Otto Console");
+    printMuted("O runtime local será mantido em background enquanto este console estiver aberto.");
+    const runtime = new BridgeRuntime(config);
+    let runtimeFailure = null;
+    const runtimeTask = runtime.start().catch((error) => {
+        runtimeFailure = error instanceof Error ? error.message : String(error);
+    });
+    await delay(600);
+    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).forEach((line) => console.log(line));
+            if (runtimeFailure) {
+                printWarning(`Runtime reportou erro: ${runtimeFailure}`);
+            }
+            return;
+        }
+        if (normalizedPrompt === "/exit") {
+            throw new Error("__OTTO_CONSOLE_EXIT__");
+        }
+        console.log(`${style("você", ANSI.white, supportsAnsi())} ${normalizedPrompt}`);
+        const response = await submitRuntimeCliAssistantPrompt(config, {
+            prompt: normalizedPrompt,
+            conversation,
+            session_id: sessionId,
+            source: "cli_terminal",
+        });
+        const summary = extractResponseSummary(response);
+        if (summary) {
+            console.log(`${style("otto", ANSI.coral, supportsAnsi())} ${summary}`);
+        }
+        conversation.push({ role: "user", content: normalizedPrompt });
+        if (summary) {
+            conversation.push({ role: "assistant", content: summary });
+        }
+        while (conversation.length > 16) {
+            conversation.shift();
+        }
+        const job = response.job && typeof response.job === "object" ? response.job : null;
+        const jobId = normalizeText(job?.id);
+        if (jobId) {
+            const terminalSummary = await followConsoleJob(rl, config, jobId);
+            if (terminalSummary) {
+                conversation.push({ role: "assistant", content: terminalSummary });
+            }
+        }
+        else if (normalizeText(response.route_mode) === "cloud_then_execute" || normalizeText(response.route_mode) === "execute_then_cloud") {
+            printWarning("Este fluxo ainda pede continuação cloud fora do console local. Acompanhe o app web se precisar do fechamento completo.");
+        }
+    };
+    printConsoleHelp();
+    try {
+        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;
+            }
+        }
+    }
+    finally {
+        await runtime.stop().catch(() => undefined);
+        await runtimeTask.catch(() => undefined);
+    }
+}
+async function printStatusView(rl, config) {
+    printSection("Bridge Status");
+    renderStatusOverview(config).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();
+    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) {
+                await runOttoConsole(rl, config);
+                return;
+            }
+            if (!config) {
+                return;
+            }
+        }
+        for (;;) {
+            console.log("");
+            renderStatusOverview(config).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 (setup.config && setup.openConsole) {
+                    await runOttoConsole(rl, setup.config);
+                }
+                continue;
+            }
+            if (choice === "console") {
+                await runOttoConsole(rl, config);
+                continue;
+            }
+            if (choice === "status") {
+                await printStatusView(rl, config);
+                continue;
+            }
+            if (choice === "extensions") {
+                await printExtensionsOverview(config);
+                await pauseForEnter(rl);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runSetupCommand(options) {
+    const rl = await createPromptInterface();
+    try {
+        console.clear();
+        console.log(renderBanner());
+        const setup = await runSetupWizard(rl, options);
+        if (setup.config && setup.openConsole) {
+            await runOttoConsole(rl, setup.config);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runConsoleCommand(initialPrompt) {
+    const config = await loadBridgeConfig();
+    if (!config) {
+        throw new Error("Nenhum pairing local encontrado. Rode `otto-bridge setup` primeiro.");
+    }
+    const rl = await createPromptInterface();
+    try {
+        console.clear();
+        console.log(renderBanner());
+        await runOttoConsole(rl, config, { initialPrompt });
+    }
+    finally {
+        rl.close();
+    }
+}