@xfey/tutti 0.1.35 → 0.1.37

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/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/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/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, 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,6 +8,7 @@ export type LocalConsoleProject = {
     workspace_path: string;
     status: RuntimeProjectRow["status"];
     provider_status: "configured" | "not_configured" | "invalid";
+    provider_model?: string;
     relay_project_ref?: RelayProjectRef;
     join_url?: string;
     open_url?: string;
@@ -27,6 +29,11 @@ export type LocalConsoleLaunchResult = {
     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;
@@ -37,6 +44,7 @@ export declare class LocalConsoleProjectService {
     constructor(options: {
         tuttiHome: string;
         serviceEnvironment?: NodeJS.ProcessEnv;
+        fetchImpl?: FetchLike;
     });
     listProjects(context: LocalConsoleInvocationContext): Promise<LocalConsoleProject[]>;
     discoverModels(input: {
@@ -53,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;

package/dist/server-shell/local-console/project-service.js

@@ -3,14 +3,16 @@ import { resolve } from "node:path";
 import { relayProjectRouteSegment } from "@tutti/shared/ids";
 import { configureProjectOpenAiProvider, discoverOpenAiModels, readOpenAiProviderConfigProjection, } from "../../providers/openai/index.js";
 import { formatCliErrorReason, LaunchError } from "../cli/errors.js";
+import { createRuntimeEndpointProbe, waitForHostShutdown, } from "../cli/host-runtime-endpoint.js";
 import { prepareLaunchProject, resolveRelayUrl } from "../cli/launch.js";
-import { rotateHostLocalInvite } from "../cli/local-control-client.js";
+import { requestHostLocalIdleShutdown, rotateHostLocalInvite, } from "../cli/local-control-client.js";
 import { readHostRegistrationSecret, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "../cli/machine-local.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
 import { resolveManagedProjectContext } from "../cli/project-resolver.js";
 import { listRuntimeProjects, runStopCommand, } from "../cli/runtime-commands.js";
 import { readCliVersion } from "../cli/version.js";
 import { createLocalConsoleOperationEnvironment, } from "./invocation-context.js";
+const OPEN_UPDATE_SHUTDOWN_WAIT_MS = 5_000;
 export class LocalConsoleProjectError extends Error {
     code;
     statusCode;
@@ -48,7 +50,7 @@ function validateProvider(input) {
     }
     return provider;
 }
-function projectFromRuntimeRow(row, providerStatus, metadata) {
+function projectFromRuntimeRow(row, providerStatus, providerModel, metadata) {
     const currentVersion = readCliVersion();
     const openUrl = projectOpenUrl(metadata.relayUrl, row.relay_project_ref);
     return {
@@ -57,6 +59,7 @@ function projectFromRuntimeRow(row, providerStatus, metadata) {
         workspace_path: row.workspace_root,
         status: row.status,
         provider_status: providerStatus,
+        ...(providerModel === undefined ? {} : { provider_model: providerModel }),
         ...(row.relay_project_ref === undefined ? {} : { relay_project_ref: row.relay_project_ref }),
         ...(row.join_url === undefined ? {} : { join_url: row.join_url }),
         ...(openUrl === undefined ? {} : { open_url: openUrl }),
@@ -117,11 +120,13 @@ function relayUrlFromJoinUrl(joinUrl) {
 export class LocalConsoleProjectService {
     #tuttiHome;
     #serviceEnvironment;
+    #fetchImpl;
     #launches = new Map();
     #mutationTail = Promise.resolve();
     constructor(options) {
         this.#tuttiHome = resolve(options.tuttiHome);
         this.#serviceEnvironment = options.serviceEnvironment ?? process.env;
+        this.#fetchImpl = options.fetchImpl ?? fetch;
     }
     #operationOptions(context) {
         return {
@@ -142,6 +147,7 @@ export class LocalConsoleProjectService {
         const operation = this.#operationOptions(context);
         const rows = await listRuntimeProjects({
             all: true,
+            fetchImpl: this.#fetchImpl,
             ...operation,
         });
         return rows.map((row) => {
@@ -165,14 +171,36 @@ export class LocalConsoleProjectService {
                 tuttiHome: this.#tuttiHome,
                 projectId: row.project_id,
             });
+            const providerModel = provider.status === "not_configured" ? undefined : provider.default_model;
             const activityAt = readProjectActivityAt(this.#tuttiHome, row, binding);
-            return projectFromRuntimeRow(row, provider.status, {
+            return projectFromRuntimeRow(row, provider.status, providerModel, {
                 ...(activityAt === undefined ? {} : { activityAt }),
                 ...(createdAt === undefined ? {} : { createdAt }),
                 relayUrl: binding?.relay_url ?? relayUrlFromJoinUrl(row.join_url) ?? resolveRelayUrl(operation.env),
             });
         });
     }
+    async #readProject(projectId, context) {
+        const project = (await this.listProjects(context)).find((candidate) => candidate.project_id === projectId);
+        if (project === undefined) {
+            throw new LocalConsoleProjectError("project_not_found", "The project could not be read from the machine project list.", 404);
+        }
+        return project;
+    }
+    async #startManagedHost(options) {
+        spawnDetachedHost({
+            workspaceRoot: options.workspaceRoot,
+            env: options.env,
+            inheritProcessEnv: false,
+        });
+        return await waitForManagedHostReady({
+            tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
+            workspaceRoot: options.workspaceRoot,
+            fetchImpl: this.#fetchImpl,
+            ...(options.inviteMode === undefined ? {} : { inviteMode: options.inviteMode }),
+        });
+    }
     async discoverModels(input) {
         const provider = validateProvider({
             base_url: input.baseUrl,
@@ -228,15 +256,11 @@ export class LocalConsoleProjectService {
             throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
         }
         try {
-            spawnDetachedHost({
+            const ready = await this.#startManagedHost({
                 workspaceRoot: preparation.workspace_root,
-                env: operation.env,
-                inheritProcessEnv: false,
-            });
-            const ready = await waitForManagedHostReady({
                 tuttiHome: preparation.tutti_home,
                 projectId: preparation.project_id,
-                workspaceRoot: preparation.workspace_root,
+                env: operation.env,
             });
             if (ready.join_url === undefined) {
                 throw new LocalConsoleProjectError("relay_registration_failed", "The host started, but Relay did not return a visible join link.");
@@ -259,6 +283,87 @@ export class LocalConsoleProjectService {
             throw this.#normalizeError(error);
         }
     }
+    async openProject(projectId, context) {
+        return await this.#runMutation(async () => {
+            const current = await this.#readProject(projectId, context);
+            if (current.open_url === undefined) {
+                throw new LocalConsoleProjectError("project_open_unavailable", "This project does not have a Relay destination yet.");
+            }
+            if (current.update_required !== true) {
+                return {
+                    project: current,
+                    open_url: current.open_url,
+                    disposition: "opened_current",
+                };
+            }
+            let managed;
+            try {
+                managed = resolveManagedProjectContext({
+                    target: projectId,
+                    ...this.#operationOptions(context),
+                });
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+            if (!managed.workspace_exists ||
+                managed.runtime_endpoint === null ||
+                managed.provider_config.status !== "configured") {
+                return {
+                    project: current,
+                    open_url: current.open_url,
+                    disposition: "deferred_unavailable",
+                };
+            }
+            let shutdownDisposition;
+            try {
+                shutdownDisposition = await requestHostLocalIdleShutdown({
+                    endpoint: managed.runtime_endpoint,
+                    fetchImpl: this.#fetchImpl,
+                });
+            }
+            catch {
+                return {
+                    project: current,
+                    open_url: current.open_url,
+                    disposition: "deferred_unavailable",
+                };
+            }
+            if (shutdownDisposition !== "accepted") {
+                return {
+                    project: current,
+                    open_url: current.open_url,
+                    disposition: shutdownDisposition === "busy" ? "deferred_busy" : "deferred_unsupported",
+                };
+            }
+            try {
+                await waitForHostShutdown({
+                    endpoint: managed.runtime_endpoint,
+                    probeRuntimeEndpoint: createRuntimeEndpointProbe(this.#fetchImpl),
+                    shutdownWaitMs: OPEN_UPDATE_SHUTDOWN_WAIT_MS,
+                });
+                await this.#startManagedHost({
+                    workspaceRoot: managed.workspace_root,
+                    tuttiHome: managed.tutti_home,
+                    projectId: managed.project_id,
+                    env: this.#operationOptions(context).env,
+                    inviteMode: "preserve",
+                });
+                const updated = await this.#readProject(projectId, context);
+                if (updated.open_url === undefined) {
+                    throw new LocalConsoleProjectError("project_open_unavailable", "The updated project does not have a Relay destination.");
+                }
+                return {
+                    project: updated,
+                    open_url: updated.open_url,
+                    disposition: "updated",
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
+    }
     async refreshInvite(projectId, context) {
         return await this.#runMutation(async () => {
             const project = resolveManagedProjectContext({
@@ -269,7 +374,10 @@ export class LocalConsoleProjectService {
                 throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
             }
             try {
-                const status = await rotateHostLocalInvite({ endpoint: project.runtime_endpoint });
+                const status = await rotateHostLocalInvite({
+                    endpoint: project.runtime_endpoint,
+                    fetchImpl: this.#fetchImpl,
+                });
                 const joinUrl = status.relay?.join_url;
                 if (joinUrl === undefined) {
                     throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");

package/dist/server-shell/local-console/server.js

@@ -276,6 +276,10 @@ export function createLocalConsoleServer(options) {
             ...(request.body.provider === undefined ? {} : { provider: request.body.provider }),
         }, session.context);
     });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/open`, async (request) => {
+        const session = requireSession(request, true);
+        return await projects.openProject(request.params.projectId, session.context);
+    });
     app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/invite`, async (request) => {
         const session = requireSession(request, true);
         return await projects.refreshInvite(request.params.projectId, session.context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",