@xfey/tutti 0.1.34 → 0.1.36

package/dist/server-shell/cli/host-runtime-endpoint.d.ts

@@ -19,6 +19,11 @@ export declare function requestExistingHostShutdown(options: {
     probeRuntimeEndpoint: HostRuntimeEndpointProbe;
     shutdownWaitMs: number;
 }): Promise<void>;
+export declare function waitForHostShutdown(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    probeRuntimeEndpoint: HostRuntimeEndpointProbe;
+    shutdownWaitMs: number;
+}): Promise<void>;
 export declare function readExistingHostLaunchStatus(options: {
     endpoint: MachineRuntimeEndpointRecord;
     fetchImpl: FetchLike;

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

@@ -85,6 +85,9 @@ export async function requestExistingHostShutdown(options) {
     if (!response.ok) {
         throw new LaunchError("takeover_failed", `The existing host server rejected takeover shutdown with HTTP ${response.status}`, "Stop the existing host server manually, then run `tutti launch` again.");
     }
+    await waitForHostShutdown(options);
+}
+export async function waitForHostShutdown(options) {
     const startedAt = Date.now();
     while (Date.now() - startedAt < options.shutdownWaitMs) {
         const probe = await options.probeRuntimeEndpoint(options.endpoint);

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

@@ -7,7 +7,7 @@ import { type TrustedRelaySessionMetadataStore } from "../session/relay-session-
 import type { HostRelayConnectionManager } from "./host-relay-connection-manager.js";
 import type { LaunchPreparationResult } from "./launch.js";
 import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
-export declare const HOST_SERVER_VERSION = "0.0.0";
+export declare const HOST_SERVER_VERSION: string;
 export type HostServerFactory = typeof createHostServer;
 export type HostServerHandle = {
     app: FastifyInstance;

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

@@ -18,10 +18,11 @@ 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 { readCliVersion } from "./version.js";
 import { relayStateFromLaunchStatus } from "./host-relay-status.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";
+export const HOST_SERVER_VERSION = readCliVersion();
 function createHostRuntimeLogger(options) {
     return {
         info(fields, message) {
@@ -262,6 +263,11 @@ export async function startForegroundHostServer(options) {
     let relayConnectionManager;
     const localControl = {
         token,
+        requestIdleShutdown: () => {
+            const execution = controlPlane.getExecutionStatus();
+            const hasActiveActivities = execution.active_activity !== undefined || (execution.active_activities?.length ?? 0) > 0;
+            return hasActiveActivities ? "busy" : "accepted";
+        },
         requestShutdown: () => {
             void close();
         },

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

@@ -68,6 +68,7 @@ export async function prepareLaunchProject(options) {
         tuttiHome,
         projectId,
         workspaceRoot,
+        relayUrl,
         displayNameSnapshot: readProjectDisplayName(workspaceRoot) ?? (basename(workspaceRoot) || projectId),
     };
     if (options.allowWorkspaceRootTakeover !== undefined) {

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

@@ -1,4 +1,4 @@
-import type { HostLocalLaunchStatus, HostLocalProjectProjection, HostLocalProviderConfigBody } from "../http/routes/local-control.js";
+import type { HostLocalIdleShutdownDisposition, 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>;
@@ -32,4 +32,8 @@ export declare function requestHostLocalShutdown(options: {
     endpoint: MachineRuntimeEndpointRecord;
     fetchImpl?: LocalControlFetch;
 }): Promise<void>;
+export declare function requestHostLocalIdleShutdown(options: {
+    endpoint: MachineRuntimeEndpointRecord;
+    fetchImpl?: LocalControlFetch;
+}): Promise<HostLocalIdleShutdownDisposition>;
 //# sourceMappingURL=local-control-client.d.ts.map

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

@@ -79,4 +79,26 @@ export async function requestHostLocalShutdown(options) {
         path: "/host-local/v1/shutdown",
     });
 }
+export async function requestHostLocalIdleShutdown(options) {
+    const response = await fetchWithTimeout(options.fetchImpl ?? fetch, new URL("/host-local/v1/shutdown-if-idle", options.endpoint.base_url), {
+        method: "POST",
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${options.endpoint.token}`,
+        },
+    });
+    if (response.status === 404) {
+        return "unsupported";
+    }
+    if (!response.ok) {
+        throw new Error(`host-local shutdown-if-idle returned HTTP ${response.status}`);
+    }
+    const body = (await response.json());
+    if (body.disposition !== "accepted" &&
+        body.disposition !== "busy" &&
+        body.disposition !== "unsupported") {
+        throw new Error("host-local shutdown-if-idle returned an invalid response");
+    }
+    return body.disposition;
+}
 //# sourceMappingURL=local-control-client.js.map

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

@@ -5,7 +5,9 @@ export type MachineProjectBindingRecord = {
     local_store_root: string;
     display_name_snapshot?: string;
     relay_project_ref?: RelayProjectRef;
+    relay_url?: string;
     host_registration_secret_ref?: string;
+    created_at?: string;
     updated_at: string;
 };
 export type HostRegistrationSecretFile = {
@@ -28,6 +30,7 @@ export type EnsureMachineProjectBindingOptions = {
     projectId: ProjectId;
     workspaceRoot: string;
     displayNameSnapshot?: string;
+    relayUrl?: string;
     allowWorkspaceRootTakeover?: boolean;
     now?: () => Date;
 };

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

@@ -78,7 +78,10 @@ export function readMachineProjectBinding(tuttiHome, projectId) {
             (typeof raw.relay_project_ref !== "string" ||
                 !isPrefixedId(raw.relay_project_ref, ID_PREFIXES.relayProject))) ||
         (raw.host_registration_secret_ref !== undefined &&
-            typeof raw.host_registration_secret_ref !== "string")) {
+            typeof raw.host_registration_secret_ref !== "string") ||
+        (raw.relay_url !== undefined &&
+            (typeof raw.relay_url !== "string" || raw.relay_url.trim() === "")) ||
+        (raw.created_at !== undefined && typeof raw.created_at !== "string")) {
         throw new LaunchError("project_identity_conflict", "Machine-local project binding is invalid or conflicts with the Git config project identity", "Inspect or remove the project binding under TUTTI_HOME after confirming it is not needed.");
     }
     const binding = {
@@ -93,9 +96,15 @@ export function readMachineProjectBinding(tuttiHome, projectId) {
     if (raw.relay_project_ref !== undefined) {
         binding.relay_project_ref = raw.relay_project_ref;
     }
+    if (raw.relay_url !== undefined) {
+        binding.relay_url = raw.relay_url;
+    }
     if (raw.host_registration_secret_ref !== undefined) {
         binding.host_registration_secret_ref = raw.host_registration_secret_ref;
     }
+    if (raw.created_at !== undefined) {
+        binding.created_at = raw.created_at;
+    }
     return binding;
 }
 export function readMachineRuntimeEndpoint(tuttiHome, projectId) {
@@ -226,7 +235,11 @@ function ensureHostRegistrationSecret(tuttiHome, projectId, now) {
     const secretPath = getHostRegistrationSecretPath(tuttiHome, projectId);
     const ref = createHostRegistrationSecretRef(projectId);
     if (existsSync(secretPath)) {
-        return { ref, created: false };
+        return {
+            ref,
+            created: false,
+            createdAt: readHostRegistrationSecret(tuttiHome, projectId).created_at,
+        };
     }
     const timestamp = now().toISOString();
     const secretFile = {
@@ -237,7 +250,7 @@ function ensureHostRegistrationSecret(tuttiHome, projectId, now) {
         updated_at: timestamp,
     };
     writePrivateJsonFile(secretPath, secretFile);
-    return { ref, created: true };
+    return { ref, created: true, createdAt: timestamp };
 }
 export function ensureMachineProjectBinding(options) {
     const now = options.now ?? (() => new Date());
@@ -256,6 +269,7 @@ export function ensureMachineProjectBinding(options) {
         workspace_root: workspaceRoot,
         local_store_root: localStoreRoot,
         host_registration_secret_ref: existing?.host_registration_secret_ref ?? secret.ref,
+        created_at: existing?.created_at ?? secret.createdAt,
         updated_at: now().toISOString(),
     };
     const displayNameSnapshot = options.displayNameSnapshot?.trim();
@@ -268,6 +282,13 @@ export function ensureMachineProjectBinding(options) {
     if (existing?.relay_project_ref !== undefined) {
         binding.relay_project_ref = existing.relay_project_ref;
     }
+    const relayUrl = options.relayUrl?.trim();
+    if (relayUrl !== undefined && relayUrl !== "") {
+        binding.relay_url = relayUrl;
+    }
+    else if (existing?.relay_url !== undefined) {
+        binding.relay_url = existing.relay_url;
+    }
     writePrivateJsonFile(bindingPath, binding);
     return {
         binding,

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

@@ -17,6 +17,7 @@ export declare function waitForManagedHostReady(options: {
     projectId: ProjectId;
     workspaceRoot: string;
     fetchImpl?: FetchLike;
+    inviteMode?: "required" | "preserve";
     timeoutMs?: number;
 }): Promise<ManagedHostReadyResult>;
 //# sourceMappingURL=managed-host.d.ts.map

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

@@ -66,7 +66,7 @@ export async function waitForManagedHostReady(options) {
                 endpoint,
                 ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
             });
-            if (status.relay?.join_url === undefined) {
+            if (status.relay?.join_url === undefined && options.inviteMode !== "preserve") {
                 status = await rotateHostLocalInvite({
                     endpoint,
                     ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
@@ -84,6 +84,9 @@ export async function waitForManagedHostReady(options) {
                         : { join_token_reusable: status.relay.join_token_reusable }),
                 };
             }
+            if (options.inviteMode === "preserve" && status.relay !== undefined) {
+                return { endpoint };
+            }
             lastReason = "host is running but Relay invite is not visible yet";
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import type { ProjectId } from "@tutti/shared/ids";
+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 { LocalControlFetch } from "./local-control-client.js";
@@ -9,7 +9,7 @@ export type RuntimeProjectRow = {
     workspace_root: string;
     endpoint?: string;
     provider_status?: string;
-    relay_project_ref?: string;
+    relay_project_ref?: RelayProjectRef;
     join_url?: string;
     relay_connection_status?: string;
     last_connected_at?: string;

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

@@ -101,6 +101,10 @@ export async function listRuntimeProjects(options = {}) {
         if (launchStatus?.relay?.relay_project_ref !== undefined) {
             row.relay_project_ref = launchStatus.relay.relay_project_ref;
         }
+        else if (inspection.binding.kind === "valid" &&
+            inspection.binding.record.relay_project_ref !== undefined) {
+            row.relay_project_ref = inspection.binding.record.relay_project_ref;
+        }
         if (launchStatus?.relay?.join_url !== undefined) {
             row.join_url = launchStatus.relay.join_url;
         }

package/dist/server-shell/http/routes/local-control.d.ts

@@ -14,8 +14,10 @@ export type HostLocalControlOptions = {
         get: () => ProviderConfigProjection;
         configure: (input: HostLocalProviderConfigBody) => Promise<ProviderConfigProjection>;
     };
+    requestIdleShutdown?: () => HostLocalIdleShutdownDisposition;
     requestShutdown: () => void;
 };
+export type HostLocalIdleShutdownDisposition = "accepted" | "busy" | "unsupported";
 export type HostLocalLaunchStatus = {
     project_id?: ProjectId;
     relay_connection?: {

package/dist/server-shell/http/routes/local-control.js

@@ -31,6 +31,14 @@ class HostLocalProjectValidationError extends Error {
         this.name = "HostLocalProjectValidationError";
     }
 }
+class HostLocalDrainingError extends Error {
+    statusCode = 409;
+    code = "conflict";
+    constructor() {
+        super("Host is draining for a safe restart");
+        this.name = "HostLocalDrainingError";
+    }
+}
 const HostLocalShutdownResponseSchema = {
     type: "object",
     required: ["ok"],
@@ -39,6 +47,14 @@ const HostLocalShutdownResponseSchema = {
         ok: { type: "boolean", enum: [true] },
     },
 };
+const HostLocalIdleShutdownResponseSchema = {
+    type: "object",
+    required: ["disposition"],
+    additionalProperties: false,
+    properties: {
+        disposition: { type: "string", enum: ["accepted", "busy", "unsupported"] },
+    },
+};
 const HostLocalProviderConfigBodySchema = {
     type: "object",
     required: ["api_key"],
@@ -190,6 +206,46 @@ function normalizeProjectBody(input) {
     return { display_name: displayName };
 }
 export function registerHostLocalControlRoutes(app, options) {
+    const mutationTracked = Symbol("hostLocalMutationTracked");
+    const shutdownPath = "/host-local/v1/shutdown";
+    const idleShutdownPath = "/host-local/v1/shutdown-if-idle";
+    let activeMutations = 0;
+    let draining = false;
+    function releaseTrackedMutation(request) {
+        const trackedRequest = request;
+        if (trackedRequest[mutationTracked] !== true) {
+            return;
+        }
+        trackedRequest[mutationTracked] = false;
+        activeMutations = Math.max(0, activeMutations - 1);
+    }
+    app.addHook("onRequest", (request, _reply, done) => {
+        const path = request.url.split("?", 1)[0];
+        const mutation = request.method !== "GET" &&
+            request.method !== "HEAD" &&
+            request.method !== "OPTIONS" &&
+            path !== shutdownPath &&
+            path !== idleShutdownPath;
+        if (!mutation) {
+            done();
+            return;
+        }
+        if (draining) {
+            done(new HostLocalDrainingError());
+            return;
+        }
+        activeMutations += 1;
+        Object.assign(request, { [mutationTracked]: true });
+        done();
+    });
+    app.addHook("onResponse", (request, _reply, done) => {
+        releaseTrackedMutation(request);
+        done();
+    });
+    app.addHook("onRequestAbort", (request, done) => {
+        releaseTrackedMutation(request);
+        done();
+    });
     function requireLocalToken(authorization) {
         const token = readBearerToken(authorization);
         if (!tokenEquals(token, options.token)) {
@@ -286,7 +342,28 @@ export function registerHostLocalControlRoutes(app, options) {
         }
         return options.project.update(normalizeProjectBody(request.body));
     });
-    app.post("/host-local/v1/shutdown", {
+    app.post(idleShutdownPath, {
+        schema: {
+            response: {
+                200: HostLocalIdleShutdownResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (draining) {
+            return { disposition: "accepted" };
+        }
+        if (activeMutations > 0) {
+            return { disposition: "busy" };
+        }
+        const disposition = options.requestIdleShutdown?.() ?? "unsupported";
+        if (disposition === "accepted") {
+            draining = true;
+            setImmediate(options.requestShutdown);
+        }
+        return { disposition };
+    });
+    app.post(shutdownPath, {
         schema: {
             response: {
                 202: HostLocalShutdownResponseSchema,

package/dist/server-shell/local-console/project-service.d.ts

@@ -1,4 +1,5 @@
-import type { ProjectId } from "@tutti/shared/ids";
+import { type ProjectId, type RelayProjectRef } from "@tutti/shared/ids";
+import { type FetchLike } from "../cli/host-runtime-endpoint.js";
 import { type RuntimeProjectRow } from "../cli/runtime-commands.js";
 import { type LocalConsoleInvocationContext } from "./invocation-context.js";
 export type LocalConsoleProject = {
@@ -7,9 +8,12 @@ export type LocalConsoleProject = {
     workspace_path: string;
     status: RuntimeProjectRow["status"];
     provider_status: "configured" | "not_configured" | "invalid";
-    relay_project_ref?: string;
+    provider_model?: string;
+    relay_project_ref?: RelayProjectRef;
     join_url?: string;
+    open_url?: string;
     relay_connection_status?: string;
+    created_at?: string;
     activity_at?: string;
     host_version?: string;
     update_required?: boolean;
@@ -21,9 +25,15 @@ export type LocalConsoleProviderInput = {
 };
 export type LocalConsoleLaunchResult = {
     project: LocalConsoleProject;
+    project_created: boolean;
     join_url: string;
     join_token_expires_at?: string;
 };
+export type LocalConsoleOpenResult = {
+    project: LocalConsoleProject;
+    open_url: string;
+    disposition: "opened_current" | "updated" | "deferred_busy" | "deferred_unsupported" | "deferred_unavailable";
+};
 export declare class LocalConsoleProjectError extends Error {
     readonly code: string;
     readonly statusCode: number;
@@ -34,6 +44,7 @@ export declare class LocalConsoleProjectService {
     constructor(options: {
         tuttiHome: string;
         serviceEnvironment?: NodeJS.ProcessEnv;
+        fetchImpl?: FetchLike;
     });
     listProjects(context: LocalConsoleInvocationContext): Promise<LocalConsoleProject[]>;
     discoverModels(input: {
@@ -50,6 +61,7 @@ export declare class LocalConsoleProjectService {
         workspacePath: string;
         provider?: LocalConsoleProviderInput;
     }, context: LocalConsoleInvocationContext): Promise<LocalConsoleLaunchResult>;
+    openProject(projectId: string, context: LocalConsoleInvocationContext): Promise<LocalConsoleOpenResult>;
     refreshInvite(projectId: string, context: LocalConsoleInvocationContext): Promise<{
         join_url: string;
         expires_at?: string;