@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/wizard.js

@@ -0,0 +1,689 @@
+/**
+ * `interf` (no subcommand) and `interf init` — the wizard.
+ *
+ * Casual-user entry point. End-to-end onboarding:
+ *   - If no connection → offer to start a local engine inline (or connect remote, or quit).
+ *   - Once connected → action menu (list / create / compile / test / open UI / stop engine / quit).
+ *   - Each action loops back to the menu instead of exiting.
+ *
+ * Agents bypass the wizard entirely. They use `interf prep`, `interf compile`,
+ * etc. directly. The wizard is purely a UX wrapper around those CLI commands.
+ */
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { readActiveConnection, writeConnection, } from "../../packages/engine/connection-config.js";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT } from "../../packages/engine/routes.js";
+async function callJson(url, token) {
+    const headers = new Headers();
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    try {
+        const response = await fetch(url, { headers });
+        const raw = await response.text();
+        let body = null;
+        if (raw) {
+            try {
+                body = JSON.parse(raw);
+            }
+            catch {
+                body = null;
+            }
+        }
+        return { status: response.status, body };
+    }
+    catch {
+        return { status: 0, body: null };
+    }
+}
+function spawnInterf(args) {
+    return new Promise((resolveSpawn) => {
+        const child = spawn(process.argv[1] ?? "interf", args, { stdio: "inherit" });
+        child.on("exit", (code) => resolveSpawn(code ?? 0));
+    });
+}
+const DEFAULT_ENGINE_URL = `http://${LOCAL_SERVICE_DEFAULT_HOST}:${LOCAL_SERVICE_DEFAULT_PORT}`;
+/**
+ * Probe a URL's `/health` endpoint and return whether the engine is up.
+ * Used as a fallback when `connection.json` may be missing (e.g. older
+ * `interf web` binaries that don't write the 0.13 record).
+ */
+async function probeHealth(url) {
+    try {
+        const response = await fetch(`${url.replace(/\/+$/, "")}/health`);
+        return response.status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Connect to an engine. Either an existing one already running on the
+ * default port (with a `wasAlreadyRunning` flag so the caller can tell
+ * the user honestly) or a fresh one we spawn here.
+ *
+ * Returns null on timeout / error.
+ */
+async function startLocalEngineInBackground() {
+    // First: check whether an engine is ALREADY running on the default
+    // port. If so, don't pretend to start a new one — just connect.
+    if (await probeHealth(DEFAULT_ENGINE_URL)) {
+        try {
+            writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
+        }
+        catch {
+            // best effort
+        }
+        console.log(chalk.dim(`  Engine already running at ${DEFAULT_ENGINE_URL} — connecting.`));
+        return { url: DEFAULT_ENGINE_URL, token: null, wasAlreadyRunning: true };
+    }
+    const spinner = p.spinner();
+    spinner.start("Starting local Interf engine…");
+    const child = spawn(process.argv[1] ?? "interf", ["web"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    const startedAt = Date.now();
+    const timeoutMs = 30_000;
+    while (Date.now() - startedAt < timeoutMs) {
+        await new Promise((r) => setTimeout(r, 250));
+        // Path A: connection.json written by the spawned 0.13+ server.
+        const conn = readActiveConnection();
+        if (conn) {
+            const url = conn.url.replace(/\/+$/, "");
+            if (await probeHealth(url)) {
+                spinner.stop(chalk.green(`Engine ready at ${url}`));
+                return { url, token: conn.auth_token, wasAlreadyRunning: false };
+            }
+        }
+        // Path B: spawned engine is ready on the default URL.
+        if (await probeHealth(DEFAULT_ENGINE_URL)) {
+            try {
+                writeConnection({ url: DEFAULT_ENGINE_URL, auth_token: null });
+            }
+            catch {
+                // best effort
+            }
+            spinner.stop(chalk.green(`Engine ready at ${DEFAULT_ENGINE_URL}`));
+            return { url: DEFAULT_ENGINE_URL, token: null, wasAlreadyRunning: false };
+        }
+    }
+    spinner.stop(chalk.red("Timed out waiting for engine to start."));
+    return null;
+}
+/**
+ * Print the canonical connect-or-error hint and exit non-zero. Used
+ * whenever the wizard needs an engine but no reachable connection
+ * exists. The wizard does NOT auto-start an engine — `interf web` is
+ * the explicit, foreground way to run one.
+ */
+function exitNoEngineConnected(reason) {
+    console.log();
+    console.log(chalk.yellow(`  ${reason}`));
+    console.log();
+    console.log("  Start one in another terminal:");
+    console.log(chalk.bold("    interf web"));
+    console.log();
+    console.log("  Or connect to a remote engine:");
+    console.log(chalk.bold("    interf login --url <https://…>"));
+    console.log();
+    process.exit(1);
+}
+/** Validate that a path exists and is a directory. */
+function validateSourcePath(value) {
+    const abs = resolve(value);
+    if (!existsSync(abs))
+        return `Source folder does not exist: ${abs}`;
+    if (!statSync(abs).isDirectory())
+        return `Source folder is not a directory: ${abs}`;
+    return undefined;
+}
+/** Offer the user a curated source-path picker before falling back to free-form input. */
+async function promptSourcePath() {
+    const cwd = process.cwd();
+    const home = homedir();
+    const commonCandidates = [
+        cwd,
+        `${home}/Documents`,
+        `${home}/Downloads`,
+        `${home}/Desktop`,
+        home,
+    ];
+    const seen = new Set();
+    const options = [];
+    for (const candidate of commonCandidates) {
+        const abs = resolve(candidate);
+        if (seen.has(abs))
+            continue;
+        if (!existsSync(abs))
+            continue;
+        if (!statSync(abs).isDirectory())
+            continue;
+        seen.add(abs);
+        const isCwd = abs === resolve(cwd);
+        const label = `${basename(abs) || abs} ${chalk.dim(`— ${abs}${isCwd ? " (current dir)" : ""}`)}`;
+        options.push({ value: abs, label });
+    }
+    options.push({ value: "__custom__", label: chalk.dim("Type a custom path…") });
+    const choice = await p.select({
+        message: "Where's the source folder?",
+        options,
+        initialValue: resolve(cwd),
+    });
+    if (p.isCancel(choice))
+        return null;
+    if (choice === "__custom__") {
+        const typed = await p.text({
+            message: "Custom source folder path",
+            placeholder: cwd,
+            initialValue: cwd,
+            validate: validateSourcePath,
+        });
+        if (p.isCancel(typed))
+            return null;
+        return resolve(String(typed));
+    }
+    return String(choice);
+}
+async function flowCreatePreparation(conn) {
+    const prepId = await p.text({
+        message: "Preparation id (a short name for this unit of agent work)",
+        placeholder: "my-prep",
+        validate: (value) => (/^[a-z0-9][a-z0-9-]*$/.test(value) ? undefined : "Lowercase letters, numbers, and dashes only."),
+    });
+    if (p.isCancel(prepId))
+        return null;
+    const about = await p.text({
+        message: "What is this preparation for? (one line — the agent task intent)",
+        placeholder: "Prepare these notes so an agent can answer questions about them.",
+    });
+    if (p.isCancel(about))
+        return null;
+    const aboutText = String(about ?? "").trim();
+    const sourcePath = await promptSourcePath();
+    if (!sourcePath)
+        return null;
+    // Offer the methods that the connected instance knows about. Method
+    // binding is OPTIONAL at create time — the agent first creates the
+    // preparation (the unit of agent work) and may pick or draft a method
+    // for it later.
+    const methodsResp = await callJson(`${conn.url}/v1/methods`, conn.token);
+    const methods = methodsResp.body?.methods ?? [];
+    const methodOptions = methods
+        .map((m) => ({ value: m.method_id ?? m.id ?? "", label: `${m.method_id ?? m.id ?? "(?)"}${m.label ? ` — ${m.label}` : ""}` }))
+        .filter((opt) => opt.value !== "");
+    let methodId = null;
+    const skipOption = { value: "__skip__", label: chalk.dim("Skip — pick or draft a method later") };
+    const customOption = { value: "__custom__", label: "Other (type a method id)" };
+    if (methodOptions.length > 0) {
+        const chosen = await p.select({
+            message: "Pick a method (optional — you can do this later)",
+            options: [...methodOptions, customOption, skipOption],
+            initialValue: methodOptions.find((o) => o.value === "interf-default")?.value ?? methodOptions[0]?.value,
+        });
+        if (p.isCancel(chosen))
+            return null;
+        if (chosen === "__skip__") {
+            methodId = null;
+        }
+        else if (chosen === "__custom__") {
+            const typed = await p.text({
+                message: "Method id",
+                placeholder: "interf-default",
+            });
+            if (p.isCancel(typed))
+                return null;
+            methodId = String(typed);
+        }
+        else {
+            methodId = String(chosen);
+        }
+    }
+    else {
+        const choose = await p.select({
+            message: "No methods registered yet — pick a method id?",
+            options: [
+                { value: "__type__", label: "Type a method id" },
+                skipOption,
+            ],
+        });
+        if (p.isCancel(choose))
+            return null;
+        if (choose === "__type__") {
+            const typed = await p.text({
+                message: "Method id",
+                initialValue: "interf-default",
+            });
+            if (p.isCancel(typed))
+                return null;
+            methodId = String(typed);
+        }
+    }
+    const exitCode = await spawnInterf([
+        "prep",
+        "create",
+        String(prepId),
+        "--source",
+        resolve(String(sourcePath)),
+        ...(methodId ? ["--method", methodId] : []),
+        ...(aboutText ? ["--about", aboutText] : []),
+    ]);
+    if (exitCode !== 0)
+        return null;
+    return String(prepId);
+}
+async function pickPreparation(conn, message) {
+    const preps = await callJson(`${conn.url}/v1/preparations`, conn.token);
+    const list = preps.body?.preparations ?? [];
+    if (list.length === 0) {
+        console.log(chalk.dim("  No preparations yet. Create one first."));
+        return null;
+    }
+    const choice = await p.select({
+        message,
+        options: list.map((prep) => ({
+            value: prep.id,
+            label: `${prep.id} ${chalk.dim(`(${prep.method_id} · ${prep.readiness?.status ?? "—"})`)}`,
+        })),
+    });
+    if (p.isCancel(choice))
+        return null;
+    return String(choice);
+}
+async function showActionMenu(conn, options = { allowCompileVerify: true }) {
+    const compileLabel = options.allowCompileVerify
+        ? "Compile a preparation"
+        : chalk.dim("Compile a preparation (no agents available)");
+    const verifyLabel = options.allowCompileVerify
+        ? "Verify a preparation's claim-checks"
+        : chalk.dim("Verify (no agents available)");
+    const action = await p.select({
+        message: "What do you want to do?",
+        options: [
+            { value: "ui", label: "Open Compiler UI" },
+            { value: "ls", label: "List preparations" },
+            { value: "create", label: "Create a new preparation" },
+            { value: "agents", label: "Manage agents (list / register / role-map)" },
+            { value: "compile", label: compileLabel },
+            { value: "verify", label: verifyLabel },
+            { value: "stop", label: "Stop the local engine" },
+            { value: "quit", label: "Quit" },
+        ],
+    });
+    if (p.isCancel(action) || action === "quit")
+        return "exit";
+    if (action === "ls") {
+        await spawnInterf(["prep", "ls"]);
+        return "continue";
+    }
+    if (action === "agents") {
+        await spawnInterf(["agents", "ls"]);
+        return "continue";
+    }
+    if (action === "create") {
+        const newId = await flowCreatePreparation(conn);
+        if (newId) {
+            if (!options.allowCompileVerify) {
+                console.log(chalk.dim("  Skipping compile prompt — no agents available. Install one then run `interf compile " +
+                    newId +
+                    "`."));
+            }
+            else {
+                const compileNow = await p.confirm({ message: `Compile ${newId} now?`, initialValue: true });
+                if (!p.isCancel(compileNow) && compileNow) {
+                    await spawnInterf(["compile", newId]);
+                }
+            }
+        }
+        return "continue";
+    }
+    if (action === "compile") {
+        if (!options.allowCompileVerify) {
+            console.log(chalk.yellow("  Cannot compile — no agents available."));
+            console.log("  Install Claude Code, Codex, Gemini, or another agent CLI, or");
+            console.log("  register a custom CLI: `interf agents register <name> --command <cmd>`.");
+            return "continue";
+        }
+        const id = await pickPreparation(conn, "Which preparation to compile?");
+        if (id)
+            await spawnInterf(["compile", id]);
+        return "continue";
+    }
+    if (action === "verify") {
+        if (!options.allowCompileVerify) {
+            console.log(chalk.yellow("  Cannot verify — no agents available."));
+            return "continue";
+        }
+        const id = await pickPreparation(conn, "Which preparation to verify?");
+        if (id)
+            await spawnInterf(["verify", id]);
+        return "continue";
+    }
+    if (action === "ui") {
+        const target = `${conn.url}/`;
+        console.log();
+        console.log(`  Opening ${chalk.bold(target)} in your browser…`);
+        const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        try {
+            const child = spawn(command, [target], { detached: true, stdio: "ignore" });
+            child.on("error", () => {
+                console.log(chalk.dim(`  (Could not open browser; visit ${target} manually.)`));
+            });
+            child.unref();
+        }
+        catch {
+            console.log(chalk.dim(`  (Could not open browser; visit ${target} manually.)`));
+        }
+        console.log();
+        return "continue";
+    }
+    if (action === "stop") {
+        const ok = await p.confirm({ message: "Stop the connected engine?", initialValue: false });
+        if (!p.isCancel(ok) && ok) {
+            await spawnInterf(["web", "stop"]);
+            return "exit";
+        }
+        return "continue";
+    }
+    return "continue";
+}
+/**
+ * Agent install-cards menu shown when the connected engine has zero
+ * detected + registered agents. Returns:
+ *   - "rerun" → user installed an agent and wants to retry detection
+ *   - "skip"  → continue in UI-only mode (no compile/verify)
+ *   - "quit"  → exit
+ */
+async function showAgentInstallCards() {
+    console.log();
+    console.log(chalk.yellow("  No agents detected."));
+    console.log();
+    console.log("  Interf needs at least one agent to compile and verify preparations.");
+    console.log();
+    const choice = await p.select({
+        message: "How do you want to proceed?",
+        options: [
+            {
+                value: "claude-code",
+                label: `Install Claude Code  ${chalk.dim("(opens install docs)")}`,
+            },
+            {
+                value: "codex",
+                label: `Install OpenAI Codex ${chalk.dim("(opens install docs)")}`,
+            },
+            {
+                value: "gemini",
+                label: `Install Gemini CLI   ${chalk.dim("(opens install docs)")}`,
+            },
+            {
+                value: "custom",
+                label: "Register a custom CLI as an agent",
+            },
+            {
+                value: "skip",
+                label: chalk.dim("Skip — UI-only mode (browse existing portable contexts only)"),
+            },
+            { value: "quit", label: chalk.dim("Quit") },
+        ],
+    });
+    if (p.isCancel(choice) || choice === "quit")
+        return "quit";
+    if (choice === "skip")
+        return "skip";
+    if (choice === "custom") {
+        const name = await p.text({
+            message: "Agent name (lowercase identifier)",
+            placeholder: "opencode",
+            validate: (value) => /^[a-z0-9][a-z0-9-]*$/.test(value)
+                ? undefined
+                : "Lowercase letters, numbers, and dashes only.",
+        });
+        if (p.isCancel(name))
+            return "quit";
+        const command = await p.text({
+            message: "Command to invoke",
+            placeholder: "opencode --prompt",
+        });
+        if (p.isCancel(command))
+            return "quit";
+        const displayName = await p.text({
+            message: `Display name (defaults to "${name}")`,
+            placeholder: String(name),
+        });
+        if (p.isCancel(displayName))
+            return "quit";
+        const cliDisplayName = String(displayName).trim() || String(name);
+        const exitCode = await spawnInterf([
+            "agents",
+            "register",
+            String(name),
+            "--command",
+            String(command),
+            "--display-name",
+            cliDisplayName,
+        ]);
+        return exitCode === 0 ? "rerun" : "quit";
+    }
+    // Print install instructions + offer to copy the install command.
+    const installCommands = {
+        "claude-code": {
+            command: "npm install -g @anthropic-ai/claude-code",
+            docs: "https://docs.claude.com/claude-code",
+        },
+        codex: {
+            command: "npm install -g @openai/codex",
+            docs: "https://github.com/openai/codex",
+        },
+        gemini: {
+            command: "npm install -g @google/gemini-cli",
+            docs: "https://github.com/google-gemini/gemini-cli",
+        },
+    };
+    const target = installCommands[String(choice)];
+    if (target) {
+        console.log();
+        console.log(`  Install command: ${chalk.bold(target.command)}`);
+        console.log(`  Docs:            ${chalk.dim(target.docs)}`);
+        console.log();
+        const next = await p.select({
+            message: "What now?",
+            options: [
+                { value: "rerun", label: "I installed it — re-detect" },
+                { value: "skip", label: chalk.dim("Skip — continue in UI-only mode") },
+                { value: "quit", label: chalk.dim("Quit") },
+            ],
+        });
+        if (p.isCancel(next) || next === "quit")
+            return "quit";
+        if (next === "skip")
+            return "skip";
+        return "rerun";
+    }
+    return "rerun";
+}
+async function fetchAgentSnapshot(conn) {
+    const instance = await callJson(`${conn.url}/v1/instance`, conn.token);
+    const agentsResponse = await callJson(`${conn.url}/v1/agents`, conn.token);
+    if (instance.status !== 200)
+        return null;
+    // Engines pre-0.15 don't expose /v1/agents. Surface the gap explicitly
+    // so the wizard can tell the user to restart instead of silently going
+    // through the install-cards flow.
+    const engineSupportsAgents = agentsResponse.status === 200 && instance.body?.agent_count !== undefined;
+    return {
+        agentCount: instance.body?.agent_count ?? 0,
+        defaultAgent: instance.body?.default_agent ?? null,
+        agents: agentsResponse.body?.agents ?? [],
+        engineSupportsAgents,
+    };
+}
+async function runWizard(args) {
+    // Connect-or-error: the wizard never auto-starts an engine. If
+    // `~/.interf/connection.json` is missing or unreachable, exit
+    // non-zero and tell the user to run `interf web` (or
+    // `interf login`) explicitly. This keeps the engine lifecycle in
+    // the user's hands — no surprise background processes, no stale
+    // binaries served by a long-lived auto-spawn.
+    const initial = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!initial) {
+        exitNoEngineConnected("No Interf engine is connected.");
+    }
+    const url = initial.url.replace(/\/+$/, "");
+    const probe = await callJson(`${url}/health`, initial.auth_token);
+    if (probe.status === 0) {
+        exitNoEngineConnected(`Connection ${url} is unreachable.`);
+    }
+    let conn = { url, token: initial.auth_token };
+    const instance = await callJson(`${conn.url}/v1/instance`, conn.token);
+    console.log();
+    console.log(chalk.bold(`  Connected to ${conn.url}`));
+    if (instance.body?.package_version) {
+        console.log(chalk.dim(`  v${instance.body.package_version} · ${instance.body.preparation_count ?? 0} preparation(s)`));
+    }
+    // 0.15 — surface the connected agents up front. When zero are
+    // detected, run the install-cards menu before letting the user
+    // try to compile / verify.
+    let agents = await fetchAgentSnapshot(conn);
+    if (agents && !agents.engineSupportsAgents) {
+        console.log();
+        console.log(chalk.yellow("  ⚠  The connected engine is older than this CLI."));
+        console.log(chalk.dim("     /v1/agents is not available — agent management is disabled."));
+        console.log();
+        const choice = await p.select({
+            message: "Restart the engine now to pick up new features?",
+            options: [
+                { value: "restart", label: "Yes — stop old engine, start new one" },
+                { value: "continue", label: chalk.dim("No — continue with limited features (no agents UI / compile / verify)") },
+                { value: "quit", label: "Quit" },
+            ],
+            initialValue: "restart",
+        });
+        if (p.isCancel(choice) || choice === "quit") {
+            p.outro("Bye.");
+            return;
+        }
+        if (choice === "restart") {
+            console.log();
+            console.log(chalk.dim("  Stopping old engine…"));
+            await spawnInterf(["web", "stop"]);
+            // Small grace period for the OS to release the port.
+            await new Promise((r) => setTimeout(r, 800));
+            const restarted = await startLocalEngineInBackground();
+            if (!restarted) {
+                console.log(chalk.red("  Could not start the new engine. Try manually: interf web"));
+                process.exit(1);
+            }
+            conn = restarted;
+            agents = await fetchAgentSnapshot(conn);
+        }
+    }
+    // Treat "all registered agents are unavailable" the same as "no agents
+    // detected" — the install-cards menu lets the user install or register
+    // a real one before the active-agent picker runs.
+    function installedAgentCount(snapshot) {
+        if (!snapshot)
+            return 0;
+        return snapshot.agents.filter((agent) => agent.available !== false).length;
+    }
+    let allowCompileVerify = installedAgentCount(agents) > 0;
+    while (agents &&
+        agents.engineSupportsAgents &&
+        installedAgentCount(agents) === 0) {
+        const decision = await showAgentInstallCards();
+        if (decision === "quit") {
+            p.outro("Bye.");
+            return;
+        }
+        if (decision === "skip") {
+            allowCompileVerify = false;
+            break;
+        }
+        // decision === "rerun"
+        agents = await fetchAgentSnapshot(conn);
+        allowCompileVerify = installedAgentCount(agents) > 0;
+    }
+    if (agents && agents.engineSupportsAgents && installedAgentCount(agents) > 0) {
+        // Always confirm the active agent before the action menu. Pre-select
+        // the current default; user presses Enter to keep it, Up/Down to
+        // change. Customizing per-stage (role-map) is opt-in advanced —
+        // accessible via `interf agents map <role> <agent>`.
+        //
+        // Custom agents whose CLI is no longer on PATH carry `available: false`
+        // — show them in a hint instead of as selectable choices so the picker
+        // does not let the user pick something the engine cannot run.
+        const stale = agents.agents.filter((agent) => agent.available === false);
+        if (stale.length > 0) {
+            const names = stale.map((agent) => agent.display_name || agent.name).join(", ");
+            console.log();
+            console.log(chalk.yellow(`  ⚠  Registered but not installed: ${names}`));
+            console.log(chalk.dim(`     Reinstall the CLI or run \`interf agents unregister <name>\` to remove the stale entry.`));
+        }
+        const installed = agents.agents.filter((agent) => agent.available !== false);
+        const options = installed.map((agent) => ({
+            value: agent.name,
+            label: `${agent.display_name || agent.name}${agent.name === agents.defaultAgent ? chalk.green("  (current active)") : ""}${agent.source === "user" ? chalk.dim("  [custom]") : ""}`,
+        }));
+        options.push({ value: "__register__", label: chalk.dim("Register a custom CLI as an agent…") });
+        const installedDefault = installed.some((agent) => agent.name === agents.defaultAgent)
+            ? agents.defaultAgent
+            : null;
+        const choice = await p.select({
+            message: "Active agent for this session (will run every role unless overridden)",
+            options,
+            initialValue: installedDefault ?? options[0]?.value,
+        });
+        if (p.isCancel(choice)) {
+            p.outro("Bye.");
+            return;
+        }
+        if (choice === "__register__") {
+            const decision = await showAgentInstallCards();
+            if (decision === "quit") {
+                p.outro("Bye.");
+                return;
+            }
+            agents = await fetchAgentSnapshot(conn);
+        }
+        else if (choice !== agents.defaultAgent) {
+            // Switch active agent before proceeding. Reuse the existing CLI to
+            // sweep the role-map's `general` row + any role pinned to the
+            // previous active.
+            await spawnInterf(["agents", "use", String(choice)]);
+            agents = await fetchAgentSnapshot(conn);
+        }
+        if (agents && agents.defaultAgent) {
+            console.log(chalk.dim(`  Active: ${agents.defaultAgent} · roles default to ${agents.defaultAgent}`));
+        }
+    }
+    for (;;) {
+        console.log();
+        const next = await showActionMenu(conn, { allowCompileVerify });
+        if (next === "exit")
+            break;
+    }
+    p.outro("Bye.");
+}
+export const wizardCommand = {
+    command: "$0",
+    describe: "Open the interactive wizard (default when no subcommand is given)",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: runWizard,
+};
+/** Alias: `interf init` runs the same wizard. */
+export const initCommand = {
+    command: "init",
+    describe: "Open the interactive wizard",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: runWizard,
+};