@xfey/tutti 0.1.5 → 0.1.7

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

@@ -1,57 +1,196 @@
 #!/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, runRestartCommand, } 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 restart [workspace_path] [--yes]
+  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 RESTART_HELP_TEXT = `Usage:
+  tutti restart [workspace_path] [--yes]
+
+Stops and relaunches 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 === "restart") {
+        return RESTART_HELP_TEXT;
+    }
+    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 "restart":
+            await runRestartCommand(command);
+            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,19 @@
+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>;
+export declare function runRestartCommand(options: {
+    workspacePath?: string;
+    yes: boolean;
+}): Promise<void>;
+//# sourceMappingURL=launch-command.d.ts.map

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

@@ -0,0 +1,127 @@
+import { createInterface } from "node:readline/promises";
+import { basename } from "node:path";
+import { redactText } from "@tutti/shared/utils";
+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 { runProviderSetupTui } from "./provider-tui.js";
+import { LaunchError } from "./errors.js";
+import { runStopCommand } from "./runtime-commands.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) {
+    return [
+        ...(process.stdout.isTTY ? [CLEAR] : []),
+        "Tutti is running in the background.",
+        "",
+        `Project: ${options.projectName}`,
+        `Workspace: ${redactText(options.workspaceRoot)}`,
+        "",
+        `Join URL: ${options.joinUrl}`,
+        "",
+        renderTerminalQr(options.joinUrl),
+        "",
+        "按下回车关闭页面，Host 会继续在后台运行。",
+    ].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),
+        workspaceRoot: preparation.workspace_root,
+        joinUrl: ready.join_url,
+    })}\n`);
+    await waitForEnter();
+}
+export async function runRestartCommand(options) {
+    await runStopCommand(options.workspacePath).catch(() => undefined);
+    await runBackgroundLaunchCommand({
+        workspacePath: options.workspacePath ?? process.cwd(),
+        yes: options.yes,
+    });
+}
+//# sourceMappingURL=launch-command.js.map

package/dist/server-shell/cli/local-control-client.d.ts

@@ -0,0 +1,30 @@
+import type { HostLocalLaunchStatus, HostLocalProjectProjection, HostLocalProviderConfigBody } from "../http/routes/local-control.js";
+import type { HostProviderConfigProjection } from "../http/routes/project-api/types.js";
+import type { MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type LocalControlFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export declare function readHostLocalLaunchStatus(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostLocalLaunchStatus>;
+export declare function rotateHostLocalInvite(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostLocalLaunchStatus>;
+export declare function readHostLocalProject(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostLocalProjectProjection>;
+export declare function readHostLocalProviderConfig(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostProviderConfigProjection>;
+export declare function writeHostLocalProviderConfig(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    body: HostLocalProviderConfigBody;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostProviderConfigProjection>;
+export declare function requestHostLocalShutdown(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<void>;
+//# sourceMappingURL=local-control-client.d.ts.map

package/dist/server-shell/cli/local-control-client.js

@@ -0,0 +1,73 @@
+const DEFAULT_TIMEOUT_MS = 2_000;
+async function fetchWithTimeout(fetchImpl, url, init = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    try {
+        return await fetchImpl(url, {
+            ...init,
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function requestLocalJson(options) {
+    const response = await fetchWithTimeout(options.fetchImpl ?? fetch, new URL(options.path, options.endpoint.base_url), {
+        method: options.method ?? "GET",
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${options.endpoint.token}`,
+            ...(options.body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+    }, options.timeoutMs);
+    if (!response.ok) {
+        throw new Error(`host-local ${options.path} returned HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+export async function readHostLocalLaunchStatus(options) {
+    return await requestLocalJson({
+        ...options,
+        path: "/host-local/v1/launch-status",
+    });
+}
+export async function rotateHostLocalInvite(options) {
+    return await requestLocalJson({
+        ...options,
+        method: "POST",
+        path: "/host-local/v1/invite/rotate",
+    });
+}
+export async function readHostLocalProject(options) {
+    return await requestLocalJson({
+        ...options,
+        path: "/host-local/v1/project",
+    });
+}
+export async function readHostLocalProviderConfig(options) {
+    return await requestLocalJson({
+        ...options,
+        path: "/host-local/v1/provider/config",
+    });
+}
+export async function writeHostLocalProviderConfig(options) {
+    return await requestLocalJson({
+        endpoint: options.endpoint,
+        ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+        method: "POST",
+        path: "/host-local/v1/provider/config",
+        body: options.body,
+    });
+}
+export async function requestHostLocalShutdown(options) {
+    await requestLocalJson({
+        ...options,
+        method: "POST",
+        path: "/host-local/v1/shutdown",
+    });
+}
+//# sourceMappingURL=local-control-client.js.map

package/dist/server-shell/cli/managed-host.d.ts

@@ -0,0 +1,19 @@
+import { type FetchLike } from "./host-runtime-endpoint.js";
+import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+import type { ProjectId } from "@tutti/shared/ids";
+export type ManagedHostReadyResult = {
+    endpoint: MachineRuntimeEndpointRecord;
+    join_url?: string;
+};
+export declare function spawnDetachedHost(options: {
+    workspaceRoot: string;
+    env?: NodeJS.ProcessEnv;
+}): void;
+export declare function waitForManagedHostReady(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+}): Promise<ManagedHostReadyResult>;
+//# sourceMappingURL=managed-host.d.ts.map

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

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
+import { getHostLogFilePath, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readHostLocalLaunchStatus, rotateHostLocalInvite } from "./local-control-client.js";
+const DEFAULT_READY_TIMEOUT_MS = 60_000;
+const READY_POLL_INTERVAL_MS = 250;
+function delay(ms) {
+    return new Promise((resolveDelay) => {
+        setTimeout(resolveDelay, ms);
+    });
+}
+function currentCliEntrypoint() {
+    const entrypoint = process.argv[1];
+    if (entrypoint === undefined || entrypoint.trim() === "") {
+        throw new Error("Cannot locate the current Tutti CLI entrypoint.");
+    }
+    return entrypoint;
+}
+export function spawnDetachedHost(options) {
+    const child = spawn(process.execPath, [
+        ...process.execArgv,
+        currentCliEntrypoint(),
+        "internal",
+        "host-run",
+        "--workspace",
+        resolve(options.workspaceRoot),
+        "--yes",
+    ], {
+        cwd: options.workspaceRoot,
+        detached: true,
+        env: {
+            ...process.env,
+            ...(options.env ?? {}),
+        },
+        stdio: "ignore",
+    });
+    child.unref();
+}
+function readHostLogTail(tuttiHome, maxLines = 80) {
+    try {
+        const text = readFileSync(getHostLogFilePath(tuttiHome), "utf8");
+        return text.split(/\r?\n/u).filter(Boolean).slice(-maxLines).join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+export async function waitForManagedHostReady(options) {
+    const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
+    const probe = createRuntimeEndpointProbe(options.fetchImpl ?? fetch);
+    let lastReason = "runtime endpoint was not written";
+    while (Date.now() < deadline) {
+        const endpoint = readMachineRuntimeEndpoint(options.tuttiHome, options.projectId);
+        if (endpoint === null) {
+            await delay(READY_POLL_INTERVAL_MS);
+            continue;
+        }
+        if (resolve(endpoint.workspace_root) !== resolve(options.workspaceRoot)) {
+            lastReason = "runtime endpoint points at a different workspace";
+            await delay(READY_POLL_INTERVAL_MS);
+            continue;
+        }
+        const health = await probe(endpoint);
+        if (health.kind === "stale") {
+            lastReason = health.reason;
+            await delay(READY_POLL_INTERVAL_MS);
+            continue;
+        }
+        try {
+            let status = await readHostLocalLaunchStatus({
+                endpoint,
+                ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+            });
+            if (status.relay?.join_url === undefined) {
+                status = await rotateHostLocalInvite({
+                    endpoint,
+                    ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+                });
+            }
+            if (status.relay?.join_url !== undefined) {
+                return {
+                    endpoint,
+                    join_url: status.relay.join_url,
+                };
+            }
+            lastReason = "host is running but Relay invite is not visible yet";
+        }
+        catch (error) {
+            lastReason = error instanceof Error ? error.message : "host-local launch status failed";
+        }
+        await delay(READY_POLL_INTERVAL_MS);
+    }
+    const tail = readHostLogTail(options.tuttiHome);
+    throw new Error([
+        `Tutti host did not become ready before timeout: ${lastReason}`,
+        tail.length === 0 ? "" : `Recent host log:\n${tail}`,
+    ]
+        .filter(Boolean)
+        .join("\n"));
+}
+//# sourceMappingURL=managed-host.js.map