@xfey/tutti 0.1.6 → 0.1.8

package/README.md

@@ -20,14 +20,14 @@
 - `cli-package.mjs`：生成临时 staging `@xfey/tutti` package artifact 的脚本。
 - `prepare-package-assets.mjs`：把 Web build output 和内部 runtime package 复制到 staging package 所需位置。
 - `pack-dry-run.mjs`：构建 staging package 并执行 `npm pack --dry-run --json` 文件列表校验。
-- `smoke-packed-cli.mjs`：安装并验证 packed CLI tarball 的本地 smoke。
+- `smoke-packed-cli.mjs`：安装并验证 packed CLI tarball 的本地 smoke，包括 CLI help / version、runtime deps 和 QR dependency。
 
 ## 当前状态
 
-- 已具备 Fastify host shell、CLI launch、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层和 OpenAI / Codex provider 接入。
+- 已具备 Fastify host shell、后台 host manager CLI 套件、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层和 OpenAI / Codex provider 接入。
 - Host server 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health 和 host-local control 不被 SPA fallback 吞掉。
 - Root `pack:dry-run` 会先清理 build output、重新构建，再复制 `apps/web/dist` 到 package-local `web/`，生成临时 staging `@xfey/tutti` artifact，并校验 npm pack 文件列表包含 CLI、migrations、prompts、Web index、bundled `@tutti/shared` / `@tutti/relay-client` 以及它们的外部 runtime dependencies，同时排除源码、source map、日志、SQLite、`.env`、`.tutti-dev` 与测试产物。
-- Root `smoke:packed-cli` 同样从干净 build output 生成 staging `@xfey/tutti` tarball、在临时目录安装，并验证 SQLite native binding、`tutti --help` / `tutti launch --help`、migrations、prompts、Web static index、bundled internal dependencies、bundled external runtime dependencies、仓库锁定的 `@openai/codex` binary 可执行性和临时全局安装路径；该 smoke 不需要 Tutti source repo 存在。
+- Root `smoke:packed-cli` 同样从干净 build output 生成 staging `@xfey/tutti` tarball、在临时目录安装，并验证 SQLite native binding、`tutti --help` / `tutti launch --help` / `tutti --version`、migrations、prompts、Web static index、bundled internal dependencies、bundled external runtime dependencies、CLI QR dependency、仓库锁定的 `@openai/codex` binary 可执行性和临时全局安装路径；该 smoke 不需要 Tutti source repo 存在。
 - `prompts/` 是所有模型-facing prompt、指令模板和 Codex 执行模板的统一落点；长 prompt 不内联在 TypeScript 中。
 - Host Project API 只信任 Relay tunnel metadata 注入的 `relay_session_context`；direct loopback 缺少可信 context 时不作为浏览器工作区入口。
 - 详细模块落点见 `src/README.md`；logger redaction、command idempotency、schema、provider 与 Codex 边界以 `docs/system/` 对应 canonical 文档为准。
@@ -43,7 +43,7 @@
 - packaged / production `tutti launch` 默认连接 `https://tutti.now`；`TUTTI_RELAY_URL` 可覆盖 Relay URL，本地开发 dev runner 默认使用 `http://127.0.0.1:4370`。
 - host 注册使用 machine-local `host_registration_secret`；该 secret 明文只可写入受限权限的 machine-local secret store，不写入目标项目 repo、Git local config 项目身份、SQLite 协作真相或日志，`binding.json` 只保存引用。
 - Relay registration 成功后只把 `relay_project_ref` 写回 machine-local binding；join URL 只在 host 本机终端或当前 host-local control 内存状态中展示，不写入 binding、runtime endpoint、SQLite 协作真相或日志。
-- 普通 `tutti launch` 的前台 stdout 只展示运行提示、setup URL 和 join URL；Host HTTP request log 与 Control Plane / Run Pipeline runtime log 写入 `TUTTI_HOME/logs/host.log`，不写入目标项目 repo 或常规 CLI stdout。
+- 普通 `tutti launch` 默认后台运行 host，CLI 完成页展示 join URL 和二维码；`tutti launch --foreground` 保留前台诊断模式。Host HTTP request log 与 Control Plane / Run Pipeline runtime log 写入 `TUTTI_HOME/logs/host.log`，不写入目标项目 repo 或常规 CLI stdout。
 - Reference 和 Skills 上传的最终写入由 Host Project API 完成；Host 只通过 Relay host-control resolve 获取短期 R2 URL 下载 staged object，不接收浏览器 base64 文件正文，也不持久化 presigned URL。
 - Host Project API command 的 browser session context 只信任 Relay tunnel metadata 中的 `relay_session_context`；route handler 不读取浏览器身份 header，也不接受 payload 内身份字段。
 - Fastify request log、debug log、SSE payload、activity event 和 run result 都必须经过 redaction，不得泄露 provider secret、host registration secret、host connection token、join token、cookie、host 绝对路径或 run workspace path。

package/dist/server-shell/cli/args.d.ts

@@ -1,7 +1,45 @@
+export type CliCommand = {
+    kind: "help";
+    topic?: string;
+} | {
+    kind: "version";
+} | {
+    kind: "launch";
+    workspacePath: string;
+    yes: boolean;
+    foreground: boolean;
+} | {
+    kind: "internal-host-run";
+    workspacePath: string;
+    yes: boolean;
+} | {
+    kind: "ps";
+    manage: boolean;
+} | {
+    kind: "stop";
+    workspacePath?: string;
+} | {
+    kind: "invite";
+    workspacePath?: string;
+} | {
+    kind: "logs";
+    workspacePath?: string;
+    tail: number;
+} | {
+    kind: "provider-setup";
+    workspacePath?: string;
+} | {
+    kind: "provider-status";
+    workspacePath?: string;
+} | {
+    kind: "doctor";
+    workspacePath?: string;
+};
 export type LaunchCliArgs = {
     command: "launch";
     workspacePath: string;
     yes: boolean;
 };
 export declare function parseLaunchCliArgs(argv: readonly string[], cwd?: string): LaunchCliArgs;
+export declare function parseCliArgs(argv: readonly string[], cwd?: string): CliCommand;
 //# sourceMappingURL=args.d.ts.map

package/dist/server-shell/cli/args.js

@@ -1,5 +1,11 @@
 import { resolve } from "node:path";
 import { LaunchError } from "./errors.js";
+function isHelpArg(arg) {
+    return arg === "--help" || arg === "-h";
+}
+function hasHelpArg(args) {
+    return args.some((arg) => isHelpArg(arg));
+}
 export function parseLaunchCliArgs(argv, cwd = process.cwd()) {
     const args = [...argv];
     const command = args.shift();
@@ -27,4 +33,166 @@ export function parseLaunchCliArgs(argv, cwd = process.cwd()) {
         yes,
     };
 }
+function readOptionalWorkspace(args, cwd) {
+    let workspacePath;
+    for (const arg of args) {
+        if (arg.startsWith("--")) {
+            throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Run `tutti --help` to see supported commands.");
+        }
+        if (workspacePath !== undefined) {
+            throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti --help` to see supported commands.");
+        }
+        workspacePath = resolve(cwd, arg);
+    }
+    return workspacePath;
+}
+export function parseCliArgs(argv, cwd = process.cwd()) {
+    const args = [...argv];
+    const command = args.shift();
+    if (command === undefined ||
+        command === "--help" ||
+        command === "-h" ||
+        command === "help") {
+        return { kind: "help", ...(args[0] === undefined ? {} : { topic: args[0] }) };
+    }
+    if (command === "--version" || command === "-v" || command === "version") {
+        return { kind: "version" };
+    }
+    if (command === "launch") {
+        let workspacePath;
+        let yes = false;
+        let foreground = false;
+        for (const arg of args) {
+            if (arg === "--yes") {
+                yes = true;
+                continue;
+            }
+            if (arg === "--foreground") {
+                foreground = true;
+                continue;
+            }
+            if (isHelpArg(arg)) {
+                return { kind: "help", topic: "launch" };
+            }
+            if (arg.startsWith("--")) {
+                throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Use `tutti launch --help` to see supported launch options.");
+            }
+            if (workspacePath !== undefined) {
+                throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti launch [workspace_path] [--yes] [--foreground]`.");
+            }
+            workspacePath = resolve(cwd, arg);
+        }
+        return { kind: "launch", workspacePath: workspacePath ?? resolve(cwd, "."), yes, foreground };
+    }
+    if (command === "internal") {
+        const internalCommand = args.shift();
+        if (internalCommand !== "host-run") {
+            throw new LaunchError("git_bootstrap_failed", "Unsupported internal command", "Internal commands are managed by Tutti.");
+        }
+        let workspacePath;
+        let yes = false;
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--yes") {
+                yes = true;
+                continue;
+            }
+            if (arg === "--workspace") {
+                const value = args[index + 1];
+                if (value === undefined) {
+                    throw new LaunchError("git_bootstrap_failed", "--workspace requires a path", "Internal host-run commands are managed by Tutti.");
+                }
+                workspacePath = resolve(cwd, value);
+                index += 1;
+                continue;
+            }
+            throw new LaunchError("git_bootstrap_failed", `Unsupported internal option: ${arg ?? ""}`, "Internal commands are managed by Tutti.");
+        }
+        if (workspacePath === undefined) {
+            throw new LaunchError("git_bootstrap_failed", "Internal host-run requires --workspace", "Internal commands are managed by Tutti.");
+        }
+        return { kind: "internal-host-run", workspacePath, yes };
+    }
+    if (command === "ps") {
+        let manage = false;
+        for (const arg of args) {
+            if (arg === "--manage") {
+                manage = true;
+                continue;
+            }
+            if (isHelpArg(arg)) {
+                return { kind: "help", topic: "ps" };
+            }
+            throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Use `tutti ps --help` to see supported ps options.");
+        }
+        return { kind: "ps", manage };
+    }
+    if (command === "stop") {
+        if (hasHelpArg(args)) {
+            return { kind: "help", topic: "stop" };
+        }
+        const workspacePath = readOptionalWorkspace(args, cwd);
+        return { kind: "stop", ...(workspacePath === undefined ? {} : { workspacePath }) };
+    }
+    if (command === "invite") {
+        if (hasHelpArg(args)) {
+            return { kind: "help", topic: "invite" };
+        }
+        const workspacePath = readOptionalWorkspace(args, cwd);
+        return { kind: "invite", ...(workspacePath === undefined ? {} : { workspacePath }) };
+    }
+    if (command === "logs") {
+        if (hasHelpArg(args)) {
+            return { kind: "help", topic: "logs" };
+        }
+        let tail = 120;
+        const positional = [];
+        for (let index = 0; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--tail") {
+                const value = args[index + 1];
+                const parsed = Number(value);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                    throw new LaunchError("git_bootstrap_failed", "--tail requires a positive integer", "Run `tutti logs [workspace_path] --tail 120`.");
+                }
+                tail = parsed;
+                index += 1;
+            }
+            else {
+                positional.push(arg ?? "");
+            }
+        }
+        const workspacePath = readOptionalWorkspace(positional, cwd);
+        return { kind: "logs", tail, ...(workspacePath === undefined ? {} : { workspacePath }) };
+    }
+    if (command === "provider") {
+        const providerCommand = args.shift();
+        if (providerCommand === undefined || isHelpArg(providerCommand)) {
+            return { kind: "help", topic: "provider" };
+        }
+        if (providerCommand === "setup") {
+            if (hasHelpArg(args)) {
+                return { kind: "help", topic: "provider" };
+            }
+            const workspacePath = readOptionalWorkspace(args, cwd);
+            return { kind: "provider-setup", ...(workspacePath === undefined ? {} : { workspacePath }) };
+        }
+        if (providerCommand === "status") {
+            if (hasHelpArg(args)) {
+                return { kind: "help", topic: "provider" };
+            }
+            const workspacePath = readOptionalWorkspace(args, cwd);
+            return { kind: "provider-status", ...(workspacePath === undefined ? {} : { workspacePath }) };
+        }
+        return { kind: "help", topic: "provider" };
+    }
+    if (command === "doctor") {
+        if (hasHelpArg(args)) {
+            return { kind: "help", topic: "doctor" };
+        }
+        const workspacePath = readOptionalWorkspace(args, cwd);
+        return { kind: "doctor", ...(workspacePath === undefined ? {} : { workspacePath }) };
+    }
+    throw new LaunchError("git_bootstrap_failed", `Unsupported command: ${command}`, "Run `tutti --help` to see supported commands.");
+}
 //# sourceMappingURL=args.js.map

package/dist/server-shell/cli/cli.js

@@ -1,57 +1,184 @@
 #!/usr/bin/env node
-import { createInterface } from "node:readline/promises";
-import { formatLaunchError } from "./errors.js";
-import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown, } from "./host-lifecycle.js";
-import { parseLaunchCliArgs } from "./args.js";
+import { formatCliError } from "./errors.js";
+import { parseCliArgs } from "./args.js";
+import { runBackgroundLaunchCommand, runForegroundLaunchCommand, runInternalHostRunCommand, } from "./launch-command.js";
+import { resolveExistingProjectContext } from "./project-resolver.js";
+import { runProviderSetupTui } from "./provider-tui.js";
+import { runInviteCommand, runLogsCommand, runProviderStatusCommand, runPsManageCommand, runPsCommand, runStopCommand, } from "./runtime-commands.js";
+import { readCliVersion } from "./version.js";
 const HELP_TEXT = `Usage:
-  tutti launch [workspace_path] [--yes]
+  tutti launch [workspace_path] [--yes] [--foreground]
+  tutti ps [--manage]
+  tutti invite [workspace_path]
+  tutti stop [workspace_path]
+  tutti logs [workspace_path] [--tail 120]
+  tutti provider setup [workspace_path]
+  tutti provider status [workspace_path]
+  tutti doctor [workspace_path]
 
 Options:
-  --yes        Accept non-interactive launch confirmations.
-  -h, --help   Show this help message.
-`;
-function isHelpRequest(argv) {
-    return (argv.length === 0 ||
-        argv.includes("--help") ||
-        argv.includes("-h") ||
-        (argv[0] === "launch" && (argv[1] === "--help" || argv[1] === "-h")));
-}
-async function confirmFromTty(request) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        return false;
+  -h, --help      Show help.
+  -v, --version   Show version.
+
+Notes:
+  launch starts the host in the background by default.
+  provider setup stores credentials in the machine-local Tutti provider store.
+`;
+const LAUNCH_HELP_TEXT = `Usage:
+  tutti launch [workspace_path] [--yes] [--foreground]
+
+Starts or reconnects a Tutti project host.
+
+Options:
+  --yes          Accept non-interactive Git/bootstrap confirmations.
+  --foreground   Keep the host attached to this terminal for diagnostics.
+`;
+const PROVIDER_HELP_TEXT = `Usage:
+  tutti provider setup [workspace_path]
+  tutti provider status [workspace_path]
+
+Commands:
+  setup    Configure or replace the OpenAI-compatible provider credential.
+  status   Show the redacted provider status for a project.
+`;
+const PS_HELP_TEXT = `Usage:
+  tutti ps [--manage]
+
+Options:
+  --manage   Open the keyboard project manager.
+`;
+const INVITE_HELP_TEXT = `Usage:
+  tutti invite [workspace_path]
+
+Rotates a fresh join link and renders it as a terminal QR code.
+`;
+const STOP_HELP_TEXT = `Usage:
+  tutti stop [workspace_path]
+
+Stops the background Tutti host for a project.
+`;
+const LOGS_HELP_TEXT = `Usage:
+  tutti logs [workspace_path] [--tail 120]
+
+Shows recent host log lines from the machine-local Tutti log file.
+`;
+const DOCTOR_HELP_TEXT = `Usage:
+  tutti doctor [workspace_path]
+
+Prints local runtime, project, provider, and host diagnostics.
+`;
+function helpForTopic(topic) {
+    if (topic === "launch") {
+        return LAUNCH_HELP_TEXT;
+    }
+    if (topic === "provider") {
+        return PROVIDER_HELP_TEXT;
+    }
+    if (topic === "ps") {
+        return PS_HELP_TEXT;
+    }
+    if (topic === "invite") {
+        return INVITE_HELP_TEXT;
+    }
+    if (topic === "stop") {
+        return STOP_HELP_TEXT;
     }
-    const readline = createInterface({
-        input: process.stdin,
-        output: process.stdout,
+    if (topic === "logs") {
+        return LOGS_HELP_TEXT;
+    }
+    if (topic === "doctor") {
+        return DOCTOR_HELP_TEXT;
+    }
+    return HELP_TEXT;
+}
+async function runProviderSetupCommand(workspacePath) {
+    const project = resolveExistingProjectContext({
+        ...(workspacePath === undefined ? {} : { workspacePath }),
+    });
+    const result = await runProviderSetupTui({
+        projectName: project.display_name,
+        tuttiHome: project.tutti_home,
+        projectId: project.project_id,
+        initialBaseUrl: project.provider_base_url ?? "https://api.openai.com/v1",
     });
+    process.stdout.write([
+        "",
+        "Provider configured.",
+        `Base URL: ${result.base_url}`,
+        `Model: ${result.default_model}`,
+        `Key: ${result.redacted_key}`,
+        `Validated: ${result.validated_at}`,
+    ].join("\n"));
+    process.stdout.write("\n");
+}
+function runDoctorCommand(workspacePath) {
+    const checks = [];
+    checks.push(`Node: ${process.version}`);
+    checks.push(`Tutti: ${readCliVersion()}`);
     try {
-        const answer = await readline.question(`${request.message}\n\nContinue? [y/N] `);
-        return /^(y|yes)$/iu.test(answer.trim());
+        const project = resolveExistingProjectContext({
+            ...(workspacePath === undefined ? {} : { workspacePath }),
+        });
+        checks.push(`Project: ${project.display_name}`);
+        checks.push(`Project ID: ${project.project_id}`);
+        checks.push(`Provider: ${project.provider_config.status}`);
+        checks.push(`Host: ${project.runtime_endpoint === null ? "not running" : project.runtime_endpoint.base_url}`);
     }
-    finally {
-        readline.close();
+    catch (error) {
+        checks.push(`Project: unavailable (${error instanceof Error ? error.message : "unknown"})`);
     }
+    process.stdout.write(`${checks.join("\n")}\n`);
 }
 try {
-    const argv = process.argv.slice(2);
-    if (isHelpRequest(argv)) {
-        process.stdout.write(HELP_TEXT);
-    }
-    else {
-        const args = parseLaunchCliArgs(argv);
-        const result = await startLaunchProject({
-            workspacePath: args.workspacePath,
-            yes: args.yes,
-            confirm: confirmFromTty,
-        });
-        process.stdout.write(`${formatLaunchLifecycleResult(result, { hyperlinks: process.stdout.isTTY })}\n`);
-        if (result.kind === "hosting") {
-            await waitForForegroundHostShutdown(result.host);
-        }
+    const command = parseCliArgs(process.argv.slice(2));
+    switch (command.kind) {
+        case "help":
+            process.stdout.write(helpForTopic(command.topic));
+            break;
+        case "version":
+            process.stdout.write(`${readCliVersion()}\n`);
+            break;
+        case "launch":
+            if (command.foreground) {
+                await runForegroundLaunchCommand(command);
+            }
+            else {
+                await runBackgroundLaunchCommand(command);
+            }
+            break;
+        case "internal-host-run":
+            await runInternalHostRunCommand(command);
+            break;
+        case "ps":
+            if (command.manage) {
+                await runPsManageCommand();
+            }
+            else {
+                process.stdout.write(`${await runPsCommand()}\n`);
+            }
+            break;
+        case "stop":
+            process.stdout.write(`${await runStopCommand(command.workspacePath)}\n`);
+            break;
+        case "invite":
+            process.stdout.write(`${await runInviteCommand(command.workspacePath)}\n`);
+            break;
+        case "logs":
+            process.stdout.write(`${runLogsCommand(command.workspacePath, command.tail)}\n`);
+            break;
+        case "provider-setup":
+            await runProviderSetupCommand(command.workspacePath);
+            break;
+        case "provider-status":
+            process.stdout.write(`${runProviderStatusCommand(command.workspacePath)}\n`);
+            break;
+        case "doctor":
+            runDoctorCommand(command.workspacePath);
+            break;
     }
 }
 catch (error) {
-    console.error(formatLaunchError(error));
+    console.error(formatCliError(error));
     process.exitCode = 1;
 }
 //# sourceMappingURL=cli.js.map

package/dist/server-shell/cli/errors.d.ts

@@ -6,4 +6,5 @@ export declare class LaunchError extends Error {
     constructor(code: LaunchErrorCode, message: string, next: string, details?: Record<string, unknown>);
 }
 export declare function formatLaunchError(error: unknown): string;
+export declare function formatCliError(error: unknown): string;
 //# sourceMappingURL=errors.d.ts.map

package/dist/server-shell/cli/errors.js

@@ -38,6 +38,28 @@ export function formatLaunchError(error) {
         "Next: Retry after checking the local debug logs.",
     ].join("\n");
 }
+export function formatCliError(error) {
+    if (error instanceof LaunchError) {
+        const lines = ["Tutti command failed", "", `Code: ${error.code}`, `Reason: ${redactText(error.message)}`];
+        const detailLines = Object.entries(error.details)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `Detail ${key}: ${redactText(formatDetailValue(value))}`);
+        if (detailLines.length > 0) {
+            lines.push(...detailLines);
+        }
+        lines.push(`Next: ${redactText(error.next)}`);
+        return lines.join("\n");
+    }
+    const redactedError = redactError(error);
+    const reason = typeof redactedError === "string" ? redactedError : JSON.stringify(redactedError);
+    return [
+        "Tutti command failed",
+        "",
+        "Code: internal_error",
+        `Reason: ${reason ?? "Unknown error"}`,
+        "Next: Retry after checking the local debug logs.",
+    ].join("\n");
+}
 function formatDetailValue(value) {
     if (Array.isArray(value)) {
         return value.map((entry) => formatDetailValue(entry)).join(", ");

package/dist/server-shell/cli/host-server-runtime.js

@@ -298,6 +298,14 @@ export async function startForegroundHostServer(options) {
                 return result.projection;
             },
         },
+        ...(options.refreshRelayJoinUrl === undefined
+            ? {}
+            : {
+                refreshInvite: async () => {
+                    await options.refreshRelayJoinUrl?.();
+                    return options.getLaunchStatus?.() ?? {};
+                },
+            }),
         ...(options.getLaunchStatus === undefined ? {} : { getLaunchStatus: options.getLaunchStatus }),
     };
     let app;

package/dist/server-shell/cli/launch-command.d.ts

@@ -0,0 +1,15 @@
+import type { LaunchConfirmationRequest } from "./git-bootstrap.js";
+export declare function confirmFromTty(request: LaunchConfirmationRequest): Promise<boolean>;
+export declare function runForegroundLaunchCommand(options: {
+    workspacePath: string;
+    yes: boolean;
+}): Promise<void>;
+export declare function runInternalHostRunCommand(options: {
+    workspacePath: string;
+    yes: boolean;
+}): Promise<void>;
+export declare function runBackgroundLaunchCommand(options: {
+    workspacePath: string;
+    yes: boolean;
+}): Promise<void>;
+//# sourceMappingURL=launch-command.d.ts.map

package/dist/server-shell/cli/launch-command.js

@@ -0,0 +1,118 @@
+import { createInterface } from "node:readline/promises";
+import { basename } from "node:path";
+import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown } from "./host-lifecycle.js";
+import { prepareLaunchProject } from "./launch.js";
+import { spawnDetachedHost, waitForManagedHostReady } from "./managed-host.js";
+import { renderTerminalQr } from "./terminal-qr.js";
+import { renderTuttiTerminalLogo } from "./terminal-logo.js";
+import { runProviderSetupTui } from "./provider-tui.js";
+import { LaunchError } from "./errors.js";
+const CLEAR = "\u001B[2J\u001B[H";
+export async function confirmFromTty(request) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return false;
+    }
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question(`${request.message}\n\nContinue? [y/N] `);
+        return /^(y|yes)$/iu.test(answer.trim());
+    }
+    finally {
+        readline.close();
+    }
+}
+function projectName(preparation) {
+    return basename(preparation.workspace_root) || preparation.project_id;
+}
+async function waitForEnter() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return;
+    }
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        await readline.question("");
+    }
+    finally {
+        readline.close();
+    }
+}
+function renderCompletionPage(options) {
+    const isTty = process.stdout.isTTY === true;
+    return [
+        ...(isTty ? [CLEAR, renderTuttiTerminalLogo({ tty: true }), ""] : []),
+        "Tutti is running in the background.",
+        "",
+        `Project: ${options.projectName}`,
+        "",
+        `Join URL: ${options.joinUrl}`,
+        "",
+        renderTerminalQr(options.joinUrl),
+        "",
+        "Press Enter to close this page. The host will keep running in the background.",
+    ].join("\n");
+}
+async function ensureProviderConfigured(preparation) {
+    if (preparation.provider_status === "configured") {
+        return;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new LaunchError("provider_configuration_required", "Provider credentials are not configured for this project", "Run `tutti provider setup` from an interactive terminal, then run `tutti launch` again.");
+    }
+    await runProviderSetupTui({
+        projectName: projectName(preparation),
+        tuttiHome: preparation.tutti_home,
+        projectId: preparation.project_id,
+        initialBaseUrl: "https://api.openai.com/v1",
+    });
+}
+export async function runForegroundLaunchCommand(options) {
+    const result = await startLaunchProject({
+        workspacePath: options.workspacePath,
+        yes: options.yes,
+        confirm: confirmFromTty,
+    });
+    process.stdout.write(`${formatLaunchLifecycleResult(result, { hyperlinks: process.stdout.isTTY })}\n`);
+    if (result.kind === "hosting") {
+        await waitForForegroundHostShutdown(result.host);
+    }
+}
+export async function runInternalHostRunCommand(options) {
+    const result = await startLaunchProject({
+        workspacePath: options.workspacePath,
+        yes: options.yes,
+    });
+    if (result.kind === "hosting") {
+        await waitForForegroundHostShutdown(result.host);
+    }
+}
+export async function runBackgroundLaunchCommand(options) {
+    const preparation = await prepareLaunchProject({
+        workspacePath: options.workspacePath,
+        yes: options.yes,
+        confirm: confirmFromTty,
+    });
+    await ensureProviderConfigured(preparation);
+    spawnDetachedHost({
+        workspaceRoot: preparation.workspace_root,
+    });
+    const ready = await waitForManagedHostReady({
+        tuttiHome: preparation.tutti_home,
+        projectId: preparation.project_id,
+        workspaceRoot: preparation.workspace_root,
+    });
+    if (ready.join_url === undefined) {
+        throw new LaunchError("relay_registration_failed", "Host started but Relay did not return a visible join URL", "Run `tutti invite` to rotate a fresh invite link.");
+    }
+    process.stdout.write(`${renderCompletionPage({
+        projectName: projectName(preparation),
+        joinUrl: ready.join_url,
+    })}\n`);
+    await waitForEnter();
+}
+//# sourceMappingURL=launch-command.js.map