@xfey/tutti 0.1.34 → 0.1.36

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

@@ -1,15 +1,18 @@
 import { existsSync, statSync } from "node:fs";
 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 { prepareLaunchProject } from "../cli/launch.js";
-import { rotateHostLocalInvite } from "../cli/local-control-client.js";
-import { readMachineProjectBinding, readMachineRuntimeEndpoint } from "../cli/machine-local.js";
+import { createRuntimeEndpointProbe, waitForHostShutdown, } from "../cli/host-runtime-endpoint.js";
+import { prepareLaunchProject, resolveRelayUrl } from "../cli/launch.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;
@@ -47,27 +50,43 @@ function validateProvider(input) {
     }
     return provider;
 }
-function projectFromRuntimeRow(row, providerStatus, activityAt) {
+function projectFromRuntimeRow(row, providerStatus, providerModel, metadata) {
     const currentVersion = readCliVersion();
+    const openUrl = projectOpenUrl(metadata.relayUrl, row.relay_project_ref);
     return {
         project_id: row.project_id,
         display_name: row.display_name,
         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 }),
         ...(row.relay_connection_status === undefined
             ? {}
             : { relay_connection_status: row.relay_connection_status }),
-        ...(activityAt === undefined ? {} : { activity_at: activityAt }),
+        ...(metadata.activityAt === undefined ? {} : { activity_at: metadata.activityAt }),
+        ...(metadata.createdAt === undefined ? {} : { created_at: metadata.createdAt }),
         ...(row.host_version === undefined ? {} : { host_version: row.host_version }),
         ...(row.host_version === undefined || row.host_version === currentVersion
             ? {}
             : { update_required: true }),
     };
 }
-function readProjectActivityAt(tuttiHome, row) {
+function projectOpenUrl(relayUrl, relayProjectRef) {
+    if (relayUrl === undefined || relayProjectRef === undefined) {
+        return undefined;
+    }
+    try {
+        const url = new URL(`/projects?open=${encodeURIComponent(relayProjectRouteSegment(relayProjectRef))}`, relayUrl);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readProjectActivityAt(tuttiHome, row, binding) {
     if (row.last_connected_at !== undefined) {
         return row.last_connected_at;
     }
@@ -81,7 +100,18 @@ function readProjectActivityAt(tuttiHome, row) {
         // Invalid endpoint state is already represented by the project status.
     }
     try {
-        return readMachineProjectBinding(tuttiHome, row.project_id)?.updated_at;
+        return binding?.updated_at;
+    }
+    catch {
+        return undefined;
+    }
+}
+function relayUrlFromJoinUrl(joinUrl) {
+    if (joinUrl === undefined) {
+        return undefined;
+    }
+    try {
+        return new URL(joinUrl).origin;
     }
     catch {
         return undefined;
@@ -90,11 +120,13 @@ function readProjectActivityAt(tuttiHome, row) {
 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 {
@@ -115,14 +147,58 @@ export class LocalConsoleProjectService {
         const operation = this.#operationOptions(context);
         const rows = await listRuntimeProjects({
             all: true,
+            fetchImpl: this.#fetchImpl,
             ...operation,
         });
         return rows.map((row) => {
+            let binding = null;
+            try {
+                binding = readMachineProjectBinding(this.#tuttiHome, row.project_id);
+            }
+            catch {
+                // Invalid binding state is already represented by the project status.
+            }
+            let createdAt = binding?.created_at;
+            if (createdAt === undefined) {
+                try {
+                    createdAt = readHostRegistrationSecret(this.#tuttiHome, row.project_id).created_at;
+                }
+                catch {
+                    // Damaged legacy metadata remains visible without an invented creation date.
+                }
+            }
             const provider = readOpenAiProviderConfigProjection({
                 tuttiHome: this.#tuttiHome,
                 projectId: row.project_id,
             });
-            return projectFromRuntimeRow(row, provider.status, readProjectActivityAt(this.#tuttiHome, row));
+            const providerModel = provider.status === "not_configured" ? undefined : provider.default_model;
+            const activityAt = readProjectActivityAt(this.#tuttiHome, row, binding);
+            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) {
@@ -180,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.");
@@ -200,6 +272,7 @@ export class LocalConsoleProjectService {
             }
             return {
                 project,
+                project_created: preparation.project_identity_created,
                 join_url: ready.join_url,
                 ...(ready.join_token_expires_at === undefined
                     ? {}
@@ -210,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({
@@ -220,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.34",
+  "version": "0.1.36",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",