@xfey/tutti 0.1.0

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

@@ -0,0 +1,432 @@
+import { existsSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { serializeRuntimeLogLine } from "@tutti/shared/utils";
+import { completeRelayUpload, resolveRelayUpload, } from "@tutti/relay-client";
+import { ApprovalRequestManager } from "../../approvals/index.js";
+import { ReadOnlyChatAssistant } from "../../chat-assistant/index.js";
+import { resolveControlPlaneCommandRecovery } from "../../control-plane/command-recovery.js";
+import { Phase5ControlPlane } from "../../control-plane/index.js";
+import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane/workflows/index.js";
+import { resolveProjectOpenAiReadOnlyChatAssistantModel } from "../../providers/openai/chat-assistant.js";
+import { configureProjectOpenAiProvider, readOpenAiProviderConfigProjection, } from "../../providers/openai/index.js";
+import { readProviderUsageProjection, recordProviderUsageEvent, } from "../../provider-usage/index.js";
+import { resolveProjectOpenAiRunPipelineRunner } from "../../run-pipeline/openai.js";
+import { openHostProjectStore } from "../../store/index.js";
+import { cleanupStaleRunWorkspaces } from "../../workspace-ops/index.js";
+import { AGENT_CONTEXT_BASE_PATH, AgentContextTokenRegistry, } from "../http/routes/agent-context.js";
+import { readHostRepoProjection } from "../http/routes/project-api.js";
+import { WorkspaceEventBus } from "../http/workspace-events.js";
+import { createTrustedRelaySessionMetadataStore, } from "../session/relay-session-context.js";
+import { LaunchError } from "./errors.js";
+import { relayStateFromLaunchStatus } from "./host-relay-status.js";
+import { readHostRegistrationSecret, createMachineRuntimeEndpointToken, deleteMachineRuntimeEndpoint, writeMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readProjectDisplayName, writeProjectDisplayName } from "./project-identity.js";
+export const HOST_SERVER_VERSION = "0.0.0";
+function createHostRuntimeLogger(options) {
+    return {
+        info(fields, message) {
+            const line = serializeRuntimeLogLine({
+                level: "info",
+                service: "tutti-host",
+                component: options.component,
+                message,
+                fields,
+                now: options.now,
+            });
+            process.stdout.write(`${line}\n`);
+        },
+    };
+}
+function resolvePackagedWebStaticRoot(env = process.env) {
+    if (env.TUTTI_WEB_STATIC_ROOT !== undefined && env.TUTTI_WEB_STATIC_ROOT.trim() !== "") {
+        return resolve(env.TUTTI_WEB_STATIC_ROOT);
+    }
+    const packagedRoot = fileURLToPath(new URL("../../../web", import.meta.url));
+    return existsSync(join(packagedRoot, "index.html")) ? packagedRoot : undefined;
+}
+function createAgentContextRuntime(options) {
+    return {
+        baseUrl: new URL(AGENT_CONTEXT_BASE_PATH, options.baseUrl).toString(),
+        issueToken: (input) => {
+            const token = options.registry.issueToken({
+                projectId: options.projectId,
+                selection: input.selectionName,
+                scopes: input.scopes,
+            });
+            return {
+                token: token.token,
+                expires_at: token.expires_at,
+            };
+        },
+    };
+}
+function formatHostForUrl(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function formatLocalEndpointBaseUrl(host, port) {
+    return `http://${formatHostForUrl(host)}:${port}`;
+}
+function resolveListeningPort(app, requestedPort) {
+    const address = app.server.address();
+    if (typeof address === "object" && address !== null) {
+        return address.port;
+    }
+    if (requestedPort > 0) {
+        return requestedPort;
+    }
+    throw new LaunchError("port_unavailable", "Host server did not expose its dynamically assigned local diagnostic port", "Retry `tutti launch`; if it keeps failing, set TUTTI_HOST_ENDPOINT_PORT explicitly.");
+}
+function createStagedUploadResolver(options) {
+    if (options.getLaunchStatus === undefined) {
+        return undefined;
+    }
+    return async (uploadId) => {
+        const relay = options.getLaunchStatus?.().relay;
+        if (relay === undefined) {
+            throw new Error("Relay is not connected");
+        }
+        const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
+        const resolved = await resolveRelayUpload({
+            relayUrl: options.preparation.relay_url,
+            projectId: options.preparation.project_id,
+            relayProjectRef: relay.relay_project_ref,
+            hostConnectionRef: relay.host_connection_ref,
+            hostRegistrationSecret: hostSecret.secret,
+            uploadId: uploadId,
+        });
+        return {
+            upload: resolved.upload,
+            get: resolved.get,
+            delete: resolved.delete,
+            complete: async (status) => {
+                await completeRelayUpload({
+                    relayUrl: options.preparation.relay_url,
+                    projectId: options.preparation.project_id,
+                    relayProjectRef: relay.relay_project_ref,
+                    hostConnectionRef: relay.host_connection_ref,
+                    hostRegistrationSecret: hostSecret.secret,
+                    uploadId: uploadId,
+                    status,
+                });
+            },
+        };
+    };
+}
+class HostLocalProviderConfigureError extends Error {
+    code;
+    statusCode = 422;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "HostLocalProviderConfigureError";
+    }
+}
+export async function startForegroundHostServer(options) {
+    const token = createMachineRuntimeEndpointToken();
+    const now = options.now ?? (() => new Date());
+    const startedAt = now().toISOString();
+    const trustedMetadataStore = createTrustedRelaySessionMetadataStore();
+    const agentContextTokenRegistry = new AgentContextTokenRegistry({ now });
+    const agentContextRuntime = createAgentContextRuntime({
+        baseUrl: options.preparation.local_diagnostic_endpoint,
+        projectId: options.preparation.project_id,
+        registry: agentContextTokenRegistry,
+    });
+    const localStoreRoot = options.preparation.machine_local.binding.local_store_root;
+    const store = openHostProjectStore({
+        localStoreRoot,
+        projectId: options.preparation.project_id,
+        commandRecoveryResolver: resolveControlPlaneCommandRecovery,
+        now,
+    });
+    const workspaceEvents = new WorkspaceEventBus({ now });
+    const getProviderConfig = () => readOpenAiProviderConfigProjection({
+        tuttiHome: options.preparation.tutti_home,
+        projectId: options.preparation.project_id,
+    });
+    const recordUsage = (usage) => {
+        recordProviderUsageEvent(store.db, {
+            ...usage,
+            now,
+        });
+        workspaceEvents.publish({
+            event_type: "query.invalidate",
+            payload: {
+                reason: "bulk_state_change",
+                message: "Provider usage updated.",
+            },
+            invalidates: [{ kind: "provider_usage" }, { kind: "bootstrap" }],
+        });
+    };
+    let projectDisplayName = readProjectDisplayName(options.preparation.workspace_root) ??
+        (basename(options.preparation.workspace_root) || options.preparation.project_id);
+    const projectContext = {
+        workspaceRoot: options.preparation.workspace_root,
+        projectName: projectDisplayName,
+    };
+    const chatAssistantProject = {
+        project_id: options.preparation.project_id,
+        display_name: projectDisplayName,
+    };
+    const projectApiProject = {
+        project_id: options.preparation.project_id,
+        display_name: projectDisplayName,
+        identity_source: "git_config",
+    };
+    const updateRuntimeProjectDisplayName = (displayName) => {
+        writeProjectDisplayName(options.preparation.workspace_root, displayName);
+        projectDisplayName = displayName;
+        projectContext.projectName = displayName;
+        chatAssistantProject.display_name = displayName;
+        projectApiProject.display_name = displayName;
+    };
+    const controlPlaneLogger = createHostRuntimeLogger({
+        component: "control-plane",
+        now,
+    });
+    const runPipelineLogger = createHostRuntimeLogger({
+        component: "run-pipeline",
+        now,
+    });
+    const approvalManager = new ApprovalRequestManager({
+        events: workspaceEvents,
+        now,
+    });
+    const controlPlane = new Phase5ControlPlane({
+        store,
+        events: workspaceEvents,
+        now,
+        logger: controlPlaneLogger,
+        projectContext,
+        readActiveApproval: () => approvalManager.getActiveApproval(),
+        readMainlineStatus: () => ({
+            mainline_clean: readHostRepoProjection(options.preparation.workspace_root).mainline_clean,
+        }),
+        resolveRunPipeline: () => resolveProjectOpenAiRunPipelineRunner({
+            tuttiHome: options.preparation.tutti_home,
+            projectId: options.preparation.project_id,
+            workspaceRoot: options.preparation.workspace_root,
+            runWorkspaceRoot: localStoreRoot,
+            agentContext: agentContextRuntime,
+            approvalManager,
+            logger: runPipelineLogger,
+            recordUsage,
+        }),
+        resolveWorkflowRunner: () => resolveProjectOpenAiProcedureWorkflowRunner({
+            tuttiHome: options.preparation.tutti_home,
+            projectId: options.preparation.project_id,
+            workspaceRoot: options.preparation.workspace_root,
+            agentContext: agentContextRuntime,
+            recordUsage,
+        }),
+    });
+    const chatAssistant = new ReadOnlyChatAssistant({
+        project: chatAssistantProject,
+        store,
+        events: workspaceEvents,
+        workspaceRoot: options.preparation.workspace_root,
+        model: {
+            answer: async (input) => {
+                const resolution = resolveProjectOpenAiReadOnlyChatAssistantModel({
+                    tuttiHome: options.preparation.tutti_home,
+                    projectId: options.preparation.project_id,
+                    workspaceRoot: options.preparation.workspace_root,
+                    agentContext: agentContextRuntime,
+                    recordUsage,
+                });
+                if (resolution.kind !== "ready") {
+                    throw new Error("Provider is not configured.");
+                }
+                return await resolution.model.answer(input);
+            },
+        },
+        onScratchpadSourceChanged: () => controlPlane.notifyScratchpadSourceChanged(),
+        now,
+    });
+    let close = async () => { };
+    let relayTunnel;
+    const localControl = {
+        token,
+        requestShutdown: () => {
+            void close();
+        },
+        project: {
+            get: () => ({ display_name: projectDisplayName }),
+            update: (input) => {
+                updateRuntimeProjectDisplayName(input.display_name);
+                workspaceEvents.publish({
+                    event_type: "query.invalidate",
+                    payload: {
+                        reason: "bulk_state_change",
+                        message: "Project display name changed.",
+                    },
+                    invalidates: [{ kind: "workspace" }, { kind: "bootstrap" }],
+                });
+                return { display_name: projectDisplayName };
+            },
+        },
+        providerConfig: {
+            get: getProviderConfig,
+            configure: async (input) => {
+                const result = await configureProjectOpenAiProvider({
+                    tuttiHome: options.preparation.tutti_home,
+                    projectId: options.preparation.project_id,
+                    apiKey: input.api_key,
+                    ...(input.base_url === undefined ? {} : { apiBaseUrl: input.base_url }),
+                    ...(input.default_model === undefined ? {} : { defaultModel: input.default_model }),
+                    now,
+                });
+                if (result.kind === "validation_failed") {
+                    throw new HostLocalProviderConfigureError(result.reason, `OpenAI provider validation failed: ${result.reason}`);
+                }
+                workspaceEvents.publish({
+                    event_type: "provider_config.changed",
+                    payload: {
+                        provider_config: result.projection,
+                    },
+                    invalidates: [{ kind: "provider_config" }, { kind: "workspace" }, { kind: "bootstrap" }],
+                });
+                void controlPlane
+                    .refreshProjectBrief({ reason: "provider_configured" })
+                    .catch(() => undefined);
+                return result.projection;
+            },
+        },
+        ...(options.getLaunchStatus === undefined ? {} : { getLaunchStatus: options.getLaunchStatus }),
+    };
+    let app;
+    try {
+        const webStaticRoot = resolvePackagedWebStaticRoot();
+        const resolveStagedUpload = createStagedUploadResolver({
+            preparation: options.preparation,
+            ...(options.getLaunchStatus === undefined
+                ? {}
+                : { getLaunchStatus: options.getLaunchStatus }),
+        });
+        app = options.createServer({
+            agentContext: { tokenRegistry: agentContextTokenRegistry },
+            localControl,
+            now,
+            projectApi: {
+                project: projectApiProject,
+                server: {
+                    version: HOST_SERVER_VERSION,
+                    started_at: startedAt,
+                    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+                },
+                relay: {
+                    getState: () => relayStateFromLaunchStatus(options.preparation.relay_url, options.getLaunchStatus?.()),
+                    ...(options.refreshRelayJoinUrl === undefined
+                        ? {}
+                        : { refreshJoinUrl: options.refreshRelayJoinUrl }),
+                },
+                trustedMetadataStore,
+                store,
+                events: workspaceEvents,
+                controlPlane,
+                approvalManager,
+                chatAssistant,
+                tuttiHome: options.preparation.tutti_home,
+                getProviderConfig,
+                getProviderUsage: () => readProviderUsageProjection(store.db),
+                updateProjectDisplayName: (displayName) => {
+                    updateRuntimeProjectDisplayName(displayName);
+                },
+                ...(resolveStagedUpload === undefined ? {} : { resolveStagedUpload }),
+                capabilities: {
+                    clarification: true,
+                    repo_viewer: true,
+                },
+                getRepo: () => readHostRepoProjection(options.preparation.workspace_root),
+                workspaceOps: {
+                    workspaceRoot: options.preparation.workspace_root,
+                    viewerAssetCacheRoot: join(localStoreRoot, "cache", "viewer-assets"),
+                },
+                now,
+            },
+            ...(webStaticRoot === undefined ? {} : { webStatic: { root: webStaticRoot } }),
+        });
+    }
+    catch (error) {
+        store.close();
+        throw error;
+    }
+    try {
+        await app.listen({ host: options.endpointHost, port: options.endpointPort });
+    }
+    catch (error) {
+        store.close();
+        throw new LaunchError("port_unavailable", error instanceof Error ? error.message : "Host server port is unavailable", options.endpointPort === 0
+            ? "Retry `tutti launch`; if it keeps failing, set TUTTI_HOST_ENDPOINT_PORT explicitly."
+            : "Stop the process using the local diagnostic port or set TUTTI_HOST_ENDPOINT_PORT.");
+    }
+    const actualEndpointPort = resolveListeningPort(app, options.endpointPort);
+    const actualEndpointBaseUrl = formatLocalEndpointBaseUrl(options.endpointHost, actualEndpointPort);
+    agentContextRuntime.baseUrl = new URL(AGENT_CONTEXT_BASE_PATH, actualEndpointBaseUrl).toString();
+    let runtimeEndpoint;
+    try {
+        runtimeEndpoint = writeMachineRuntimeEndpoint({
+            tuttiHome: options.preparation.tutti_home,
+            projectId: options.preparation.project_id,
+            pid: process.pid,
+            baseUrl: actualEndpointBaseUrl,
+            token,
+            workspaceRoot: options.preparation.workspace_root,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+    }
+    catch (error) {
+        await app.close();
+        store.close();
+        throw error;
+    }
+    controlPlane.runStartupRecovery({
+        interruptedCommandCount: store.interrupted_command_count,
+        cleanupStaleRunWorkspaces: () => cleanupStaleRunWorkspaces({
+            workspaceRoot: options.preparation.workspace_root,
+            runWorkspaceRoot: join(localStoreRoot, "run-workspaces"),
+            mergeWorkspaceRoot: join(localStoreRoot, "merge-workspaces"),
+        }),
+    });
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    let closePromise;
+    close = () => {
+        closePromise ??= (async () => {
+            try {
+                relayTunnel?.close(1000, "host closing");
+                await app.close();
+            }
+            finally {
+                try {
+                    approvalManager.dispose();
+                    store.close();
+                }
+                finally {
+                    deleteMachineRuntimeEndpoint({
+                        tuttiHome: options.preparation.tutti_home,
+                        projectId: options.preparation.project_id,
+                        expectedToken: token,
+                    });
+                    resolveClosed();
+                }
+            }
+        })();
+        return closePromise;
+    };
+    return {
+        app,
+        store,
+        runtime_endpoint: runtimeEndpoint,
+        trusted_relay_metadata_store: trustedMetadataStore,
+        attachRelayTunnel: (tunnel) => {
+            relayTunnel = tunnel;
+        },
+        closed,
+        close,
+    };
+}
+//# sourceMappingURL=host-server-runtime.js.map

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

@@ -0,0 +1,8 @@
+export * from "./args.js";
+export * from "./errors.js";
+export * from "./git-bootstrap.js";
+export * from "./host-lifecycle.js";
+export * from "./launch.js";
+export * from "./machine-local.js";
+export * from "./project-identity.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,8 @@
+export * from "./args.js";
+export * from "./errors.js";
+export * from "./git-bootstrap.js";
+export * from "./host-lifecycle.js";
+export * from "./launch.js";
+export * from "./machine-local.js";
+export * from "./project-identity.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,45 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type OpenAiProviderConfigProjection } from "../../providers/openai/index.js";
+import { type GitBootstrapResult, type LaunchConfirmationHandler } from "./git-bootstrap.js";
+import { type MachineProjectBindingResult } from "./machine-local.js";
+import { type ProjectIdentityReadResult } from "./project-identity.js";
+export type LaunchPreparationOptions = {
+    workspacePath: string;
+    yes?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    now?: () => Date;
+    confirm?: LaunchConfirmationHandler;
+    allowWorkspaceRootTakeover?: boolean;
+};
+export type LaunchProviderStatus = OpenAiProviderConfigProjection["status"];
+export type LaunchPreparationResult = {
+    status: "prepared";
+    workspace_root: string;
+    tutti_home: string;
+    project_id: ProjectId;
+    branch: "tutti/mainline";
+    relay_url: string;
+    local_diagnostic_endpoint: string;
+    provider_status: LaunchProviderStatus;
+    provider_config: OpenAiProviderConfigProjection;
+    project_identity_created: boolean;
+    git: GitBootstrapResult;
+    machine_local: MachineProjectBindingResult;
+};
+export type LaunchLocalDiagnosticEndpoint = {
+    host: string;
+    port: number;
+    base_url: string;
+};
+export type LaunchLocalContext = {
+    workspace_root: string;
+    tutti_home: string;
+    relay_url: string;
+    local_diagnostic_endpoint: LaunchLocalDiagnosticEndpoint;
+    existing_identity: ProjectIdentityReadResult;
+};
+export declare function resolveLaunchLocalContext(options: Pick<LaunchPreparationOptions, "workspacePath" | "env" | "cwd">): LaunchLocalContext;
+export declare function prepareLaunchProject(options: LaunchPreparationOptions): Promise<LaunchPreparationResult>;
+export declare function formatLaunchPreparation(result: LaunchPreparationResult): string;
+//# sourceMappingURL=launch.d.ts.map

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

@@ -0,0 +1,115 @@
+import { resolve } from "node:path";
+import { createProjectId } from "@tutti/shared/ids";
+import { redactText } from "@tutti/shared/utils";
+import { readOpenAiProviderConfigProjection, resolveTuttiHome, } from "../../providers/openai/index.js";
+import { LaunchError } from "./errors.js";
+import { assertSafeProjectRoot, ensureGitBootstrap, } from "./git-bootstrap.js";
+import { ensureMachineProjectBinding } from "./machine-local.js";
+import { readProjectIdentity, writeProjectIdentity, } from "./project-identity.js";
+const DEFAULT_RELAY_URL = "https://tutti.now";
+const DEFAULT_HOST_ENDPOINT_HOST = "127.0.0.1";
+const AUTO_HOST_ENDPOINT_PORT = 0;
+function readOptionalPort(value) {
+    if (value === undefined || value.trim() === "") {
+        return AUTO_HOST_ENDPOINT_PORT;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+        throw new LaunchError("port_unavailable", `Invalid TUTTI_HOST_ENDPOINT_PORT: ${value}`, "Use an integer port between 1 and 65535.");
+    }
+    return parsed;
+}
+function resolveLocalDiagnosticEndpoint(env) {
+    const host = env.TUTTI_HOST_ENDPOINT_HOST ?? DEFAULT_HOST_ENDPOINT_HOST;
+    const port = readOptionalPort(env.TUTTI_HOST_ENDPOINT_PORT);
+    return {
+        host,
+        port,
+        base_url: `http://${host}:${port}`,
+    };
+}
+export function resolveLaunchLocalContext(options) {
+    const env = options.env ?? process.env;
+    const cwd = options.cwd ?? process.cwd();
+    const workspaceRoot = resolve(cwd, options.workspacePath);
+    assertSafeProjectRoot(workspaceRoot);
+    return {
+        workspace_root: workspaceRoot,
+        tutti_home: resolveTuttiHome(env.TUTTI_HOME, cwd),
+        relay_url: env.TUTTI_RELAY_URL ?? DEFAULT_RELAY_URL,
+        local_diagnostic_endpoint: resolveLocalDiagnosticEndpoint(env),
+        existing_identity: readProjectIdentity(workspaceRoot),
+    };
+}
+export async function prepareLaunchProject(options) {
+    const context = resolveLaunchLocalContext(options);
+    const workspaceRoot = context.workspace_root;
+    const tuttiHome = context.tutti_home;
+    const relayUrl = context.relay_url;
+    const localDiagnosticEndpoint = context.local_diagnostic_endpoint.base_url;
+    const existingIdentity = context.existing_identity;
+    const projectId = existingIdentity.kind === "present" ? existingIdentity.project_id : createProjectId();
+    const projectIdentityCreated = existingIdentity.kind === "missing";
+    const gitOptions = {
+        workspaceRoot,
+        projectId,
+        prepareBootstrapFiles: () => writeProjectIdentity(workspaceRoot, projectId),
+    };
+    if (options.yes !== undefined) {
+        gitOptions.assumeYes = options.yes;
+    }
+    if (options.confirm !== undefined) {
+        gitOptions.confirm = options.confirm;
+    }
+    const git = await ensureGitBootstrap(gitOptions);
+    const bindingOptions = {
+        tuttiHome,
+        projectId,
+        workspaceRoot,
+    };
+    if (options.allowWorkspaceRootTakeover !== undefined) {
+        bindingOptions.allowWorkspaceRootTakeover = options.allowWorkspaceRootTakeover;
+    }
+    if (options.now !== undefined) {
+        bindingOptions.now = options.now;
+    }
+    const machineLocal = ensureMachineProjectBinding(bindingOptions);
+    const providerConfig = readOpenAiProviderConfigProjection({
+        tuttiHome,
+        projectId,
+    });
+    return {
+        status: "prepared",
+        workspace_root: workspaceRoot,
+        tutti_home: tuttiHome,
+        project_id: projectId,
+        branch: git.branch,
+        relay_url: relayUrl,
+        local_diagnostic_endpoint: localDiagnosticEndpoint,
+        provider_status: providerConfig.status,
+        provider_config: providerConfig,
+        project_identity_created: projectIdentityCreated,
+        git,
+        machine_local: machineLocal,
+    };
+}
+export function formatLaunchPreparation(result) {
+    const localDiagnosticEndpoint = result.local_diagnostic_endpoint.endsWith(":0")
+        ? result.local_diagnostic_endpoint.replace(/:0$/u, ":<auto>")
+        : result.local_diagnostic_endpoint;
+    const fields = [
+        "Tutti launch prerequisites are ready",
+        "",
+        "Status: prepared",
+        `Workspace: ${redactText(result.workspace_root)}`,
+        `Project: ${result.project_id}`,
+        `Branch: ${result.branch}`,
+        `Relay: ${result.relay_url}`,
+        `Provider: ${result.provider_status}`,
+        `Local diagnostic endpoint: ${localDiagnosticEndpoint}`,
+        "",
+        "Next: Relay host-control registration and visible-once join URL output are the next roadmap slice.",
+    ];
+    return fields.join("\n");
+}
+//# sourceMappingURL=launch.js.map

package/dist/server-shell/cli/machine-local.d.ts

@@ -0,0 +1,69 @@
+import { type ProjectId, type RelayProjectRef } from "@tutti/shared/ids";
+export type MachineProjectBindingRecord = {
+    project_id: ProjectId;
+    workspace_root: string;
+    local_store_root: string;
+    relay_project_ref?: RelayProjectRef;
+    host_registration_secret_ref?: string;
+    updated_at: string;
+};
+export type HostRegistrationSecretFile = {
+    kind: "host_registration_secret_v1";
+    project_id: ProjectId;
+    secret: string;
+    created_at: string;
+    updated_at: string;
+};
+export type MachineRuntimeEndpointRecord = {
+    project_id: ProjectId;
+    pid: number;
+    base_url: string;
+    token: string;
+    workspace_root: string;
+    updated_at: string;
+};
+export type EnsureMachineProjectBindingOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    allowWorkspaceRootTakeover?: boolean;
+    now?: () => Date;
+};
+export type MachineProjectBindingResult = {
+    binding: MachineProjectBindingRecord;
+    binding_path: string;
+    host_registration_secret_ref: string;
+    host_registration_secret_created: boolean;
+};
+export declare function getProjectLocalStoreRoot(tuttiHome: string, projectId: ProjectId): string;
+export declare function getMachineProjectBindingPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function getMachineRuntimeEndpointPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function createHostRegistrationSecretRef(projectId: ProjectId): string;
+export declare function getHostRegistrationSecretPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function createHostRegistrationSecret(): string;
+export declare function createMachineRuntimeEndpointToken(): string;
+export declare function readMachineProjectBinding(tuttiHome: string, projectId: ProjectId): MachineProjectBindingRecord | null;
+export declare function readMachineRuntimeEndpoint(tuttiHome: string, projectId: ProjectId): MachineRuntimeEndpointRecord | null;
+export declare function writeMachineRuntimeEndpoint(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    pid: number;
+    baseUrl: string;
+    token?: string;
+    workspaceRoot: string;
+    now?: () => Date;
+}): MachineRuntimeEndpointRecord;
+export declare function deleteMachineRuntimeEndpoint(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    expectedToken?: string;
+}): boolean;
+export declare function readHostRegistrationSecret(tuttiHome: string, projectId: ProjectId): HostRegistrationSecretFile;
+export declare function updateMachineProjectRelayBinding(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    relayProjectRef: RelayProjectRef;
+    now?: () => Date;
+}): MachineProjectBindingRecord;
+export declare function ensureMachineProjectBinding(options: EnsureMachineProjectBindingOptions): MachineProjectBindingResult;
+//# sourceMappingURL=machine-local.d.ts.map