@xfey/tenso 0.1.130

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

@@ -0,0 +1,429 @@
+import { emitKeypressEvents } from "node:readline";
+import { redactError } from "@tutti/shared/utils";
+import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, discoverOpenAiModels, } from "../../providers/openai/index.js";
+import { LaunchError } from "./errors.js";
+import { appendHostLogLine, getHostLogFilePath } from "./machine-local.js";
+import { renderTuttiTerminalLogo } from "./terminal-logo.js";
+const HIDE_CURSOR = "\u001B[?25l";
+const SHOW_CURSOR = "\u001B[?25h";
+const BLINK_ON = "\u001B[5m";
+const BLINK_OFF = "\u001B[25m";
+const CLEAR = "\u001B[2J\u001B[H";
+const FIELD_BOX_WIDTH = 60;
+const MODEL_LIST_WINDOW = 8;
+function providerSetupCancelled() {
+    return new LaunchError("provider_setup_cancelled", "Provider setup cancelled.", "Run the command again when you are ready.");
+}
+function renderFieldInput(options) {
+    const value = options.secret && options.value.length > 0 ? "*".repeat(options.value.length) : options.value;
+    const visibleValue = value.length >= FIELD_BOX_WIDTH ? `<${value.slice(-(FIELD_BOX_WIDTH - 2))}` : value;
+    const cursor = `${BLINK_ON}_${BLINK_OFF}`;
+    const plainLength = visibleValue.length + 1;
+    const padding = Math.max(0, FIELD_BOX_WIDTH - plainLength);
+    return [
+        `+${"-".repeat(FIELD_BOX_WIDTH + 2)}+`,
+        `| ${visibleValue}${cursor}${" ".repeat(padding)} |`,
+        `+${"-".repeat(FIELD_BOX_WIDTH + 2)}+`,
+    ];
+}
+function modelOptionsWithCustom(state) {
+    return [...(state.modelOptions ?? []), ""];
+}
+function selectedModelIndex(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = state.selectedModelIndex ?? 0;
+    return Math.min(Math.max(0, selected), Math.max(0, options.length - 1));
+}
+function selectedModelValue(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = selectedModelIndex(state);
+    if (selected < (state.modelOptions ?? []).length) {
+        return options[selected] ?? "";
+    }
+    return state.customModel?.trim() ?? "";
+}
+function renderModelOptions(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = selectedModelIndex(state);
+    const modelCount = state.modelOptions?.length ?? 0;
+    const windowStart = Math.max(0, Math.min(selected - Math.floor(MODEL_LIST_WINDOW / 2), options.length - MODEL_LIST_WINDOW));
+    const windowEnd = Math.min(options.length, windowStart + MODEL_LIST_WINDOW);
+    const lines = [];
+    if (windowStart > 0) {
+        lines.push("  ...");
+    }
+    for (let index = windowStart; index < windowEnd; index += 1) {
+        const marker = index === selected ? ">" : " ";
+        const label = index < modelCount ? options[index] : "Custom model";
+        const suffix = index < modelCount ? "" : " (type your own)";
+        lines.push(`${marker} ${label}${suffix}`);
+    }
+    if (windowEnd < options.length) {
+        lines.push("  ...");
+    }
+    if (selected === modelCount) {
+        lines.push("", ...renderFieldInput({ value: state.customModel ?? "" }));
+    }
+    return lines;
+}
+function renderProviderField(state) {
+    if (state.step === "base-url") {
+        return [
+            "Step 1/3  Base URL",
+            "OpenAI-compatible Responses API base URL; must expose POST /responses.",
+            "",
+            ...renderFieldInput({
+                value: state.baseUrl,
+            }),
+            "",
+            "[Enter] Continue    [Esc] Cancel",
+        ];
+    }
+    if (state.step === "api-key") {
+        return [
+            "Step 2/3  API Key",
+            "Stored only in the machine-local Tenso credential store.",
+            "",
+            ...renderFieldInput({
+                value: state.apiKey,
+                secret: true,
+            }),
+            "",
+            "[Enter] Continue    [Esc] Back to Base URL",
+        ];
+    }
+    return [
+        "Step 3/3  Model",
+        state.modelListStatus === "loaded"
+            ? "Choose a model with Up/Down, or move to Custom model and type one."
+            : "Could not read the model list. Type a model name in Custom model.",
+        "",
+        ...renderModelOptions(state),
+        "",
+        state.error === undefined
+            ? "[Enter] Validate    [Esc] Back to API Key"
+            : "[Enter] Retry    [Esc] Back to API Key",
+    ];
+}
+export function renderProviderForm(options) {
+    const lines = [
+        CLEAR,
+        HIDE_CURSOR,
+        renderTuttiTerminalLogo({ tty: options.tty === true }),
+        "",
+        "Provider setup",
+        "Connect a provider compatible with OpenAI's Responses API.",
+        "",
+        ...renderProviderField(options.state),
+        "",
+    ];
+    if (options.state.error !== undefined) {
+        lines.push(`Error: ${options.state.error}`, "");
+    }
+    if (options.footer !== undefined) {
+        lines.push(options.footer);
+    }
+    return lines.join("\n");
+}
+export function providerValidationFailureMessage(result) {
+    if (result.kind === "configured") {
+        return "";
+    }
+    switch (result.reason) {
+        case "provider_auth_invalid":
+            return "API key was rejected.";
+        case "provider_model_unavailable":
+            return "Default model is unavailable for this provider.";
+        case "provider_quota_or_billing_required":
+            return "Provider quota or billing is not available.";
+        case "provider_rate_limited":
+            return "Provider is rate limited. Try again later.";
+        case "provider_network_error":
+            return "Could not reach a Responses API-compatible endpoint.";
+    }
+}
+function providerValidationExceptionMessage(logged) {
+    if (logged) {
+        return "Could not validate the provider connection. Details were written to the host log.";
+    }
+    return "Could not validate the provider connection. Host log could not be written.";
+}
+export function writeProviderSetupValidationLog(options) {
+    const logEvent = {
+        ts: (options.now ?? (() => new Date()))().toISOString(),
+        level: "error",
+        scope: "provider_setup",
+        ...options.event,
+    };
+    const redactedLogEvent = {
+        ...logEvent,
+        ...(logEvent.error === undefined ? {} : { error: redactError(logEvent.error) }),
+    };
+    try {
+        appendHostLogLine(getHostLogFilePath(options.tuttiHome), JSON.stringify(redactError(redactedLogEvent)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readProviderForm(options) {
+    const state = {
+        step: options.initialStep ?? "base-url",
+        baseUrl: options.initialBaseUrl ?? "",
+        apiKey: options.initialApiKey ?? "",
+        error: options.initialError,
+    };
+    return await new Promise((resolve, reject) => {
+        let busy = false;
+        const render = () => {
+            options.stdout.write(renderProviderForm({
+                state,
+                tty: options.stdout.isTTY === true,
+            }));
+        };
+        const cleanup = () => {
+            options.stdin.off("keypress", onKeypress);
+            if (options.stdin.isTTY) {
+                options.stdin.setRawMode(false);
+            }
+            options.stdout.write(SHOW_CURSOR);
+        };
+        const openModelStep = async () => {
+            busy = true;
+            state.error = undefined;
+            options.stdout.write(renderModelDiscovery(options.stdout.isTTY === true));
+            const discoverModels = options.discoverModels ?? discoverOpenAiModels;
+            const result = await discoverModels({
+                apiKey: state.apiKey.trim(),
+                apiBaseUrl: state.baseUrl.trim(),
+            }).catch(() => ({
+                kind: "unavailable",
+                reason: "model_list_unavailable",
+            }));
+            if (result.kind === "ok") {
+                state.modelOptions = result.models;
+                state.modelListStatus = "loaded";
+                const defaultIndex = result.models.indexOf(DEFAULT_OPENAI_MODEL);
+                state.selectedModelIndex = defaultIndex >= 0 ? defaultIndex : 0;
+            }
+            else {
+                state.modelOptions = [];
+                state.modelListStatus = "unavailable";
+                state.selectedModelIndex = 0;
+            }
+            state.customModel = "";
+            state.step = "model";
+            busy = false;
+            render();
+        };
+        const onKeypress = (character, key) => {
+            if (busy) {
+                return;
+            }
+            if (key.ctrl === true && key.name === "c") {
+                cleanup();
+                reject(providerSetupCancelled());
+                return;
+            }
+            if (key.name === "escape") {
+                if (state.step === "api-key") {
+                    state.step = "base-url";
+                    state.error = undefined;
+                    render();
+                    return;
+                }
+                if (state.step === "model") {
+                    state.step = "api-key";
+                    state.error = undefined;
+                    render();
+                    return;
+                }
+                cleanup();
+                reject(providerSetupCancelled());
+                return;
+            }
+            if (key.name === "return") {
+                if (state.step === "base-url") {
+                    if (state.baseUrl.trim() === "") {
+                        state.error = "Base URL is required.";
+                        render();
+                        return;
+                    }
+                    state.step = "api-key";
+                    state.error = undefined;
+                    render();
+                    return;
+                }
+                if (state.step === "api-key") {
+                    if (state.apiKey.trim() === "") {
+                        state.error = "API key is required.";
+                        render();
+                        return;
+                    }
+                    void openModelStep();
+                    return;
+                }
+                const model = selectedModelValue(state);
+                if (model === "") {
+                    state.error = "Model name is required.";
+                    render();
+                    return;
+                }
+                cleanup();
+                resolve({
+                    baseUrl: state.baseUrl.trim(),
+                    apiKey: state.apiKey.trim(),
+                    defaultModel: model,
+                });
+                return;
+            }
+            if (state.step === "model" && (key.name === "up" || key.name === "down")) {
+                const optionsWithCustom = modelOptionsWithCustom(state);
+                const delta = key.name === "up" ? -1 : 1;
+                state.selectedModelIndex =
+                    (selectedModelIndex(state) + delta + optionsWithCustom.length) % optionsWithCustom.length;
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (key.name === "backspace") {
+                if (state.step === "base-url") {
+                    state.baseUrl = state.baseUrl.slice(0, -1);
+                }
+                else if (state.step === "api-key") {
+                    state.apiKey = state.apiKey.slice(0, -1);
+                }
+                else if (selectedModelIndex(state) === (state.modelOptions?.length ?? 0)) {
+                    state.customModel = (state.customModel ?? "").slice(0, -1);
+                }
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (character !== undefined && character >= " " && character !== "\u007F") {
+                if (state.step === "base-url") {
+                    state.baseUrl += character;
+                }
+                else if (state.step === "api-key") {
+                    state.apiKey += character;
+                }
+                else {
+                    state.selectedModelIndex = state.modelOptions?.length ?? 0;
+                    state.customModel = `${state.customModel ?? ""}${character}`;
+                }
+                state.error = undefined;
+                render();
+            }
+        };
+        emitKeypressEvents(options.stdin);
+        if (options.stdin.isTTY) {
+            options.stdin.setRawMode(true);
+        }
+        options.stdin.on("keypress", onKeypress);
+        render();
+    });
+}
+function renderModelDiscovery(tty) {
+    return [
+        CLEAR,
+        HIDE_CURSOR,
+        renderTuttiTerminalLogo({ tty }),
+        "",
+        "Provider setup",
+        "Looking up available models for this provider.",
+        "",
+        "Checking model list...",
+    ].join("\n");
+}
+function renderChecking(frame, tty, model) {
+    const frames = ["|", "/", "-", "\\"];
+    const indicator = frames[frame % frames.length] ?? "|";
+    return [
+        CLEAR,
+        HIDE_CURSOR,
+        renderTuttiTerminalLogo({ tty }),
+        "",
+        "Provider setup",
+        "Validating the configured Responses API endpoint.",
+        "",
+        `${indicator} Checking provider connection with ${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 LaunchError("provider_configuration_required", "Provider setup requires an interactive terminal.", "Run `tenso provider setup` from an interactive terminal.");
+    }
+    let initialBaseUrl;
+    let initialApiKey = "";
+    let initialStep = "base-url";
+    let initialError;
+    while (true) {
+        const input = await readProviderForm({
+            ...(initialBaseUrl === undefined ? {} : { initialBaseUrl }),
+            ...(initialApiKey === "" ? {} : { initialApiKey }),
+            initialStep,
+            ...(initialError === undefined ? {} : { initialError }),
+            stdin,
+            stdout,
+        });
+        initialBaseUrl = input.baseUrl;
+        initialApiKey = input.apiKey;
+        initialStep = "api-key";
+        let frame = 0;
+        const interval = setInterval(() => {
+            stdout.write(renderChecking(frame, stdout.isTTY === true, input.defaultModel));
+            frame += 1;
+        }, 120);
+        try {
+            stdout.write(renderChecking(frame, stdout.isTTY === true, input.defaultModel));
+            const result = await configureProjectOpenAiProvider({
+                tuttiHome: options.tuttiHome,
+                projectId: options.projectId,
+                apiBaseUrl: input.baseUrl,
+                apiKey: input.apiKey,
+                defaultModel: input.defaultModel,
+            });
+            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,
+                };
+            }
+            writeProviderSetupValidationLog({
+                tuttiHome: options.tuttiHome,
+                event: {
+                    event: "provider_validation_failed",
+                    project_id: options.projectId,
+                    reason: result.reason,
+                    retryable: result.retryable,
+                    ...(result.diagnostic === undefined ? {} : { diagnostic: result.diagnostic }),
+                },
+            });
+            initialError = providerValidationFailureMessage(result);
+        }
+        catch (error) {
+            clearInterval(interval);
+            stdout.write(SHOW_CURSOR);
+            if (error instanceof LaunchError) {
+                throw error;
+            }
+            const logged = writeProviderSetupValidationLog({
+                tuttiHome: options.tuttiHome,
+                event: {
+                    event: "provider_validation_exception",
+                    project_id: options.projectId,
+                    error,
+                },
+            });
+            initialError = providerValidationExceptionMessage(logged);
+        }
+    }
+}
+//# sourceMappingURL=provider-tui.js.map

package/dist/server-shell/cli/relay-registration.d.ts

@@ -0,0 +1,38 @@
+import { type ConnectRelayHostTunnelOptions, type RelayHostTunnelHandle, type RegisterRelayHostConnectionOptions, type RegisterRelayHostConnectionResponse } from "@tutti/relay-client";
+import { type HostConnectionRef, type RelayProjectRef } from "@tutti/shared/ids";
+import type { FeishuSetupProjection } from "@tutti/shared/schemas/internal";
+import { LaunchError } from "./errors.js";
+import type { LaunchPreparationResult } from "./launch.js";
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type HostLaunchRelaySummary = {
+    relay_project_ref: RelayProjectRef;
+    host_connection_ref: HostConnectionRef;
+    join_url?: string;
+    join_url_visibility: "visible_once" | "not_recoverable";
+    join_token_expires_at?: string;
+    join_token_reusable: boolean;
+    tunnel_url: string;
+    connected_at: string;
+    surface_profile?: LaunchPreparationResult["machine_local"]["binding"]["surface_profile"];
+    feishu_setup?: FeishuSetupProjection;
+};
+export type RelayHostConnectionRegistrar = (options: RegisterRelayHostConnectionOptions) => Promise<RegisterRelayHostConnectionResponse>;
+export type RelayHostTunnelConnector = (options: ConnectRelayHostTunnelOptions) => RelayHostTunnelHandle;
+export type RegisteredRelayHostConnection = {
+    summary: HostLaunchRelaySummary;
+    hostConnectionToken: string;
+    heartbeatIntervalMs: number;
+};
+export type HostRelayRegistrationPreparation = Pick<LaunchPreparationResult, "tutti_home" | "project_id" | "workspace_root" | "relay_url"> & Partial<Pick<LaunchPreparationResult, "machine_local">>;
+export declare function relayErrorToLaunchError(error: unknown, relayUrl: string): LaunchError;
+export declare function registerHostWithRelay(options: {
+    preparation: HostRelayRegistrationPreparation;
+    fetchImpl: FetchLike;
+    registerRelayHostConnection: RelayHostConnectionRegistrar;
+    serverVersion: string;
+    joinTokenMode?: "reuse_active" | "rotate";
+    signal?: AbortSignal;
+    now?: () => Date;
+}): Promise<RegisteredRelayHostConnection>;
+export {};
+//# sourceMappingURL=relay-registration.d.ts.map

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

@@ -0,0 +1,140 @@
+import { basename } from "node:path";
+import { RelayHostControlClientError, } from "@tutti/relay-client";
+import { createIdempotencyKey, } from "@tutti/shared/ids";
+import { deleteFeishuOwnerAccountHandoff, readFeishuOwnerAccountHandoff, readHostRegistrationSecret, updateMachineProjectRelayBinding, } from "./machine-local.js";
+import { LaunchError } from "./errors.js";
+import { readProjectDisplayName } from "./project-identity.js";
+import { findNativeManagedProject } from "../managed-access/state.js";
+import { realpathSync } from "node:fs";
+import { ManagedLocalStateError } from "../managed-access/private-store.js";
+import { reconcileNativePreparation } from "../managed-access/transport.js";
+export function relayErrorToLaunchError(error, relayUrl) {
+    if (error instanceof LaunchError) {
+        return error;
+    }
+    if (error instanceof RelayHostControlClientError) {
+        if (error.code === "relay_unavailable") {
+            return new LaunchError("relay_unavailable", `Cannot register host connection because Relay is unavailable at ${relayUrl}`, "Keep the project host stopped, start or fix Relay, then run `tenso launch` again.");
+        }
+        if (error.relayErrorCode === "project_surface_conflict") {
+            return new LaunchError("project_surface_conflict", "Relay rejected a different collaboration surface for this project", "Keep the Host stopped and inspect the machine project binding and Relay project metadata.");
+        }
+        return new LaunchError("relay_registration_failed", `Relay rejected host registration${error.relayErrorCode === undefined ? "" : ` (${error.relayErrorCode})`}`, error.retryable
+            ? "Retry after Relay recovers, or run `tenso launch` again with a new registration command."
+            : "Check Relay host-control registration state and this machine's host registration credential.");
+    }
+    return new LaunchError("relay_registration_failed", "Relay host registration failed before a join URL could be created", "Retry `tenso launch`; if it keeps failing, inspect Relay host-control logs.");
+}
+export async function registerHostWithRelay(options) {
+    const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
+    const surfaceProfile = options.preparation.machine_local?.binding.surface_profile ??
+        { kind: "standalone", version: 1 };
+    const managed = findNativeManagedProject({
+        tuttiHome: options.preparation.tutti_home,
+        relayUrl: options.preparation.relay_url,
+        projectId: options.preparation.project_id,
+    });
+    if (managed !== null &&
+        (managed.journal.workspace_root !== realpathSync(options.preparation.workspace_root) ||
+            managed.journal.surface !== surfaceProfile.kind ||
+            managed.journal.host_registration_secret !== hostSecret.secret))
+        throw new ManagedLocalStateError("managed_registration_mismatch");
+    // A lost registration response is reconciled independently before retry. Once
+    // activated, ordinary collaboration reconnect does not require browser consent.
+    if (managed !== null && managed.journal.state !== "registered") {
+        await reconcileNativePreparation({
+            state: managed.state,
+            requestRef: managed.journal.request_ref,
+            fetchImpl: (input, init) => options.fetchImpl(input instanceof Request ? input.url : input, init),
+            now: options.now?.() ?? new Date(),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
+    }
+    const pendingManaged = managed !== null && managed.state.read(managed.journal.request_ref).state !== "registered";
+    const registrationOptions = {
+        relayUrl: options.preparation.relay_url,
+        projectId: options.preparation.project_id,
+        hostRegistrationSecret: hostSecret.secret,
+        displayName: readProjectDisplayName(options.preparation.workspace_root) ??
+            (basename(options.preparation.workspace_root) || options.preparation.project_id),
+        serverVersion: options.serverVersion,
+        surfaceProfile,
+        commandId: createIdempotencyKey(),
+        joinToken: { mode: options.joinTokenMode ?? "rotate" },
+        capabilities: {
+            integration_source_ingestion_v1: true,
+            integration_development_bot_v1: true,
+            integration_clarification_v1: true,
+            feishu_supporting_reads_v1: true,
+            request_status_v1: true,
+            integration_external_references_v1: true,
+            integration_attachment_ingestion_v1: true,
+            integration_managed_reference_ingestion_v1: true,
+            integration_outbound_v1: true,
+            integration_approval_decision_v1: true,
+        },
+        fetch: options.fetchImpl,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        ...(options.now === undefined ? {} : { issuedAt: options.now() }),
+    };
+    const accountHandoff = surfaceProfile.kind === "feishu" && managed === null
+        ? readFeishuOwnerAccountHandoff(options.preparation.tutti_home, options.preparation.project_id, options.now?.() ?? new Date())
+        : null;
+    if (accountHandoff !== null) {
+        registrationOptions.accountHandoffToken = accountHandoff.token;
+    }
+    if (pendingManaged && managed !== null) {
+        registrationOptions.managedBootstrap = managed.state.bootstrap(managed.journal.request_ref, options.now?.() ?? new Date());
+    }
+    const response = await options.registerRelayHostConnection(registrationOptions);
+    if (response.disposition.kind !== "registered" || response.result === undefined) {
+        throw new LaunchError("relay_registration_failed", "Relay host registration did not complete", "Retry `tenso launch` with a new registration command.");
+    }
+    const result = response.result;
+    if (pendingManaged && managed !== null) {
+        if (result.managed_authority === undefined ||
+            result.managed_authority.relay_project_ref !== result.relay_project.relay_project_ref)
+            throw new ManagedLocalStateError("managed_registration_mismatch");
+    }
+    if ((result.relay_project.surface_profile?.kind ?? "standalone") !== surfaceProfile.kind) {
+        throw new LaunchError("project_surface_conflict", "Relay returned a different project collaboration surface", "Keep the Host stopped and inspect the machine project binding and Relay project metadata.");
+    }
+    if (surfaceProfile.kind === "standalone" &&
+        (options.joinTokenMode ?? "rotate") === "rotate" &&
+        (result.join_token?.visibility !== "visible_once" || result.join_token.join_url === undefined)) {
+        throw new LaunchError("relay_registration_failed", "Relay did not return a visible join URL for this launch", "Retry `tenso launch` so the host can rotate a fresh visible-once join URL.");
+    }
+    if (pendingManaged && managed !== null && result.managed_authority !== undefined) {
+        managed.state.registered(managed.journal.request_ref, result.managed_authority);
+    }
+    updateMachineProjectRelayBinding({
+        tuttiHome: options.preparation.tutti_home,
+        projectId: options.preparation.project_id,
+        relayProjectRef: result.relay_project.relay_project_ref,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    if (accountHandoff !== null && result.feishu_setup?.state !== "account_handoff_required") {
+        deleteFeishuOwnerAccountHandoff(options.preparation.tutti_home, options.preparation.project_id);
+    }
+    return {
+        summary: {
+            relay_project_ref: result.relay_project.relay_project_ref,
+            host_connection_ref: result.host_connection.host_connection_ref,
+            ...(result.join_token?.join_url === undefined
+                ? {}
+                : { join_url: result.join_token.join_url }),
+            join_url_visibility: result.join_token?.visibility ?? "not_recoverable",
+            ...(result.join_token === undefined
+                ? {}
+                : { join_token_expires_at: result.join_token.expires_at }),
+            join_token_reusable: result.join_token?.reusable ?? false,
+            tunnel_url: result.host_connection.tunnel_url,
+            connected_at: result.host_connection.connected_at,
+            surface_profile: surfaceProfile,
+            ...(result.feishu_setup === undefined ? {} : { feishu_setup: result.feishu_setup }),
+        },
+        hostConnectionToken: result.host_connection_token,
+        heartbeatIntervalMs: result.host_connection.heartbeat_interval_ms,
+    };
+}
+//# sourceMappingURL=relay-registration.js.map

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

@@ -0,0 +1,75 @@
+import type { ProjectId, RelayProjectRef } from "@tutti/shared/ids";
+import { type FetchLike } from "./host-runtime-endpoint.js";
+import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+import { type CodexLinuxSandboxReadiness } from "../../providers/openai/index.js";
+import type { LocalControlFetch } from "./local-control-client.js";
+export type RuntimeProjectRow = {
+    project_id: ProjectId;
+    status: "online" | "reconnecting" | "relay-unavailable" | "stale" | "stopped" | "workspace-missing" | "workspace-replaced" | "invalid";
+    display_name: string;
+    workspace_root: string;
+    endpoint?: string;
+    provider_status?: string;
+    relay_project_ref?: RelayProjectRef;
+    join_url?: string;
+    relay_connection_status?: string;
+    last_connected_at?: string;
+    next_retry_at?: string;
+    relay_reason_code?: string;
+    host_version?: string;
+};
+export declare function formatProjectIdForDisplay(projectId: ProjectId, projectIds: readonly ProjectId[]): string;
+export declare function listRuntimeProjects(options?: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    fetchImpl?: FetchLike;
+    all?: boolean;
+}): Promise<RuntimeProjectRow[]>;
+export declare function runPsCommand(options?: Parameters<typeof listRuntimeProjects>[0]): Promise<string>;
+export declare function runPsManageCommand(options?: {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    all?: boolean;
+}): Promise<void>;
+export declare function runStopCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    shutdownWaitMs?: number;
+}): Promise<string>;
+export declare function runArchiveCommand(target: string, options?: {
+    yes?: boolean;
+    interactive?: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    shutdownWaitMs?: number;
+    now?: () => Date;
+}): Promise<string>;
+export declare function runForgetCommand(target: string, options?: {
+    yes?: boolean;
+    interactive?: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    shutdownWaitMs?: number;
+}): Promise<string>;
+export declare function runInviteCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+}): Promise<string>;
+export declare function runProviderStatusCommand(target?: string): string;
+export declare function runLogsCommand(target?: string, tailLines?: number): string;
+export declare function runDoctorCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    inspectCodexSandbox?: () => CodexLinuxSandboxReadiness;
+}): Promise<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;
+//# sourceMappingURL=runtime-commands.d.ts.map