@xfey/tutti 0.1.6 → 0.1.7

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

package/dist/server-shell/cli/project-resolver.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type OpenAiProviderConfigProjection } from "../../providers/openai/index.js";
+import { type MachineProjectBindingRecord, type MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type ExistingProjectContext = {
+    workspace_root: string;
+    tutti_home: string;
+    project_id: ProjectId;
+    display_name: string;
+    binding: MachineProjectBindingRecord | null;
+    runtime_endpoint: MachineRuntimeEndpointRecord | null;
+    provider_config: OpenAiProviderConfigProjection;
+    provider_base_url?: string;
+};
+export declare function resolveExistingProjectContext(options: {
+    workspacePath?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ExistingProjectContext;
+//# sourceMappingURL=project-resolver.d.ts.map

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

@@ -0,0 +1,35 @@
+import { resolve } from "node:path";
+import { readOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, resolveTuttiHome, } from "../../providers/openai/index.js";
+import { LaunchError } from "./errors.js";
+import { assertSafeProjectRoot } from "./git-bootstrap.js";
+import { readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readProjectDisplayName, readProjectIdentity } from "./project-identity.js";
+export function resolveExistingProjectContext(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const workspaceRoot = resolve(cwd, options.workspacePath ?? ".");
+    assertSafeProjectRoot(workspaceRoot);
+    const identity = readProjectIdentity(workspaceRoot);
+    if (identity.kind !== "present") {
+        throw new LaunchError("project_identity_conflict", "Current directory is not a Tutti project", "Run `tutti launch` from a project root first.");
+    }
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const binding = readMachineProjectBinding(tuttiHome, identity.project_id);
+    const projectConfig = readProjectOpenAiProviderConfig(tuttiHome, identity.project_id);
+    return {
+        workspace_root: workspaceRoot,
+        tutti_home: tuttiHome,
+        project_id: identity.project_id,
+        display_name: readProjectDisplayName(workspaceRoot) ?? identity.project_id,
+        binding,
+        runtime_endpoint: readMachineRuntimeEndpoint(tuttiHome, identity.project_id),
+        provider_config: readOpenAiProviderConfigProjection({
+            tuttiHome,
+            projectId: identity.project_id,
+        }),
+        ...(projectConfig.kind === "ok" && projectConfig.config.api_base_url !== undefined
+            ? { provider_base_url: projectConfig.config.api_base_url }
+            : {}),
+    };
+}
+//# sourceMappingURL=project-resolver.js.map

package/dist/server-shell/cli/provider-tui.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectId } from "@tutti/shared/ids";
+export type ProviderSetupResult = {
+    base_url: string;
+    redacted_key: string;
+    default_model: string;
+    validated_at: string;
+};
+export declare function runProviderSetupTui(options: {
+    projectName: string;
+    tuttiHome: string;
+    projectId: ProjectId;
+    initialBaseUrl?: string;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}): Promise<ProviderSetupResult>;
+//# sourceMappingURL=provider-tui.d.ts.map

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

@@ -0,0 +1,226 @@
+import { emitKeypressEvents } from "node:readline";
+import { redactError } from "@tutti/shared/utils";
+import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, } from "../../providers/openai/index.js";
+const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+const HIDE_CURSOR = "\u001B[?25l";
+const SHOW_CURSOR = "\u001B[?25h";
+const CLEAR = "\u001B[2J\u001B[H";
+function fieldLine(options) {
+    const active = options.index === options.selected;
+    const marker = active ? ">" : " ";
+    const value = options.secret && options.value.length > 0 ? "*".repeat(options.value.length) : options.value;
+    return `${marker} ${options.label.padEnd(10)} ${value}${active ? " _" : ""}`;
+}
+function renderProviderForm(options) {
+    const lines = [
+        CLEAR,
+        HIDE_CURSOR,
+        "Tutti Provider Setup",
+        "",
+        `Project: ${options.projectName}`,
+        "Use Up/Down to move, type to edit, Enter to validate, Ctrl-C to cancel.",
+        "",
+        fieldLine({
+            index: 0,
+            selected: options.state.selected,
+            label: "Base URL",
+            value: options.state.baseUrl,
+        }),
+        fieldLine({
+            index: 1,
+            selected: options.state.selected,
+            label: "API Key",
+            value: options.state.apiKey,
+            secret: true,
+        }),
+        "",
+    ];
+    if (options.state.error !== undefined) {
+        lines.push(`Error: ${options.state.error}`, "");
+    }
+    if (options.footer !== undefined) {
+        lines.push(options.footer);
+    }
+    return lines.join("\n");
+}
+function validationFailureMessage(result) {
+    if (result.kind === "configured") {
+        return "";
+    }
+    const retry = result.retryable ? " Retry after the provider recovers." : "";
+    return `${result.reason}.${retry}`;
+}
+function waitForKeypress(stdin) {
+    return new Promise((resolve, reject) => {
+        const onKeypress = (_character, key) => {
+            cleanup();
+            if (key.ctrl === true && key.name === "c") {
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            resolve();
+        };
+        const cleanup = () => {
+            stdin.off("keypress", onKeypress);
+            if (stdin.isTTY) {
+                stdin.setRawMode(false);
+            }
+        };
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+        }
+        stdin.once("keypress", onKeypress);
+    });
+}
+async function readProviderForm(options) {
+    const state = {
+        selected: 0,
+        baseUrl: options.initialBaseUrl ?? DEFAULT_BASE_URL,
+        apiKey: "",
+        error: undefined,
+    };
+    return await new Promise((resolve, reject) => {
+        const render = () => {
+            options.stdout.write(renderProviderForm({ projectName: options.projectName, state }));
+        };
+        const cleanup = () => {
+            options.stdin.off("keypress", onKeypress);
+            if (options.stdin.isTTY) {
+                options.stdin.setRawMode(false);
+            }
+            options.stdout.write(SHOW_CURSOR);
+        };
+        const onKeypress = (character, key) => {
+            if (key.ctrl === true && key.name === "c") {
+                cleanup();
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            if (key.name === "escape") {
+                cleanup();
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            if (key.name === "up") {
+                state.selected = state.selected === 0 ? 1 : 0;
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (key.name === "down" || key.name === "tab") {
+                state.selected = state.selected === 0 ? 1 : 0;
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (key.name === "return") {
+                if (state.baseUrl.trim() === "" || state.apiKey.trim() === "") {
+                    state.error = "Base URL and API key are required.";
+                    render();
+                    return;
+                }
+                cleanup();
+                resolve({ baseUrl: state.baseUrl.trim(), apiKey: state.apiKey.trim() });
+                return;
+            }
+            if (key.name === "backspace") {
+                if (state.selected === 0) {
+                    state.baseUrl = state.baseUrl.slice(0, -1);
+                }
+                else {
+                    state.apiKey = state.apiKey.slice(0, -1);
+                }
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (character !== undefined && character >= " " && character !== "\u007F") {
+                if (state.selected === 0) {
+                    state.baseUrl += character;
+                }
+                else {
+                    state.apiKey += character;
+                }
+                state.error = undefined;
+                render();
+            }
+        };
+        emitKeypressEvents(options.stdin);
+        if (options.stdin.isTTY) {
+            options.stdin.setRawMode(true);
+        }
+        options.stdin.on("keypress", onKeypress);
+        render();
+    });
+}
+function renderChecking(projectName, frame) {
+    const frames = ["|", "/", "-", "\\"];
+    const indicator = frames[frame % frames.length] ?? "|";
+    return [
+        CLEAR,
+        HIDE_CURSOR,
+        "Tutti Provider Setup",
+        "",
+        `Project: ${projectName}`,
+        "",
+        `${indicator} Checking provider connection with ${DEFAULT_OPENAI_MODEL}...`,
+    ].join("\n");
+}
+export async function runProviderSetupTui(options) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    if (!stdin.isTTY || !stdout.isTTY) {
+        throw new Error("Provider setup requires an interactive terminal.");
+    }
+    let initialBaseUrl = options.initialBaseUrl;
+    while (true) {
+        const input = await readProviderForm({
+            projectName: options.projectName,
+            ...(initialBaseUrl === undefined ? {} : { initialBaseUrl }),
+            stdin,
+            stdout,
+        });
+        initialBaseUrl = input.baseUrl;
+        let frame = 0;
+        const interval = setInterval(() => {
+            stdout.write(renderChecking(options.projectName, frame));
+            frame += 1;
+        }, 120);
+        try {
+            stdout.write(renderChecking(options.projectName, frame));
+            const result = await configureProjectOpenAiProvider({
+                tuttiHome: options.tuttiHome,
+                projectId: options.projectId,
+                apiBaseUrl: input.baseUrl,
+                apiKey: input.apiKey,
+            });
+            clearInterval(interval);
+            stdout.write(SHOW_CURSOR);
+            if (result.kind === "configured") {
+                return {
+                    base_url: input.baseUrl,
+                    redacted_key: result.projection.redacted_key,
+                    default_model: result.projection.default_model,
+                    validated_at: result.projection.validated_at,
+                };
+            }
+            stdout.write(renderProviderForm({
+                projectName: options.projectName,
+                state: {
+                    selected: 1,
+                    baseUrl: input.baseUrl,
+                    apiKey: input.apiKey,
+                    error: validationFailureMessage(result),
+                },
+                footer: "Press any key to edit and try again.",
+            }));
+            await waitForKeypress(stdin);
+        }
+        catch (error) {
+            clearInterval(interval);
+            stdout.write(SHOW_CURSOR);
+            throw new Error(`Provider setup failed: ${String(redactError(error))}`, { cause: error });
+        }
+    }
+}
+//# sourceMappingURL=provider-tui.js.map

package/dist/server-shell/cli/runtime-commands.d.ts

@@ -0,0 +1,32 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type FetchLike } from "./host-runtime-endpoint.js";
+import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type RuntimeProjectRow = {
+    project_id: ProjectId;
+    status: "online" | "stale";
+    display_name: string;
+    workspace_root: string;
+    endpoint?: string;
+    provider_status?: string;
+    relay_project_ref?: string;
+    join_url?: string;
+};
+export declare function listRuntimeProjects(options?: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    fetchImpl?: FetchLike;
+}): Promise<RuntimeProjectRow[]>;
+export declare function runPsCommand(): Promise<string>;
+export declare function runPsManageCommand(options?: {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}): Promise<void>;
+export declare function runStopCommand(workspacePath?: string): Promise<string>;
+export declare function runInviteCommand(workspacePath?: string): Promise<string>;
+export declare function runProviderStatusCommand(workspacePath?: string): string;
+export declare function runLogsCommand(workspacePath?: string, tailLines?: number): string;
+export declare function readRuntimeEndpointForProject(tuttiHome: string, projectId: ProjectId): MachineRuntimeEndpointRecord | null;
+export declare function runtimeEndpointPathForProject(tuttiHome: string, projectId: ProjectId): string;
+export declare function projectLocalStoreRoot(tuttiHome: string, projectId: ProjectId): string;
+export declare function resolveWorkspacePath(value: string | undefined): string;
+//# sourceMappingURL=runtime-commands.d.ts.map