@xfey/tutti 0.1.28 → 0.1.30

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

@@ -2,7 +2,7 @@ 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 { 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";
@@ -20,7 +20,7 @@ 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 { appendHostLogLine, readHostRegistrationSecret, createMachineRuntimeEndpointToken, deleteMachineRuntimeEndpoint, ensureHostLogFile, getHostLogFilePath, writeMachineRuntimeEndpoint, } from "./machine-local.js";
+import { appendHostLogLine, readHostRegistrationSecret, createMachineRuntimeEndpointToken, deleteMachineRuntimeEndpoint, ensureHostLogFile, getHostLogFilePath, updateMachineProjectDisplayNameSnapshot, writeMachineRuntimeEndpoint, } from "./machine-local.js";
 import { readProjectDescription, readProjectDisplayName, writeProjectDescription, writeProjectDisplayName, } from "./project-identity.js";
 export const HOST_SERVER_VERSION = "0.0.0";
 function createHostRuntimeLogger(options) {
@@ -180,6 +180,12 @@ export async function startForegroundHostServer(options) {
     };
     const updateRuntimeProjectDisplayName = (displayName) => {
         writeProjectDisplayName(options.preparation.workspace_root, displayName);
+        updateMachineProjectDisplayNameSnapshot({
+            tuttiHome: options.preparation.tutti_home,
+            projectId: options.preparation.project_id,
+            displayName,
+            now,
+        });
         projectDisplayName = displayName;
         projectContext.projectName = displayName;
         chatAssistantProject.display_name = displayName;
@@ -261,8 +267,7 @@ export async function startForegroundHostServer(options) {
         now,
     });
     let close = async () => { };
-    let relayTunnel;
-    let relayTunnelConnected = false;
+    let relayConnectionManager;
     const localControl = {
         token,
         requestShutdown: () => {
@@ -318,6 +323,10 @@ export async function startForegroundHostServer(options) {
                     return options.getLaunchStatus?.() ?? {};
                 },
             }),
+        reconnectRelay: async () => {
+            await relayConnectionManager?.reconnectNow();
+            return options.getLaunchStatus?.() ?? {};
+        },
         ...(options.getLaunchStatus === undefined ? {} : { getLaunchStatus: options.getLaunchStatus }),
     };
     let app;
@@ -333,7 +342,9 @@ export async function startForegroundHostServer(options) {
             agentContext: { tokenRegistry: agentContextTokenRegistry },
             health: {
                 readiness: {
-                    relay: () => (relayTunnelConnected ? "connected" : "not_connected"),
+                    relay: () => relayConnectionManager?.getState().status === "connected"
+                        ? "connected"
+                        : "not_connected",
                     store: () => "ready",
                 },
             },
@@ -432,8 +443,7 @@ export async function startForegroundHostServer(options) {
     close = () => {
         closePromise ??= (async () => {
             try {
-                relayTunnelConnected = false;
-                relayTunnel?.close(1000, "host closing");
+                await relayConnectionManager?.stop();
                 await app.close();
             }
             finally {
@@ -459,14 +469,8 @@ export async function startForegroundHostServer(options) {
         log_file_path: logFilePath,
         runtime_endpoint: runtimeEndpoint,
         trusted_relay_metadata_store: trustedMetadataStore,
-        attachRelayTunnel: (tunnel) => {
-            relayTunnel = tunnel;
-            relayTunnelConnected = true;
-            void tunnel.closed.finally(() => {
-                if (relayTunnel === tunnel) {
-                    relayTunnelConnected = false;
-                }
-            });
+        attachRelayConnectionManager: (manager) => {
+            relayConnectionManager = manager;
         },
         closed,
         close,

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

@@ -1,5 +1,6 @@
 import type { LaunchConfirmationRequest } from "./git-bootstrap.js";
 export declare function confirmFromTty(request: LaunchConfirmationRequest): Promise<boolean>;
+export declare function confirmTextFromTty(message: string): Promise<boolean>;
 export declare function renderCompletionPage(options: {
     joinUrl: string;
     joinTokenExpiresAt?: string;

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

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { basename } from "node:path";
-import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown } from "./host-lifecycle.js";
+import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown, } from "./host-lifecycle.js";
 import { prepareLaunchProject } from "./launch.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "./managed-host.js";
 import { resolveLaunchWorkspacePath } from "./project-resolver.js";
@@ -10,6 +10,9 @@ import { runProviderSetupTui } from "./provider-tui.js";
 import { LaunchError } from "./errors.js";
 const CLEAR = "\u001B[2J\u001B[H";
 export async function confirmFromTty(request) {
+    return await confirmTextFromTty(request.message);
+}
+export async function confirmTextFromTty(message) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         return false;
     }
@@ -18,7 +21,7 @@ export async function confirmFromTty(request) {
         output: process.stdout,
     });
     try {
-        const answer = await readline.question(`${request.message}\n\nContinue? [y/N] `);
+        const answer = await readline.question(`${message}\n\nContinue? [y/N] `);
         return /^(y|yes)$/iu.test(answer.trim());
     }
     finally {
@@ -49,8 +52,7 @@ function visibleTerminalLength(line) {
         const end = Array.from(stripped.slice(start + 2)).findIndex((character) => {
             const codePoint = character.codePointAt(0);
             return (codePoint !== undefined &&
-                ((codePoint >= 0x41 && codePoint <= 0x5a) ||
-                    (codePoint >= 0x61 && codePoint <= 0x7a)));
+                ((codePoint >= 0x41 && codePoint <= 0x5a) || (codePoint >= 0x61 && codePoint <= 0x7a)));
         });
         if (end < 0) {
             break;
@@ -71,12 +73,8 @@ export function renderCompletionPage(options) {
     const projectLabel = formatProjectLabel(options.workspaceRoot, options.projectId);
     const joinUrl = formatTerminalLink(options.joinUrl, { hyperlinks: options.hyperlinks === true });
     const joinValidity = formatJoinLinkValidity({
-        ...(options.joinTokenExpiresAt === undefined
-            ? {}
-            : { expiresAt: options.joinTokenExpiresAt }),
-        ...(options.joinTokenReusable === undefined
-            ? {}
-            : { reusable: options.joinTokenReusable }),
+        ...(options.joinTokenExpiresAt === undefined ? {} : { expiresAt: options.joinTokenExpiresAt }),
+        ...(options.joinTokenReusable === undefined ? {} : { reusable: options.joinTokenReusable }),
         includeRemaining: false,
     });
     const summaryLines = [

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

@@ -39,6 +39,7 @@ export type LaunchLocalContext = {
     local_diagnostic_endpoint: LaunchLocalDiagnosticEndpoint;
     existing_identity: ProjectIdentityReadResult;
 };
+export declare function resolveRelayUrl(env?: NodeJS.ProcessEnv): string;
 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;

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

@@ -1,13 +1,16 @@
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { createProjectId } from "@tutti/shared/ids";
 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";
+import { readProjectIdentity, readProjectDisplayName, 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;
+export function resolveRelayUrl(env = process.env) {
+    return env.TUTTI_RELAY_URL ?? DEFAULT_RELAY_URL;
+}
 function readOptionalPort(value) {
     if (value === undefined || value.trim() === "") {
         return AUTO_HOST_ENDPOINT_PORT;
@@ -35,7 +38,7 @@ export function resolveLaunchLocalContext(options) {
     return {
         workspace_root: workspaceRoot,
         tutti_home: resolveTuttiHome(env.TUTTI_HOME, cwd),
-        relay_url: env.TUTTI_RELAY_URL ?? DEFAULT_RELAY_URL,
+        relay_url: resolveRelayUrl(env),
         local_diagnostic_endpoint: resolveLocalDiagnosticEndpoint(env),
         existing_identity: readProjectIdentity(workspaceRoot),
     };
@@ -65,6 +68,7 @@ export async function prepareLaunchProject(options) {
         tuttiHome,
         projectId,
         workspaceRoot,
+        displayNameSnapshot: readProjectDisplayName(workspaceRoot) ?? (basename(workspaceRoot) || projectId),
     };
     if (options.allowWorkspaceRootTakeover !== undefined) {
         bindingOptions.allowWorkspaceRootTakeover = options.allowWorkspaceRootTakeover;

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

@@ -10,6 +10,11 @@ export declare function rotateHostLocalInvite(options: {
     endpoint: MachineRuntimeEndpointRecord;
     fetchImpl?: LocalControlFetch;
 }): Promise<HostLocalLaunchStatus>;
+export declare function reconnectHostLocalRelay(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+    timeoutMs?: number;
+}): Promise<HostLocalLaunchStatus>;
 export declare function readHostLocalProject(options: {
     endpoint: MachineRuntimeEndpointRecord;
     fetchImpl?: LocalControlFetch;

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

@@ -42,6 +42,15 @@ export async function rotateHostLocalInvite(options) {
         path: "/host-local/v1/invite/rotate",
     });
 }
+export async function reconnectHostLocalRelay(options) {
+    return await requestLocalJson({
+        endpoint: options.endpoint,
+        ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        method: "POST",
+        path: "/host-local/v1/relay/reconnect",
+    });
+}
 export async function readHostLocalProject(options) {
     return await requestLocalJson({
         ...options,

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

@@ -3,6 +3,7 @@ export type MachineProjectBindingRecord = {
     project_id: ProjectId;
     workspace_root: string;
     local_store_root: string;
+    display_name_snapshot?: string;
     relay_project_ref?: RelayProjectRef;
     host_registration_secret_ref?: string;
     updated_at: string;
@@ -26,6 +27,7 @@ export type EnsureMachineProjectBindingOptions = {
     tuttiHome: string;
     projectId: ProjectId;
     workspaceRoot: string;
+    displayNameSnapshot?: string;
     allowWorkspaceRootTakeover?: boolean;
     now?: () => Date;
 };
@@ -72,5 +74,11 @@ export declare function updateMachineProjectRelayBinding(options: {
     relayProjectRef: RelayProjectRef;
     now?: () => Date;
 }): MachineProjectBindingRecord;
+export declare function updateMachineProjectDisplayNameSnapshot(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+    displayName: string;
+    now?: () => Date;
+}): MachineProjectBindingRecord;
 export declare function ensureMachineProjectBinding(options: EnsureMachineProjectBindingOptions): MachineProjectBindingResult;
 //# sourceMappingURL=machine-local.d.ts.map

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

@@ -72,6 +72,8 @@ export function readMachineProjectBinding(tuttiHome, projectId) {
         typeof raw.workspace_root !== "string" ||
         typeof raw.local_store_root !== "string" ||
         typeof raw.updated_at !== "string" ||
+        (raw.display_name_snapshot !== undefined &&
+            (typeof raw.display_name_snapshot !== "string" || raw.display_name_snapshot.trim() === "")) ||
         (raw.relay_project_ref !== undefined &&
             (typeof raw.relay_project_ref !== "string" ||
                 !isPrefixedId(raw.relay_project_ref, ID_PREFIXES.relayProject))) ||
@@ -85,6 +87,9 @@ export function readMachineProjectBinding(tuttiHome, projectId) {
         local_store_root: raw.local_store_root,
         updated_at: raw.updated_at,
     };
+    if (raw.display_name_snapshot !== undefined) {
+        binding.display_name_snapshot = raw.display_name_snapshot;
+    }
     if (raw.relay_project_ref !== undefined) {
         binding.relay_project_ref = raw.relay_project_ref;
     }
@@ -200,6 +205,23 @@ export function updateMachineProjectRelayBinding(options) {
     writePrivateJsonFile(getMachineProjectBindingPath(options.tuttiHome, options.projectId), binding);
     return binding;
 }
+export function updateMachineProjectDisplayNameSnapshot(options) {
+    const existing = readMachineProjectBinding(options.tuttiHome, options.projectId);
+    if (existing === null) {
+        throw new LaunchError("project_identity_conflict", "Machine-local project binding is missing while updating its display name", "Run `tutti launch` again from the project workspace.");
+    }
+    const displayName = options.displayName.trim();
+    if (displayName === "") {
+        throw new LaunchError("project_identity_conflict", "Machine-local project display name snapshot must be non-empty", "Use a non-empty project display name.");
+    }
+    const binding = {
+        ...existing,
+        display_name_snapshot: displayName,
+        updated_at: (options.now ?? (() => new Date()))().toISOString(),
+    };
+    writePrivateJsonFile(getMachineProjectBindingPath(options.tuttiHome, options.projectId), binding);
+    return binding;
+}
 function ensureHostRegistrationSecret(tuttiHome, projectId, now) {
     const secretPath = getHostRegistrationSecretPath(tuttiHome, projectId);
     const ref = createHostRegistrationSecretRef(projectId);
@@ -236,6 +258,13 @@ export function ensureMachineProjectBinding(options) {
         host_registration_secret_ref: existing?.host_registration_secret_ref ?? secret.ref,
         updated_at: now().toISOString(),
     };
+    const displayNameSnapshot = options.displayNameSnapshot?.trim();
+    if (displayNameSnapshot !== undefined && displayNameSnapshot !== "") {
+        binding.display_name_snapshot = displayNameSnapshot;
+    }
+    else if (existing?.display_name_snapshot !== undefined) {
+        binding.display_name_snapshot = existing.display_name_snapshot;
+    }
     if (existing?.relay_project_ref !== undefined) {
         binding.relay_project_ref = existing.relay_project_ref;
     }

package/dist/server-shell/cli/machine-project-inspector.d.ts

@@ -0,0 +1,81 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type FetchLike, type HostRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
+import { type MachineProjectBindingRecord, type MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type MachineProjectBindingInspection = {
+    kind: "valid";
+    record: MachineProjectBindingRecord;
+} | {
+    kind: "missing";
+} | {
+    kind: "invalid";
+    reason_code: "invalid_binding";
+};
+export type MachineProjectEndpointInspection = {
+    kind: "valid";
+    record: MachineRuntimeEndpointRecord;
+} | {
+    kind: "missing";
+} | {
+    kind: "invalid";
+    reason_code: "invalid_endpoint";
+};
+export type MachineProjectWorkspaceInspection = {
+    kind: "matching";
+    display_name?: string;
+} | {
+    kind: "missing";
+} | {
+    kind: "replaced";
+    actual_project_id: ProjectId;
+} | {
+    kind: "not_a_tutti_project";
+} | {
+    kind: "unreadable";
+    reason_code: "workspace_root_unavailable" | "identity_read_failed";
+};
+export type MachineProjectHostInspection = {
+    kind: "stopped";
+} | {
+    kind: "stale";
+    reason_code: "invalid_endpoint" | "unreachable" | "local_control_unavailable";
+} | {
+    kind: "running";
+    identity_verified: boolean;
+    relay_readiness?: "connected" | "not_connected";
+    relay_connection_status?: "connecting" | "connected" | "reconnecting" | "unavailable" | "stopped";
+} | {
+    kind: "identity_mismatch";
+    actual_project_id: ProjectId;
+};
+export type MachineProjectRelayInspection = "connected" | "connecting" | "reconnecting" | "unavailable" | "unknown";
+export type MachineProjectInventoryInspection = {
+    project_id: ProjectId;
+    binding: MachineProjectBindingInspection;
+    endpoint: MachineProjectEndpointInspection;
+    workspace: MachineProjectWorkspaceInspection;
+    workspace_root?: string;
+    normalized_workspace_root?: string;
+    display_name: string;
+};
+export type MachineProjectInspection = MachineProjectInventoryInspection & {
+    host: MachineProjectHostInspection;
+    relay: MachineProjectRelayInspection;
+};
+export type MachineProjectInspectorOptions = {
+    tuttiHome: string;
+    fetchImpl?: FetchLike;
+    probeRuntimeEndpoint?: HostRuntimeEndpointProbe;
+};
+export type MachineProjectInspectionIndex = {
+    by_project_id: ReadonlyMap<ProjectId, MachineProjectInventoryInspection>;
+    by_normalized_workspace_root: ReadonlyMap<string, readonly MachineProjectInventoryInspection[]>;
+    by_alias: ReadonlyMap<string, readonly MachineProjectInventoryInspection[]>;
+};
+export declare function listMachineProjectIds(tuttiHome: string): ProjectId[];
+export declare function normalizeMachineWorkspacePath(workspaceRoot: string): string;
+export declare function createMachineProjectInspectionIndex(inspections: readonly MachineProjectInventoryInspection[]): MachineProjectInspectionIndex;
+export declare function inspectMachineProject(projectId: ProjectId, options: MachineProjectInspectorOptions): Promise<MachineProjectInspection>;
+export declare function inspectMachineProjectInventory(projectId: ProjectId, tuttiHome: string): MachineProjectInventoryInspection;
+export declare function inspectMachineProjectInventories(tuttiHome: string): MachineProjectInventoryInspection[];
+export declare function inspectMachineProjects(options: MachineProjectInspectorOptions): Promise<MachineProjectInspection[]>;
+//# sourceMappingURL=machine-project-inspector.d.ts.map

package/dist/server-shell/cli/machine-project-inspector.js

@@ -0,0 +1,205 @@
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { createRuntimeEndpointProbe, } from "./host-runtime-endpoint.js";
+import { readHostLocalLaunchStatus } from "./local-control-client.js";
+import { readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readProjectDisplayName, readProjectIdentity } from "./project-identity.js";
+export function listMachineProjectIds(tuttiHome) {
+    const projectsRoot = join(tuttiHome, "projects");
+    if (!existsSync(projectsRoot)) {
+        return [];
+    }
+    return readdirSync(projectsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && isPrefixedId(entry.name, ID_PREFIXES.project))
+        .map((entry) => entry.name)
+        .sort();
+}
+export function normalizeMachineWorkspacePath(workspaceRoot) {
+    try {
+        return realpathSync.native(workspaceRoot);
+    }
+    catch {
+        return resolve(workspaceRoot);
+    }
+}
+function normalizeMachineProjectAlias(value) {
+    return value.trim().toLowerCase();
+}
+export function createMachineProjectInspectionIndex(inspections) {
+    const byProjectId = new Map();
+    const byWorkspace = new Map();
+    const byAlias = new Map();
+    for (const inspection of inspections) {
+        byProjectId.set(inspection.project_id, inspection);
+        if (inspection.normalized_workspace_root !== undefined) {
+            const matches = byWorkspace.get(inspection.normalized_workspace_root) ?? [];
+            matches.push(inspection);
+            byWorkspace.set(inspection.normalized_workspace_root, matches);
+        }
+        if (inspection.workspace.kind !== "matching") {
+            continue;
+        }
+        const workspaceName = inspection.workspace_root === undefined ? undefined : basename(inspection.workspace_root);
+        const aliases = new Set([inspection.display_name, workspaceName]
+            .filter((alias) => alias !== undefined && alias.trim() !== "")
+            .map(normalizeMachineProjectAlias));
+        for (const alias of aliases) {
+            const matches = byAlias.get(alias) ?? [];
+            matches.push(inspection);
+            byAlias.set(alias, matches);
+        }
+    }
+    return {
+        by_project_id: byProjectId,
+        by_normalized_workspace_root: byWorkspace,
+        by_alias: byAlias,
+    };
+}
+function inspectBinding(tuttiHome, projectId) {
+    try {
+        const record = readMachineProjectBinding(tuttiHome, projectId);
+        return record === null ? { kind: "missing" } : { kind: "valid", record };
+    }
+    catch {
+        return { kind: "invalid", reason_code: "invalid_binding" };
+    }
+}
+function inspectEndpoint(tuttiHome, projectId) {
+    try {
+        const record = readMachineRuntimeEndpoint(tuttiHome, projectId);
+        return record === null ? { kind: "missing" } : { kind: "valid", record };
+    }
+    catch {
+        return { kind: "invalid", reason_code: "invalid_endpoint" };
+    }
+}
+function inspectWorkspace(workspaceRoot, projectId) {
+    if (workspaceRoot === undefined) {
+        return { kind: "unreadable", reason_code: "workspace_root_unavailable" };
+    }
+    if (!existsSync(workspaceRoot)) {
+        return { kind: "missing" };
+    }
+    try {
+        const identity = readProjectIdentity(workspaceRoot);
+        if (identity.kind === "missing") {
+            return { kind: "not_a_tutti_project" };
+        }
+        if (identity.project_id !== projectId) {
+            return { kind: "replaced", actual_project_id: identity.project_id };
+        }
+        const displayName = readProjectDisplayName(workspaceRoot);
+        return displayName === null
+            ? { kind: "matching" }
+            : { kind: "matching", display_name: displayName };
+    }
+    catch {
+        return { kind: "unreadable", reason_code: "identity_read_failed" };
+    }
+}
+function relayInspectionFromHost(host) {
+    if (host.kind !== "running") {
+        return "unknown";
+    }
+    if (host.relay_connection_status === "connected") {
+        return "connected";
+    }
+    if (host.relay_connection_status === "connecting") {
+        return "connecting";
+    }
+    if (host.relay_connection_status === "reconnecting") {
+        return "reconnecting";
+    }
+    if (host.relay_connection_status === "unavailable" ||
+        host.relay_connection_status === "stopped") {
+        return "unavailable";
+    }
+    if (host.relay_readiness === "connected") {
+        return "connected";
+    }
+    if (host.relay_readiness === "not_connected") {
+        return "unavailable";
+    }
+    return "unknown";
+}
+async function inspectHost(options) {
+    if (options.endpoint.kind === "missing") {
+        return { kind: "stopped" };
+    }
+    if (options.endpoint.kind === "invalid") {
+        return { kind: "stale", reason_code: "invalid_endpoint" };
+    }
+    const probe = await options.probeRuntimeEndpoint(options.endpoint.record);
+    if (probe.kind === "stale") {
+        return { kind: "stale", reason_code: "unreachable" };
+    }
+    try {
+        const status = await readHostLocalLaunchStatus({
+            endpoint: options.endpoint.record,
+            ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+        });
+        if (status.project_id !== undefined && status.project_id !== options.projectId) {
+            return { kind: "identity_mismatch", actual_project_id: status.project_id };
+        }
+        return {
+            kind: "running",
+            identity_verified: status.project_id === options.projectId,
+            ...(probe.readiness?.relay === undefined ? {} : { relay_readiness: probe.readiness.relay }),
+            ...(status.relay_connection?.status === undefined
+                ? {}
+                : { relay_connection_status: status.relay_connection.status }),
+        };
+    }
+    catch {
+        return { kind: "stale", reason_code: "local_control_unavailable" };
+    }
+}
+export async function inspectMachineProject(projectId, options) {
+    const inventory = inspectMachineProjectInventory(projectId, options.tuttiHome);
+    const probeRuntimeEndpoint = options.probeRuntimeEndpoint ?? createRuntimeEndpointProbe(options.fetchImpl ?? fetch);
+    const host = await inspectHost({
+        projectId,
+        endpoint: inventory.endpoint,
+        probeRuntimeEndpoint,
+        ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+    });
+    return {
+        ...inventory,
+        host,
+        relay: relayInspectionFromHost(host),
+    };
+}
+export function inspectMachineProjectInventory(projectId, tuttiHome) {
+    const binding = inspectBinding(tuttiHome, projectId);
+    const endpoint = inspectEndpoint(tuttiHome, projectId);
+    const workspaceRoot = binding.kind === "valid"
+        ? binding.record.workspace_root
+        : endpoint.kind === "valid"
+            ? endpoint.record.workspace_root
+            : undefined;
+    const workspace = inspectWorkspace(workspaceRoot, projectId);
+    const snapshotName = binding.kind === "valid" ? binding.record.display_name_snapshot : undefined;
+    const workspaceName = workspaceRoot === undefined ? undefined : basename(workspaceRoot);
+    const matchingDisplayName = workspace.kind === "matching" ? workspace.display_name : undefined;
+    return {
+        project_id: projectId,
+        binding,
+        endpoint,
+        workspace,
+        ...(workspaceRoot === undefined
+            ? {}
+            : {
+                workspace_root: workspaceRoot,
+                normalized_workspace_root: normalizeMachineWorkspacePath(workspaceRoot),
+            }),
+        display_name: matchingDisplayName ?? snapshotName ?? workspaceName ?? projectId,
+    };
+}
+export function inspectMachineProjectInventories(tuttiHome) {
+    return listMachineProjectIds(tuttiHome).map((projectId) => inspectMachineProjectInventory(projectId, tuttiHome));
+}
+export async function inspectMachineProjects(options) {
+    return await Promise.all(listMachineProjectIds(options.tuttiHome).map((projectId) => inspectMachineProject(projectId, options)));
+}
+//# sourceMappingURL=machine-project-inspector.js.map