@xfey/tutti 0.1.33 → 0.1.35

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

@@ -0,0 +1,135 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, closeSync, constants, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 35_000;
+const LOCK_POLL_MS = 100;
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+function lockPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "local-console.lock");
+}
+function ensurePrivateRuntimeDirectory(tuttiHome) {
+    const directory = dirname(lockPath(tuttiHome));
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+}
+function lockOwnerAlive(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!Number.isInteger(value.pid)) {
+            return false;
+        }
+        process.kill(value.pid, 0);
+        return true;
+    }
+    catch (error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "EPERM");
+    }
+}
+function removeStaleLock(path, now, staleMs) {
+    try {
+        const age = now() - statSync(path).mtimeMs;
+        if (age < staleMs || lockOwnerAlive(path)) {
+            return false;
+        }
+        unlinkSync(path);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return true;
+        }
+        return false;
+    }
+}
+async function acquireLock(options) {
+    const now = options.now ?? Date.now;
+    const timing = options.timing ?? {
+        staleMs: LOCK_STALE_MS,
+        waitMs: LOCK_WAIT_MS,
+        pollMs: LOCK_POLL_MS,
+    };
+    const path = lockPath(options.tuttiHome);
+    const deadline = now() + timing.waitMs;
+    const ownerId = randomBytes(16).toString("base64url");
+    ensurePrivateRuntimeDirectory(options.tuttiHome);
+    while (now() < deadline) {
+        try {
+            const descriptor = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            try {
+                writeFileSync(descriptor, `${JSON.stringify({
+                    pid: process.pid,
+                    owner_id: ownerId,
+                    acquired_at: new Date(now()).toISOString(),
+                })}\n`, "utf8");
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            chmodSync(path, 0o600);
+            return () => {
+                try {
+                    let record;
+                    try {
+                        record = JSON.parse(readFileSync(path, "utf8"));
+                    }
+                    catch {
+                        return;
+                    }
+                    if (record.owner_id !== ownerId) {
+                        return;
+                    }
+                    unlinkSync(path);
+                }
+                catch (error) {
+                    if (typeof error !== "object" ||
+                        error === null ||
+                        !("code" in error) ||
+                        error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            };
+        }
+        catch (error) {
+            if (typeof error !== "object" ||
+                error === null ||
+                !("code" in error) ||
+                error.code !== "EEXIST") {
+                throw error;
+            }
+            removeStaleLock(path, now, timing.staleMs);
+            await delay(timing.pollMs);
+        }
+    }
+    throw new Error("Timed out waiting for the Tutti service lifecycle lock.");
+}
+export async function withLocalConsoleLifecycleLock(options) {
+    const timing = options.timing === undefined
+        ? undefined
+        : {
+            staleMs: options.timing.staleMs ?? LOCK_STALE_MS,
+            waitMs: options.timing.waitMs ?? LOCK_WAIT_MS,
+            pollMs: options.timing.pollMs ?? LOCK_POLL_MS,
+        };
+    const release = await acquireLock({
+        tuttiHome: options.tuttiHome,
+        ...(options.now === undefined ? {} : { now: options.now }),
+        ...(timing === undefined ? {} : { timing }),
+    });
+    try {
+        return await options.run();
+    }
+    finally {
+        release();
+    }
+}
+//# sourceMappingURL=lifecycle-lock.js.map

package/dist/server-shell/local-console/managed-console.d.ts

@@ -1,9 +1,47 @@
 import { type LocalConsoleRuntimeEndpoint } from "./runtime-endpoint.js";
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type LocalConsoleServiceStatus = {
+    status: "stopped";
+    log_path: string;
+} | {
+    status: "stale";
+    pid: number;
+    base_url: string;
+    started_at: string;
+    log_path: string;
+} | {
+    status: "running";
+    pid: number;
+    base_url: string;
+    started_at: string;
+    version: string;
+    current_version: string;
+    update_required: boolean;
+    log_path: string;
+};
+export declare function getLocalConsoleLogPath(tuttiHome: string): string;
 export declare function ensureLocalConsole(options?: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
 }): Promise<{
     url: string;
     endpoint: LocalConsoleRuntimeEndpoint;
 }>;
+export declare function readLocalConsoleServiceStatus(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<LocalConsoleServiceStatus>;
+export declare function stopLocalConsoleService(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<"stopped" | "already_stopped">;
+export declare function restartLocalConsoleService(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<LocalConsoleRuntimeEndpoint>;
+export {};
 //# sourceMappingURL=managed-console.d.ts.map

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

@@ -1,10 +1,16 @@
 import { spawn } from "node:child_process";
-import { resolve } from "node:path";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, renameSync, statSync, unlinkSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliVersion } from "../cli/version.js";
+import { createLocalConsoleInvocationContext, createLocalConsoleServiceEnvironment, } from "./invocation-context.js";
+import { withLocalConsoleLifecycleLock } from "./lifecycle-lock.js";
 import { deleteLocalConsoleRuntimeEndpoint, readLocalConsoleRuntimeEndpoint, } from "./runtime-endpoint.js";
 import { LOCAL_CONSOLE_API_BASE } from "./server.js";
 const READY_TIMEOUT_MS = 15_000;
 const READY_POLL_MS = 150;
+const STOP_TIMEOUT_MS = 5_000;
+const CONSOLE_LOG_MAX_BYTES = 2 * 1024 * 1024;
 function delay(milliseconds) {
     return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
 }
@@ -13,82 +19,294 @@ function cliEntrypoint() {
     if (entrypoint === undefined || entrypoint.trim() === "") {
         throw new Error("Cannot locate the Tutti CLI entrypoint.");
     }
-    return entrypoint;
+    return resolve(entrypoint);
 }
-async function endpointReady(endpoint) {
+export function getLocalConsoleLogPath(tuttiHome) {
+    return join(tuttiHome, "logs", "console.log");
+}
+function prepareConsoleLog(tuttiHome) {
+    const path = getLocalConsoleLogPath(tuttiHome);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    if (existsSync(path) && statSync(path).size >= CONSOLE_LOG_MAX_BYTES) {
+        const previousPath = `${path}.1`;
+        if (existsSync(previousPath)) {
+            unlinkSync(previousPath);
+        }
+        renameSync(path, previousPath);
+    }
+    const descriptor = openSync(path, "a", 0o600);
+    chmodSync(path, 0o600);
+    return descriptor;
+}
+async function endpointHealth(endpoint, fetchImpl) {
     try {
-        const response = await fetch(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/health`, {
+        const response = await fetchImpl(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/health`, {
             signal: AbortSignal.timeout(1_000),
         });
         if (!response.ok) {
-            return false;
+            return { kind: "stale" };
         }
         const value = (await response.json());
-        return value.status === "ready";
+        if (value.status !== "ready") {
+            return { kind: "stale" };
+        }
+        if (endpoint.schema_version === 1) {
+            return { kind: "ready", identityVerified: false };
+        }
+        return {
+            kind: "ready",
+            identityVerified: value.instance_id === endpoint.instance_id && value.pid === endpoint.pid,
+        };
     }
     catch {
-        return false;
+        return { kind: "stale" };
     }
 }
+function endpointMatchesCurrentRuntime(endpoint) {
+    return (endpoint.schema_version === 2 &&
+        endpoint.version === readCliVersion() &&
+        resolve(endpoint.entrypoint) === cliEntrypoint());
+}
 function spawnDetachedConsole(options) {
-    const child = spawn(process.execPath, [...process.execArgv, cliEntrypoint(), "internal", "console-run"], {
-        cwd: options.cwd,
-        detached: true,
-        env: options.env,
-        stdio: "ignore",
-    });
-    child.unref();
+    const logDescriptor = prepareConsoleLog(options.tuttiHome);
+    try {
+        const child = spawn(process.execPath, [...process.execArgv, cliEntrypoint(), "internal", "console-run"], {
+            cwd: options.cwd,
+            detached: true,
+            env: createLocalConsoleServiceEnvironment({
+                env: options.env,
+                tuttiHome: options.tuttiHome,
+            }),
+            stdio: ["ignore", logDescriptor, logDescriptor],
+        });
+        child.on("error", () => undefined);
+        child.unref();
+        return child;
+    }
+    finally {
+        closeSync(logDescriptor);
+    }
 }
-async function waitForConsoleEndpoint(tuttiHome) {
+async function waitForConsoleEndpoint(options) {
     const deadline = Date.now() + READY_TIMEOUT_MS;
     while (Date.now() < deadline) {
-        const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
-        if (endpoint !== null && (await endpointReady(endpoint))) {
-            return endpoint;
+        const endpoint = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (endpoint?.schema_version === 2 && endpointMatchesCurrentRuntime(endpoint)) {
+            const health = await endpointHealth(endpoint, options.fetchImpl);
+            if (health.kind === "ready" && health.identityVerified) {
+                return endpoint;
+            }
         }
         await delay(READY_POLL_MS);
     }
-    throw new Error("Tutti Local Console did not become ready. Run `tutti doctor` for diagnostics.");
+    throw new Error(`Tutti service did not become ready. Inspect ${getLocalConsoleLogPath(options.tuttiHome)}.`);
 }
-async function ensureConsoleEndpoint(options) {
-    const existing = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
-    if (existing !== null && (await endpointReady(existing))) {
-        return existing;
+async function waitForEndpointToStop(options) {
+    const deadline = Date.now() + STOP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const current = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (current === null || current.control_token !== options.endpoint.control_token) {
+            return true;
+        }
+        if ((await endpointHealth(options.endpoint, options.fetchImpl)).kind === "stale") {
+            deleteLocalConsoleRuntimeEndpoint({
+                tuttiHome: options.tuttiHome,
+                expectedControlToken: options.endpoint.control_token,
+            });
+            return true;
+        }
+        await delay(100);
     }
-    if (existing !== null) {
+    return false;
+}
+async function authenticateLegacyEndpoint(options) {
+    try {
+        const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${options.endpoint.control_token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ current_directory: options.cwd }),
+            signal: AbortSignal.timeout(2_000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopEndpoint(options) {
+    const health = await endpointHealth(options.endpoint, options.fetchImpl);
+    if (health.kind === "stale") {
         deleteLocalConsoleRuntimeEndpoint({
             tuttiHome: options.tuttiHome,
-            expectedControlToken: existing.control_token,
+            expectedControlToken: options.endpoint.control_token,
+        });
+        return;
+    }
+    if (options.endpoint.schema_version === 2 && !health.identityVerified) {
+        throw new Error("The running Tutti service identity does not match its endpoint record.");
+    }
+    let shutdownAccepted = false;
+    try {
+        const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/control/shutdown`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${options.endpoint.control_token}` },
+            signal: AbortSignal.timeout(2_000),
         });
+        shutdownAccepted = response.ok;
+    }
+    catch {
+        // A legacy service is handled by the authenticated SIGTERM fallback below.
+    }
+    if (!shutdownAccepted) {
+        const authenticated = await authenticateLegacyEndpoint(options);
+        if (!authenticated) {
+            throw new Error("The running Tutti service identity could not be verified.");
+        }
+        process.kill(options.endpoint.pid, "SIGTERM");
+    }
+    if (!(await waitForEndpointToStop(options))) {
+        throw new Error("The Tutti service did not stop before the shutdown timeout.");
+    }
+}
+async function ensureConsoleEndpointUnlocked(options) {
+    const existing = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+    if (existing !== null) {
+        const health = await endpointHealth(existing, options.fetchImpl);
+        if (health.kind === "ready" &&
+            (existing.schema_version === 1 || health.identityVerified) &&
+            endpointMatchesCurrentRuntime(existing)) {
+            return existing;
+        }
+        if (health.kind === "ready") {
+            await stopEndpoint({ ...options, endpoint: existing });
+        }
+        else {
+            deleteLocalConsoleRuntimeEndpoint({
+                tuttiHome: options.tuttiHome,
+                expectedControlToken: existing.control_token,
+            });
+        }
+    }
+    const child = spawnDetachedConsole(options);
+    try {
+        return await waitForConsoleEndpoint(options);
+    }
+    catch (error) {
+        if (child.pid !== undefined) {
+            try {
+                process.kill(child.pid, "SIGTERM");
+            }
+            catch {
+                // The process already exited.
+            }
+        }
+        throw error;
     }
-    spawnDetachedConsole({ cwd: options.cwd, env: options.env });
-    return await waitForConsoleEndpoint(options.tuttiHome);
 }
-async function issueBrowserAccess(endpoint, currentDirectory) {
-    const response = await fetch(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+async function issueBrowserAccess(options) {
+    const context = createLocalConsoleInvocationContext({ cwd: options.cwd, env: options.env });
+    const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
         method: "POST",
         headers: {
-            authorization: `Bearer ${endpoint.control_token}`,
+            authorization: `Bearer ${options.endpoint.control_token}`,
             accept: "application/json",
             "content-type": "application/json",
         },
-        body: JSON.stringify({ current_directory: currentDirectory }),
+        body: JSON.stringify({
+            current_directory: context.currentDirectory,
+            environment: context.environment,
+        }),
         signal: AbortSignal.timeout(3_000),
     });
     if (!response.ok) {
-        throw new Error("Tutti Local Console could not create a browser access link.");
+        throw new Error("Tutti could not create a browser access link.");
     }
     const value = (await response.json());
     if (typeof value.access_token !== "string" || value.access_token.trim() === "") {
-        throw new Error("Tutti Local Console returned an invalid browser access link.");
+        throw new Error("Tutti returned an invalid browser access link.");
     }
-    return `${endpoint.base_url}/console#access_token=${encodeURIComponent(value.access_token)}`;
+    return `${options.endpoint.base_url}/console#access_token=${encodeURIComponent(value.access_token)}`;
 }
 export async function ensureLocalConsole(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const endpoint = await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => await ensureConsoleEndpointUnlocked({ cwd, env, tuttiHome, fetchImpl }),
+    });
+    return {
+        endpoint,
+        url: await issueBrowserAccess({ endpoint, cwd, env, fetchImpl }),
+    };
+}
+export async function readLocalConsoleServiceStatus(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const logPath = getLocalConsoleLogPath(tuttiHome);
+    const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+    if (endpoint === null) {
+        return { status: "stopped", log_path: logPath };
+    }
+    const health = await endpointHealth(endpoint, options.fetchImpl ?? fetch);
+    if (health.kind === "stale" || (endpoint.schema_version === 2 && !health.identityVerified)) {
+        return {
+            status: "stale",
+            pid: endpoint.pid,
+            base_url: endpoint.base_url,
+            started_at: endpoint.started_at,
+            log_path: logPath,
+        };
+    }
+    const currentVersion = readCliVersion();
+    return {
+        status: "running",
+        pid: endpoint.pid,
+        base_url: endpoint.base_url,
+        started_at: endpoint.started_at,
+        version: endpoint.schema_version === 2 ? endpoint.version : "unknown",
+        current_version: currentVersion,
+        update_required: !endpointMatchesCurrentRuntime(endpoint),
+        log_path: logPath,
+    };
+}
+export async function stopLocalConsoleService(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
     const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
-    const endpoint = await ensureConsoleEndpoint({ cwd, env, tuttiHome });
-    return { endpoint, url: await issueBrowserAccess(endpoint, cwd) };
+    return await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => {
+            const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+            if (endpoint === null) {
+                return "already_stopped";
+            }
+            await stopEndpoint({ endpoint, tuttiHome, cwd, fetchImpl });
+            return "stopped";
+        },
+    });
+}
+export async function restartLocalConsoleService(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    return await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => {
+            const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+            if (endpoint !== null) {
+                await stopEndpoint({ endpoint, tuttiHome, cwd, fetchImpl });
+            }
+            return await ensureConsoleEndpointUnlocked({ cwd, env, tuttiHome, fetchImpl });
+        },
+    });
 }
 //# sourceMappingURL=managed-console.js.map

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

@@ -1,14 +1,20 @@
-import type { ProjectId } from "@tutti/shared/ids";
+import { type ProjectId, type RelayProjectRef } from "@tutti/shared/ids";
 import { type RuntimeProjectRow } from "../cli/runtime-commands.js";
+import { type LocalConsoleInvocationContext } from "./invocation-context.js";
 export type LocalConsoleProject = {
     project_id: ProjectId;
     display_name: string;
     workspace_path: string;
     status: RuntimeProjectRow["status"];
     provider_status: "configured" | "not_configured" | "invalid";
-    relay_project_ref?: 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;
 };
 export type LocalConsoleProviderInput = {
     base_url: string;
@@ -17,6 +23,7 @@ export type LocalConsoleProviderInput = {
 };
 export type LocalConsoleLaunchResult = {
     project: LocalConsoleProject;
+    project_created: boolean;
     join_url: string;
     join_token_expires_at?: string;
 };
@@ -27,11 +34,11 @@ export declare class LocalConsoleProjectError extends Error {
 }
 export declare class LocalConsoleProjectService {
     #private;
-    constructor(options?: {
-        cwd?: string;
-        env?: NodeJS.ProcessEnv;
+    constructor(options: {
+        tuttiHome: string;
+        serviceEnvironment?: NodeJS.ProcessEnv;
     });
-    listProjects(): Promise<LocalConsoleProject[]>;
+    listProjects(context: LocalConsoleInvocationContext): Promise<LocalConsoleProject[]>;
     discoverModels(input: {
         baseUrl: string;
         apiKey: string;
@@ -45,12 +52,12 @@ export declare class LocalConsoleProjectService {
     launchProject(input: {
         workspacePath: string;
         provider?: LocalConsoleProviderInput;
-    }): Promise<LocalConsoleLaunchResult>;
-    refreshInvite(projectId: string): Promise<{
+    }, context: LocalConsoleInvocationContext): Promise<LocalConsoleLaunchResult>;
+    refreshInvite(projectId: string, context: LocalConsoleInvocationContext): Promise<{
         join_url: string;
         expires_at?: string;
     }>;
-    stopProject(projectId: string): Promise<{
+    stopProject(projectId: string, context: LocalConsoleInvocationContext): Promise<{
         message: string;
     }>;
 }