@xfey/tutti 0.1.33 → 0.1.34

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

@@ -1,12 +1,15 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
-import { configureProjectOpenAiProvider, discoverOpenAiModels, readOpenAiProviderConfigProjection, resolveTuttiHome, } from "../../providers/openai/index.js";
+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 { 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";
 export class LocalConsoleProjectError extends Error {
     code;
     statusCode;
@@ -44,7 +47,8 @@ function validateProvider(input) {
     }
     return provider;
 }
-function projectFromRuntimeRow(row, providerStatus) {
+function projectFromRuntimeRow(row, providerStatus, activityAt) {
+    const currentVersion = readCliVersion();
     return {
         project_id: row.project_id,
         display_name: row.display_name,
@@ -56,29 +60,69 @@ function projectFromRuntimeRow(row, providerStatus) {
         ...(row.relay_connection_status === undefined
             ? {}
             : { relay_connection_status: row.relay_connection_status }),
+        ...(activityAt === undefined ? {} : { activity_at: activityAt }),
+        ...(row.host_version === undefined ? {} : { host_version: row.host_version }),
+        ...(row.host_version === undefined || row.host_version === currentVersion
+            ? {}
+            : { update_required: true }),
     };
 }
+function readProjectActivityAt(tuttiHome, row) {
+    if (row.last_connected_at !== undefined) {
+        return row.last_connected_at;
+    }
+    try {
+        const endpoint = readMachineRuntimeEndpoint(tuttiHome, row.project_id);
+        if (endpoint !== null) {
+            return endpoint.updated_at;
+        }
+    }
+    catch {
+        // Invalid endpoint state is already represented by the project status.
+    }
+    try {
+        return readMachineProjectBinding(tuttiHome, row.project_id)?.updated_at;
+    }
+    catch {
+        return undefined;
+    }
+}
 export class LocalConsoleProjectService {
-    #cwd;
-    #env;
+    #tuttiHome;
+    #serviceEnvironment;
     #launches = new Map();
-    constructor(options = {}) {
-        this.#cwd = resolve(options.cwd ?? process.cwd());
-        this.#env = options.env ?? process.env;
+    #mutationTail = Promise.resolve();
+    constructor(options) {
+        this.#tuttiHome = resolve(options.tuttiHome);
+        this.#serviceEnvironment = options.serviceEnvironment ?? process.env;
+    }
+    #operationOptions(context) {
+        return {
+            cwd: context.currentDirectory,
+            env: createLocalConsoleOperationEnvironment({
+                serviceEnvironment: this.#serviceEnvironment,
+                invocationEnvironment: context.environment,
+                tuttiHome: this.#tuttiHome,
+            }),
+        };
     }
-    async listProjects() {
-        const tuttiHome = resolveTuttiHome(this.#env.TUTTI_HOME, this.#cwd);
+    #runMutation(operation) {
+        const result = this.#mutationTail.then(operation, operation);
+        this.#mutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async listProjects(context) {
+        const operation = this.#operationOptions(context);
         const rows = await listRuntimeProjects({
             all: true,
-            cwd: this.#cwd,
-            env: this.#env,
+            ...operation,
         });
         return rows.map((row) => {
             const provider = readOpenAiProviderConfigProjection({
-                tuttiHome,
+                tuttiHome: this.#tuttiHome,
                 projectId: row.project_id,
             });
-            return projectFromRuntimeRow(row, provider.status);
+            return projectFromRuntimeRow(row, provider.status, readProjectActivityAt(this.#tuttiHome, row));
         });
     }
     async discoverModels(input) {
@@ -92,29 +136,29 @@ export class LocalConsoleProjectService {
             apiKey: provider.api_key,
         });
     }
-    async launchProject(input) {
+    async launchProject(input, context) {
         const workspacePath = validateWorkspacePath(input.workspacePath);
         const active = this.#launches.get(workspacePath);
         if (active !== undefined) {
             return await active;
         }
-        const launch = this.#launchProject({
+        const launch = this.#runMutation(async () => await this.#launchProject({
             workspacePath,
             ...(input.provider === undefined ? {} : { provider: validateProvider(input.provider) }),
-        }).finally(() => {
+        }, context)).finally(() => {
             this.#launches.delete(workspacePath);
         });
         this.#launches.set(workspacePath, launch);
         return await launch;
     }
-    async #launchProject(input) {
+    async #launchProject(input, context) {
+        const operation = this.#operationOptions(context);
         let preparation;
         try {
             preparation = await prepareLaunchProject({
                 workspacePath: input.workspacePath,
                 yes: true,
-                cwd: this.#cwd,
-                env: this.#env,
+                ...operation,
             });
         }
         catch (error) {
@@ -138,7 +182,8 @@ export class LocalConsoleProjectService {
         try {
             spawnDetachedHost({
                 workspaceRoot: preparation.workspace_root,
-                env: this.#env,
+                env: operation.env,
+                inheritProcessEnv: false,
             });
             const ready = await waitForManagedHostReady({
                 tuttiHome: preparation.tutti_home,
@@ -148,7 +193,7 @@ export class LocalConsoleProjectService {
             if (ready.join_url === undefined) {
                 throw new LocalConsoleProjectError("relay_registration_failed", "The host started, but Relay did not return a visible join link.");
             }
-            const projects = await this.listProjects();
+            const projects = await this.listProjects(context);
             const project = projects.find((item) => item.project_id === preparation.project_id);
             if (project === undefined) {
                 throw new LocalConsoleProjectError("project_not_found", "The launched project could not be read from the machine project list.");
@@ -165,44 +210,44 @@ export class LocalConsoleProjectService {
             throw this.#normalizeError(error);
         }
     }
-    async refreshInvite(projectId) {
-        const project = resolveManagedProjectContext({
-            target: projectId,
-            cwd: this.#cwd,
-            env: this.#env,
-        });
-        if (project.runtime_endpoint === null) {
-            throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
-        }
-        try {
-            const status = await rotateHostLocalInvite({ endpoint: project.runtime_endpoint });
-            const joinUrl = status.relay?.join_url;
-            if (joinUrl === undefined) {
-                throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");
+    async refreshInvite(projectId, context) {
+        return await this.#runMutation(async () => {
+            const project = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            });
+            if (project.runtime_endpoint === null) {
+                throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
             }
-            return {
-                join_url: joinUrl,
-                ...(status.relay?.join_token_expires_at === undefined
-                    ? {}
-                    : { expires_at: status.relay.join_token_expires_at }),
-            };
-        }
-        catch (error) {
-            throw this.#normalizeError(error);
-        }
+            try {
+                const status = await rotateHostLocalInvite({ endpoint: project.runtime_endpoint });
+                const joinUrl = status.relay?.join_url;
+                if (joinUrl === undefined) {
+                    throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");
+                }
+                return {
+                    join_url: joinUrl,
+                    ...(status.relay?.join_token_expires_at === undefined
+                        ? {}
+                        : { expires_at: status.relay.join_token_expires_at }),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
     }
-    async stopProject(projectId) {
-        try {
-            return {
-                message: await runStopCommand(projectId, {
-                    cwd: this.#cwd,
-                    env: this.#env,
-                }),
-            };
-        }
-        catch (error) {
-            throw this.#normalizeError(error);
-        }
+    async stopProject(projectId, context) {
+        return await this.#runMutation(async () => {
+            try {
+                return {
+                    message: await runStopCommand(projectId, this.#operationOptions(context)),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
     }
     #normalizeError(error) {
         if (error instanceof LocalConsoleProjectError) {

package/dist/server-shell/local-console/runtime-endpoint.d.ts

@@ -1,17 +1,31 @@
 export type LocalConsoleRuntimeEndpoint = {
+    schema_version: 2;
+    instance_id: string;
+    pid: number;
+    base_url: string;
+    control_token: string;
+    version: string;
+    entrypoint: string;
+    started_at: string;
+};
+export type LegacyLocalConsoleRuntimeEndpoint = {
     schema_version: 1;
     pid: number;
     base_url: string;
     control_token: string;
     started_at: string;
 };
+export type ReadableLocalConsoleRuntimeEndpoint = LocalConsoleRuntimeEndpoint | LegacyLocalConsoleRuntimeEndpoint;
 export declare function createLocalConsoleSecret(): string;
-export declare function readLocalConsoleRuntimeEndpoint(tuttiHome: string): LocalConsoleRuntimeEndpoint | null;
+export declare function readLocalConsoleRuntimeEndpoint(tuttiHome: string): ReadableLocalConsoleRuntimeEndpoint | null;
 export declare function writeLocalConsoleRuntimeEndpoint(options: {
     tuttiHome: string;
+    instanceId: string;
     pid: number;
     baseUrl: string;
     controlToken: string;
+    version: string;
+    entrypoint: string;
     now?: () => Date;
 }): LocalConsoleRuntimeEndpoint;
 export declare function deleteLocalConsoleRuntimeEndpoint(options: {

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

@@ -7,10 +7,8 @@ function endpointPath(tuttiHome) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isEndpoint(value) {
-    return (isRecord(value) &&
-        value.schema_version === 1 &&
-        typeof value.pid === "number" &&
+function hasSharedEndpointFields(value) {
+    return (typeof value.pid === "number" &&
         Number.isInteger(value.pid) &&
         typeof value.base_url === "string" &&
         /^http:\/\/127\.0\.0\.1:\d+$/u.test(value.base_url) &&
@@ -18,6 +16,21 @@ function isEndpoint(value) {
         value.control_token.length >= 32 &&
         typeof value.started_at === "string");
 }
+function isEndpoint(value) {
+    if (!isRecord(value) || !hasSharedEndpointFields(value)) {
+        return false;
+    }
+    if (value.schema_version === 1) {
+        return true;
+    }
+    return (value.schema_version === 2 &&
+        typeof value.instance_id === "string" &&
+        value.instance_id.length >= 16 &&
+        typeof value.version === "string" &&
+        value.version.trim() !== "" &&
+        typeof value.entrypoint === "string" &&
+        value.entrypoint.trim() !== "");
+}
 export function createLocalConsoleSecret() {
     return randomBytes(32).toString("base64url");
 }
@@ -36,10 +49,13 @@ export function readLocalConsoleRuntimeEndpoint(tuttiHome) {
 }
 export function writeLocalConsoleRuntimeEndpoint(options) {
     const record = {
-        schema_version: 1,
+        schema_version: 2,
+        instance_id: options.instanceId,
         pid: options.pid,
         base_url: options.baseUrl,
         control_token: options.controlToken,
+        version: options.version,
+        entrypoint: options.entrypoint,
         started_at: (options.now ?? (() => new Date()))().toISOString(),
     };
     if (!isEndpoint(record)) {

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

@@ -1,17 +1,29 @@
 import { type FastifyInstance } from "fastify";
 export declare const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
+type LocalConsoleRuntimeMetadata = {
+    instanceId: string;
+    version: string;
+    entrypoint: string;
+    startedAt: string;
+    pid: number;
+};
 type LocalConsoleServerOptions = {
     controlToken: string;
     cwd: string;
+    tuttiHome?: string;
     env?: NodeJS.ProcessEnv;
     now?: () => Date;
     webStaticRoot?: string | false;
+    runtime?: LocalConsoleRuntimeMetadata;
+    onActivity?: () => void;
+    onShutdown?: () => void;
 };
 export declare function createLocalConsoleServer(options: LocalConsoleServerOptions): FastifyInstance;
 export declare function runLocalConsoleProcess(options?: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     now?: () => Date;
+    idleTimeoutMs?: number;
 }): Promise<void>;
 export {};
 //# sourceMappingURL=server.d.ts.map

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

@@ -1,9 +1,12 @@
 import { timingSafeEqual } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import fastify from "fastify";
 import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliVersion } from "../cli/version.js";
 import { registerHostWebStaticRoutes, resolvePackagedWebStaticRoot } from "../http/static-web.js";
-import { createLocalProjectFolder, detectLocalFolderPicker, pickLocalFolder, } from "./folder-picker.js";
+import { detectLocalFolderPicker, pickLocalFolder } from "./folder-picker.js";
+import { LOCAL_CONSOLE_INVOCATION_ENV_KEYS, createLocalConsoleServiceEnvironment, } from "./invocation-context.js";
 import { LocalConsoleProjectError, LocalConsoleProjectService, } from "./project-service.js";
 import { LOCAL_CONSOLE_SESSION_COOKIE, LocalConsoleSessionRegistry, localConsoleSessionCookie, parseCookieHeader, } from "./session.js";
 import { createLocalConsoleSecret, deleteLocalConsoleRuntimeEndpoint, writeLocalConsoleRuntimeEndpoint, } from "./runtime-endpoint.js";
@@ -59,12 +62,13 @@ function requireLoopbackHost(request) {
 }
 export function createLocalConsoleServer(options) {
     const app = fastify({ logger: false, bodyLimit: 64 * 1024 });
+    const tuttiHome = options.tuttiHome ?? resolveTuttiHome(options.env?.TUTTI_HOME, options.cwd);
     const sessions = new LocalConsoleSessionRegistry({
         ...(options.now === undefined ? {} : { now: options.now }),
     });
     const projects = new LocalConsoleProjectService({
-        cwd: options.cwd,
-        ...(options.env === undefined ? {} : { env: options.env }),
+        tuttiHome,
+        ...(options.env === undefined ? {} : { serviceEnvironment: options.env }),
     });
     app.addHook("onRequest", (request, reply, done) => {
         try {
@@ -101,10 +105,11 @@ export function createLocalConsoleServer(options) {
         if (!tokenEquals(bearerToken(request.headers.authorization), options.controlToken)) {
             throw new LocalConsoleHttpError(401, "unauthorized", "Local Console control token is invalid.");
         }
+        options.onActivity?.();
     }
     function requireSession(request, csrf = false) {
         const cookie = parseCookieHeader(headerValue(request.headers.cookie));
-        const session = sessions.readSession(cookie[LOCAL_CONSOLE_SESSION_COOKIE]);
+        const session = sessions.readSession(cookie[LOCAL_CONSOLE_SESSION_COOKIE], headerValue(request.headers["x-local-console-context"]));
         if (session === null) {
             throw new LocalConsoleHttpError(401, "session_required", "Open Tutti from the CLI again.");
         }
@@ -115,22 +120,65 @@ export function createLocalConsoleServer(options) {
                 throw new LocalConsoleHttpError(403, "csrf_rejected", "Local Console request was rejected.");
             }
         }
+        options.onActivity?.();
         return session;
     }
-    app.get(`${LOCAL_CONSOLE_API_BASE}/health`, () => ({ status: "ready" }));
+    app.get(`${LOCAL_CONSOLE_API_BASE}/health`, () => ({
+        status: "ready",
+        protocol_version: 2,
+        ...(options.runtime === undefined
+            ? {}
+            : {
+                instance_id: options.runtime.instanceId,
+                version: options.runtime.version,
+                pid: options.runtime.pid,
+            }),
+    }));
+    app.get(`${LOCAL_CONSOLE_API_BASE}/control/status`, (request) => {
+        requireControl(request);
+        return {
+            status: "running",
+            protocol_version: 2,
+            ...(options.runtime === undefined
+                ? {}
+                : {
+                    instance_id: options.runtime.instanceId,
+                    version: options.runtime.version,
+                    entrypoint: options.runtime.entrypoint,
+                    started_at: options.runtime.startedAt,
+                    pid: options.runtime.pid,
+                }),
+        };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/control/shutdown`, (request) => {
+        requireControl(request);
+        setImmediate(() => options.onShutdown?.());
+        return { status: "stopping" };
+    });
     app.post(`${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
         schema: {
             body: {
                 type: "object",
                 required: ["current_directory"],
                 additionalProperties: false,
-                properties: { current_directory: { type: "string", minLength: 1, maxLength: 4096 } },
+                properties: {
+                    current_directory: { type: "string", minLength: 1, maxLength: 4096 },
+                    environment: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: Object.fromEntries(LOCAL_CONSOLE_INVOCATION_ENV_KEYS.map((key) => [
+                            key,
+                            { type: "string", minLength: 1, maxLength: 4096 },
+                        ])),
+                    },
+                },
             },
         },
     }, (request) => {
         requireControl(request);
         const access = sessions.issueAccessToken({
             currentDirectory: resolve(request.body.current_directory),
+            environment: request.body.environment ?? {},
         });
         return { access_token: access.token, expires_at: access.expires_at };
     });
@@ -145,51 +193,41 @@ export function createLocalConsoleServer(options) {
         },
     }, (request, reply) => {
         requireSameOrigin(request);
-        const session = sessions.exchangeAccessToken(request.body.access_token);
+        const cookie = parseCookieHeader(headerValue(request.headers.cookie));
+        const session = sessions.exchangeAccessToken(request.body.access_token, cookie[LOCAL_CONSOLE_SESSION_COOKIE]);
         if (session === null) {
             throw new LocalConsoleHttpError(401, "access_token_invalid", "This Local Console access link has expired. Run `tutti` again.");
         }
-        void reply.header("set-cookie", localConsoleSessionCookie(session.sessionToken, session.expires_at));
-        return { csrf_token: session.csrfToken, expires_at: session.expires_at };
+        if (session.sessionToken !== undefined) {
+            void reply.header("set-cookie", localConsoleSessionCookie(session.sessionToken, session.expires_at));
+        }
+        options.onActivity?.();
+        return {
+            csrf_token: session.csrfToken,
+            context_token: session.contextToken,
+            expires_at: session.expires_at,
+        };
     });
     app.get(`${LOCAL_CONSOLE_API_BASE}/bootstrap`, (request) => {
         const session = requireSession(request);
-        const picker = detectLocalFolderPicker(process.platform, options.env ?? process.env);
         return {
             csrf_token: session.csrfToken,
-            current_directory: session.currentDirectory,
+            current_directory: session.context.currentDirectory,
             platform: process.platform,
-            folder_picker: picker.kind,
+            folder_picker: detectLocalFolderPicker(process.platform, session.context.environment).kind,
         };
     });
     app.get(`${LOCAL_CONSOLE_API_BASE}/projects`, async (request) => {
+        const session = requireSession(request);
+        return { projects: await projects.listProjects(session.context) };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/heartbeat`, (request) => {
         requireSession(request);
-        return { projects: await projects.listProjects() };
+        return { status: "ok" };
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/folders/pick`, async (request) => {
-        requireSession(request, true);
-        return await pickLocalFolder({ env: options.env ?? process.env });
-    });
-    app.post(`${LOCAL_CONSOLE_API_BASE}/folders/create`, {
-        schema: {
-            body: {
-                type: "object",
-                required: ["parent_path", "name"],
-                additionalProperties: false,
-                properties: {
-                    parent_path: { type: "string", minLength: 1 },
-                    name: { type: "string", minLength: 1, maxLength: 160 },
-                },
-            },
-        },
-    }, (request) => {
-        requireSession(request, true);
-        try {
-            return { path: createLocalProjectFolder(request.body.parent_path, request.body.name) };
-        }
-        catch (error) {
-            throw new LocalConsoleHttpError(422, "project_folder_create_failed", error instanceof Error ? error.message : "Project folder could not be created.");
-        }
+        const session = requireSession(request, true);
+        return await pickLocalFolder({ env: session.context.environment });
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/providers/models`, {
         schema: {
@@ -232,19 +270,19 @@ export function createLocalConsoleServer(options) {
             },
         },
     }, async (request) => {
-        requireSession(request, true);
+        const session = requireSession(request, true);
         return await projects.launchProject({
             workspacePath: request.body.workspace_path,
             ...(request.body.provider === undefined ? {} : { provider: request.body.provider }),
-        });
+        }, session.context);
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/invite`, async (request) => {
-        requireSession(request, true);
-        return await projects.refreshInvite(request.params.projectId);
+        const session = requireSession(request, true);
+        return await projects.refreshInvite(request.params.projectId, session.context);
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/stop`, async (request) => {
-        requireSession(request, true);
-        return await projects.stopProject(request.params.projectId);
+        const session = requireSession(request, true);
+        return await projects.stopProject(request.params.projectId, session.context);
     });
     const webStaticRoot = options.webStaticRoot === false
         ? undefined
@@ -261,24 +299,64 @@ function listeningPort(app) {
     }
     return address.port;
 }
+function entrypointIdentity(path) {
+    try {
+        const stats = statSync(path);
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+    }
+    catch {
+        return null;
+    }
+}
 export async function runLocalConsoleProcess(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const env = options.env ?? process.env;
     const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const serviceEnvironment = createLocalConsoleServiceEnvironment({ env, tuttiHome });
     const controlToken = createLocalConsoleSecret();
+    const instanceId = createLocalConsoleSecret();
+    const now = options.now ?? (() => new Date());
+    const startedAt = now().toISOString();
+    const version = readCliVersion();
+    const entrypointArgument = process.argv[1];
+    if (entrypointArgument === undefined || entrypointArgument.trim() === "") {
+        throw new Error("Cannot locate the Tutti CLI entrypoint.");
+    }
+    const entrypoint = resolve(entrypointArgument);
+    const initialEntrypointIdentity = entrypointIdentity(entrypoint);
+    if (initialEntrypointIdentity === null) {
+        throw new Error("The Tutti CLI entrypoint is unavailable.");
+    }
+    let lastActivityAt = now().getTime();
+    let requestClose = () => undefined;
     const app = createLocalConsoleServer({
         controlToken,
         cwd,
-        env,
+        tuttiHome,
+        env: serviceEnvironment,
+        runtime: {
+            instanceId,
+            version,
+            entrypoint,
+            startedAt,
+            pid: process.pid,
+        },
+        onActivity: () => {
+            lastActivityAt = now().getTime();
+        },
+        onShutdown: () => requestClose(),
         ...(options.now === undefined ? {} : { now: options.now }),
     });
     await app.listen({ host: "127.0.0.1", port: 0 });
     writeLocalConsoleRuntimeEndpoint({
         tuttiHome,
+        instanceId,
         pid: process.pid,
         baseUrl: `http://127.0.0.1:${listeningPort(app)}`,
         controlToken,
-        ...(options.now === undefined ? {} : { now: options.now }),
+        version,
+        entrypoint,
+        now,
     });
     let closing = false;
     const close = async () => {
@@ -290,12 +368,41 @@ export async function runLocalConsoleProcess(options = {}) {
             tuttiHome,
             expectedControlToken: controlToken,
         });
-        await app.close();
+        const forceClose = setTimeout(() => app.server.closeAllConnections(), 5_000);
+        forceClose.unref();
+        try {
+            await app.close();
+        }
+        finally {
+            clearTimeout(forceClose);
+        }
     };
+    requestClose = () => void close();
+    const idleTimeoutMs = options.idleTimeoutMs ?? 60 * 60 * 1_000;
+    const idleCheck = setInterval(() => {
+        let installedVersion = null;
+        try {
+            installedVersion = readCliVersion();
+        }
+        catch {
+            // Package removal is handled as a runtime identity change.
+        }
+        if (!existsSync(entrypoint) ||
+            entrypointIdentity(entrypoint) !== initialEntrypointIdentity ||
+            installedVersion !== version) {
+            void close();
+            return;
+        }
+        if (now().getTime() - lastActivityAt >= idleTimeoutMs) {
+            void close();
+        }
+    }, Math.min(60_000, Math.max(1_000, Math.floor(idleTimeoutMs / 4))));
+    idleCheck.unref();
     process.once("SIGINT", () => void close());
     process.once("SIGTERM", () => void close());
     await new Promise((resolveClosed) => {
         app.server.once("close", resolveClosed);
     });
+    clearInterval(idleCheck);
 }
 //# sourceMappingURL=server.js.map