@xfey/tutti 0.1.60 → 0.1.62

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

@@ -0,0 +1,297 @@
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { readCliPackageIdentity } from "../cli/version.js";
+import { buildGlobalInstallPlan, createPackageCommandPlan, PUBLISHED_TUTTI_PACKAGE_NAME, runPackageCommand, compareExactSemver, parseExactSemver, } from "../package-installation/index.js";
+import { releasePackageUpdateLockForCurrentProcess } from "./package-update-lock.js";
+import { PackageUpdateLogger } from "./package-update-log.js";
+import { updatePackageUpdateRuntimeRecord, writePackageUpdateRuntimeRecord, } from "./package-update-record.js";
+import { restorePackageUpdateHosts, stopPackageUpdateHost, } from "./package-update-hosts.js";
+const WORKER_INPUT_KEYS = [
+    "cli_entrypoint",
+    "completion_environment",
+    "installation",
+    "restore_project_ids",
+    "schema_version",
+    "target",
+    "tutti_home",
+];
+const INSTALLATION_KEYS = [
+    "currentVersion",
+    "globalRoot",
+    "nodeExecutable",
+    "npmEnvironment",
+    "npmExecutable",
+    "packageName",
+    "packageRoot",
+];
+const NPM_ENV_KEYS = new Set([
+    "HOME",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOGNAME",
+    "NO_PROXY",
+    "NPM_CONFIG_UPDATE_NOTIFIER",
+    "PATH",
+    "TMPDIR",
+    "USER",
+]);
+const COMPLETION_ENV_KEYS = new Set([
+    "HOME",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LOGNAME",
+    "NO_PROXY",
+    "PATH",
+    "TMPDIR",
+    "TUTTI_HOME",
+    "USER",
+]);
+function strictObject(value, keys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    return Object.keys(record).every((key) => keys.includes(key)) ? record : null;
+}
+function strictEnvironment(value, allowedKeys) {
+    const record = strictObject(value, [...allowedKeys]);
+    if (record === null ||
+        Object.entries(record).some(([key, nested]) => !allowedKeys.has(key) || typeof nested !== "string" || nested === "")) {
+        return null;
+    }
+    return record;
+}
+export function parsePackageUpdateWorkerInput(value, options = {}) {
+    const input = strictObject(value, WORKER_INPUT_KEYS);
+    const installation = strictObject(input?.installation, INSTALLATION_KEYS);
+    const target = strictObject(input?.target, ["packageName", "version"]);
+    const sourceVersion = parseExactSemver(installation?.currentVersion);
+    const targetVersion = parseExactSemver(target?.version);
+    const npmEnvironment = strictEnvironment(installation?.npmEnvironment, NPM_ENV_KEYS);
+    const completionEnvironment = strictEnvironment(input?.completion_environment, COMPLETION_ENV_KEYS);
+    const tuttiHome = input?.tutti_home;
+    const packageRoot = installation?.packageRoot;
+    const globalRoot = installation?.globalRoot;
+    if (input?.schema_version !== 1 ||
+        typeof tuttiHome !== "string" ||
+        !isAbsolute(tuttiHome) ||
+        resolve(tuttiHome) !== resolve(options.defaultTuttiHome ?? join(homedir(), ".tutti")) ||
+        typeof input.cli_entrypoint !== "string" ||
+        !isAbsolute(input.cli_entrypoint) ||
+        installation?.packageName !== PUBLISHED_TUTTI_PACKAGE_NAME ||
+        sourceVersion === null ||
+        target?.packageName !== PUBLISHED_TUTTI_PACKAGE_NAME ||
+        targetVersion === null ||
+        compareExactSemver(targetVersion, sourceVersion) <= 0 ||
+        typeof packageRoot !== "string" ||
+        !isAbsolute(packageRoot) ||
+        typeof globalRoot !== "string" ||
+        !isAbsolute(globalRoot) ||
+        typeof installation.npmExecutable !== "string" ||
+        !isAbsolute(installation.npmExecutable) ||
+        typeof installation.nodeExecutable !== "string" ||
+        !isAbsolute(installation.nodeExecutable) ||
+        npmEnvironment === null ||
+        typeof npmEnvironment.PATH !== "string" ||
+        completionEnvironment === null ||
+        completionEnvironment.TUTTI_HOME !== tuttiHome ||
+        typeof completionEnvironment.PATH !== "string" ||
+        !Array.isArray(input.restore_project_ids) ||
+        !input.restore_project_ids.every((projectId) => typeof projectId === "string" && isPrefixedId(projectId, ID_PREFIXES.project)) ||
+        new Set(input.restore_project_ids).size !== input.restore_project_ids.length) {
+        return null;
+    }
+    try {
+        if (realpathSync(join(globalRoot, ...PUBLISHED_TUTTI_PACKAGE_NAME.split("/"))) !==
+            realpathSync(packageRoot)) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return {
+        schema_version: 1,
+        tutti_home: resolve(tuttiHome),
+        cli_entrypoint: resolve(input.cli_entrypoint),
+        installation: {
+            packageName: PUBLISHED_TUTTI_PACKAGE_NAME,
+            currentVersion: sourceVersion,
+            packageRoot: resolve(packageRoot),
+            globalRoot: resolve(globalRoot),
+            npmExecutable: resolve(installation.npmExecutable),
+            nodeExecutable: resolve(installation.nodeExecutable),
+            npmEnvironment,
+        },
+        target: { packageName: PUBLISHED_TUTTI_PACKAGE_NAME, version: targetVersion },
+        restore_project_ids: [...input.restore_project_ids].sort(),
+        completion_environment: completionEnvironment,
+    };
+}
+export function createPackageUpdateWorkerInput(options) {
+    if (!isAbsolute(options.tuttiHome) || !isAbsolute(options.cliEntrypoint)) {
+        throw new Error("Package update worker paths must be absolute.");
+    }
+    return {
+        schema_version: 1,
+        tutti_home: resolve(options.tuttiHome),
+        cli_entrypoint: resolve(options.cliEntrypoint),
+        installation: options.installation,
+        target: options.target,
+        restore_project_ids: [...new Set(options.restoreProjectIds)].sort(),
+        completion_environment: { ...options.completionEnvironment },
+    };
+}
+export async function verifyPackageUpdatePostInstall(input, runner = runPackageCommand, readIdentity = readCliPackageIdentity) {
+    try {
+        const identity = readIdentity();
+        if (identity.name !== PUBLISHED_TUTTI_PACKAGE_NAME ||
+            identity.version !== input.target.version ||
+            realpathSync(identity.root) !== realpathSync(input.installation.packageRoot) ||
+            !existsSync(input.cli_entrypoint)) {
+            return false;
+        }
+        const result = await runner(createPackageCommandPlan({
+            executable: input.installation.nodeExecutable,
+            args: [input.cli_entrypoint, "--version"],
+            env: input.completion_environment,
+        }));
+        return result.status === 0 && result.stdout.trim() === input.target.version;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runPackageUpdateWorker(input, dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const logger = dependencies.logger ??
+        new PackageUpdateLogger({
+            tuttiHome: input.tutti_home,
+            privatePaths: [
+                input.installation.packageRoot,
+                input.installation.globalRoot,
+                input.tutti_home,
+            ],
+            now,
+        });
+    const writeRecord = dependencies.writeRecord ??
+        ((record) => writePackageUpdateRuntimeRecord(input.tutti_home, record));
+    const updateRecord = dependencies.updateRecord ??
+        ((record, options) => updatePackageUpdateRuntimeRecord({
+            tuttiHome: input.tutti_home,
+            current: record,
+            phase: options.phase,
+            now,
+            ...(options.failureReasonCode === undefined
+                ? {}
+                : { failureReasonCode: options.failureReasonCode }),
+            ...(options.restartFailureCount === undefined
+                ? {}
+                : { restartFailureCount: options.restartFailureCount }),
+        }));
+    const releaseLock = dependencies.releaseLock ?? (() => releasePackageUpdateLockForCurrentProcess(input.tutti_home));
+    const restoreHosts = dependencies.restoreHosts ??
+        ((projectIds) => restorePackageUpdateHosts({
+            tuttiHome: input.tutti_home,
+            projectIds,
+            env: input.completion_environment,
+        }));
+    const stopHost = dependencies.stopHost ??
+        ((projectId) => stopPackageUpdateHost({ tuttiHome: input.tutti_home, projectId }));
+    const startedAt = now().toISOString();
+    let record = {
+        schema_version: 1,
+        source_version: input.installation.currentVersion,
+        target_version: input.target.version,
+        phase: "preparing",
+        restore_project_ids: [...input.restore_project_ids],
+        updater_pid: process.pid,
+        started_at: startedAt,
+        updated_at: startedAt,
+    };
+    writeRecord(record);
+    const log = (entry) => {
+        try {
+            logger.append(entry);
+        }
+        catch {
+            // Update correctness must not depend on the diagnostic log remaining writable.
+        }
+    };
+    log({ level: "info", message: "Package update worker accepted.", phase: record.phase });
+    const fail = async (reasonCode, stoppedProjectIds) => {
+        let restartFailureCount = stoppedProjectIds.length;
+        try {
+            const restored = await restoreHosts(stoppedProjectIds);
+            restartFailureCount = restored.failed_project_ids.length;
+        }
+        catch {
+            // Every Host in the stopped set remains conservatively classified as not restored.
+        }
+        try {
+            record = updateRecord(record, {
+                phase: "failed",
+                failureReasonCode: reasonCode,
+                restartFailureCount,
+            });
+        }
+        catch {
+            // A prior valid phase record is left for startup recovery to classify.
+        }
+        log({
+            level: "error",
+            message: "Package update stopped before completion.",
+            phase: record.phase,
+            reasonCode,
+        });
+        releaseLock();
+        return {
+            status: "failed",
+            reason_code: reasonCode,
+            restart_failure_count: restartFailureCount,
+        };
+    };
+    const stoppedProjectIds = [];
+    try {
+        record = updateRecord(record, { phase: "stopping_hosts" });
+        for (const projectId of input.restore_project_ids) {
+            const result = await stopHost(projectId);
+            if (result !== "stopped") {
+                return await fail(result, stoppedProjectIds);
+            }
+            stoppedProjectIds.push(projectId);
+        }
+        record = updateRecord(record, { phase: "installing" });
+        const install = await (dependencies.commandRunner ?? runPackageCommand)(buildGlobalInstallPlan({ installation: input.installation, target: input.target }));
+        log({
+            level: install.status === 0 ? "info" : "error",
+            message: install.status === 0 ? "npm install completed." : "npm install failed.",
+            phase: record.phase,
+            ...(install.stdout === "" ? {} : { stdout: install.stdout }),
+            ...(install.stderr === "" ? {} : { stderr: install.stderr }),
+        });
+        if (install.status !== 0) {
+            return await fail("npm_install_failed", stoppedProjectIds);
+        }
+        const verified = await (dependencies.verifyPostInstall ?? verifyPackageUpdatePostInstall)(input);
+        if (!verified) {
+            return await fail("post_install_validation_failed", stoppedProjectIds);
+        }
+        record = updateRecord(record, { phase: "restarting" });
+        await dependencies.startCompletion(input, record);
+        log({
+            level: "info",
+            message: "Package update handed off to the installed CLI.",
+            phase: record.phase,
+        });
+        return { status: "handed_off" };
+    }
+    catch {
+        return await fail(record.phase === "restarting" ? "completion_start_failed" : "worker_crashed", stoppedProjectIds);
+    }
+}
+//# sourceMappingURL=package-update-worker.js.map

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

@@ -3,6 +3,7 @@ import { type ConfigureProjectOpenAiProviderResult, type OpenAiProviderCredentia
 import { type FetchLike } from "../cli/host-runtime-endpoint.js";
 import { type RuntimeProjectRow } from "../cli/runtime-commands.js";
 import { type LocalConsoleInvocationContext } from "./invocation-context.js";
+import { LocalConsoleOperationCoordinator } from "./operation-coordinator.js";
 export type LocalConsoleProject = {
     project_id: ProjectId;
     display_name: string;
@@ -55,6 +56,7 @@ export declare class LocalConsoleProjectService {
         serviceEnvironment?: NodeJS.ProcessEnv;
         fetchImpl?: FetchLike;
         validateProviderCredential?: OpenAiProviderCredentialValidator;
+        operations?: LocalConsoleOperationCoordinator;
     });
     listProjects(context: LocalConsoleInvocationContext): Promise<LocalConsoleProject[]>;
     discoverModels(input: {

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

@@ -12,6 +12,7 @@ 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";
+import { LocalConsoleOperationConflictError, LocalConsoleOperationCoordinator, } from "./operation-coordinator.js";
 const OPEN_UPDATE_SHUTDOWN_WAIT_MS = 5_000;
 export class LocalConsoleProjectError extends Error {
     code;
@@ -153,12 +154,13 @@ export class LocalConsoleProjectService {
     #serviceEnvironment;
     #fetchImpl;
     #validateProviderCredential;
+    #operations;
     #launches = new Map();
-    #mutationTail = Promise.resolve();
     constructor(options) {
         this.#tuttiHome = resolve(options.tuttiHome);
         this.#serviceEnvironment = options.serviceEnvironment ?? process.env;
         this.#fetchImpl = options.fetchImpl ?? fetch;
+        this.#operations = options.operations ?? new LocalConsoleOperationCoordinator();
         this.#validateProviderCredential =
             options.validateProviderCredential ?? validateOpenAiCredential;
     }
@@ -172,11 +174,6 @@ export class LocalConsoleProjectService {
             }),
         };
     }
-    #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({
@@ -293,13 +290,17 @@ export class LocalConsoleProjectService {
         if (active !== undefined) {
             return await active;
         }
-        const launch = this.#runMutation(async () => await this.#launchProject({
+        const launch = this.#operations
+            .runProjectOperation(async () => await this.#launchProject({
             workspacePath,
             ...(input.project === undefined
                 ? {}
                 : { project: validateProjectMetadata(input.project) }),
-            ...(input.provider === undefined ? {} : { provider: validateProvider(input.provider) }),
-        }, context)).finally(() => {
+            ...(input.provider === undefined
+                ? {}
+                : { provider: validateProvider(input.provider) }),
+        }, context))
+            .finally(() => {
             this.#launches.delete(workspacePath);
         });
         this.#launches.set(workspacePath, launch);
@@ -380,7 +381,7 @@ export class LocalConsoleProjectService {
         }
     }
     async openProject(projectId, context) {
-        return await this.#runMutation(async () => {
+        return await this.#operations.runProjectOperation(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.");
@@ -461,7 +462,7 @@ export class LocalConsoleProjectService {
         });
     }
     async refreshInvite(projectId, context) {
-        return await this.#runMutation(async () => {
+        return await this.#operations.runProjectOperation(async () => {
             const project = resolveManagedProjectContext({
                 target: projectId,
                 ...this.#operationOptions(context),
@@ -491,7 +492,7 @@ export class LocalConsoleProjectService {
         });
     }
     async stopProject(projectId, context) {
-        return await this.#runMutation(async () => {
+        return await this.#operations.runProjectOperation(async () => {
             try {
                 return {
                     message: await runStopCommand(projectId, this.#operationOptions(context)),
@@ -506,6 +507,9 @@ export class LocalConsoleProjectService {
         if (error instanceof LocalConsoleProjectError) {
             return error;
         }
+        if (error instanceof LocalConsoleOperationConflictError) {
+            return new LocalConsoleProjectError(error.code, error.message, error.statusCode);
+        }
         if (error instanceof LaunchError) {
             return new LocalConsoleProjectError(error.code, error.message);
         }

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

@@ -1,4 +1,7 @@
 import { type FastifyInstance } from "fastify";
+import { type PackageUpdateCompletionResult } from "./package-update-record.js";
+import { LocalConsolePackageUpdateService, type LocalConsolePackageUpdatePreparation } from "./package-update-service.js";
+import { LocalConsoleOperationCoordinator } from "./operation-coordinator.js";
 export declare const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
 type LocalConsoleRuntimeMetadata = {
     instanceId: string;
@@ -17,6 +20,12 @@ type LocalConsoleServerOptions = {
     runtime?: LocalConsoleRuntimeMetadata;
     onActivity?: () => void;
     onShutdown?: () => void;
+    operationCoordinator?: LocalConsoleOperationCoordinator;
+    packageUpdateService?: Pick<LocalConsolePackageUpdateService, "getStatus" | "beginUpdate">;
+    startPackageUpdate?: (preparation: LocalConsolePackageUpdatePreparation) => Promise<{
+        pid: number;
+    }>;
+    getPackageUpdateCompletion?: () => PackageUpdateCompletionResult | undefined;
 };
 export declare function createLocalConsoleServer(options: LocalConsoleServerOptions): FastifyInstance;
 export declare function runLocalConsoleProcess(options?: {

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

@@ -7,7 +7,12 @@ import { readCliVersion } from "../cli/version.js";
 import { registerHostWebStaticRoutes, resolvePackagedWebStaticRoot } from "../http/static-web.js";
 import { detectLocalFolderPicker, pickLocalFolder } from "./folder-picker.js";
 import { LOCAL_CONSOLE_INVOCATION_ENV_KEYS, createLocalConsoleServiceEnvironment, } from "./invocation-context.js";
+import { spawnPackageUpdateWorkerProcess } from "./package-update-process.js";
+import { consumePackageUpdateCompletion, } from "./package-update-record.js";
+import { LocalConsolePackageUpdateService, } from "./package-update-service.js";
+import { createPackageUpdateWorkerInput } from "./package-update-worker.js";
 import { LocalConsoleProjectError, LocalConsoleProjectService, } from "./project-service.js";
+import { LocalConsoleOperationConflictError, LocalConsoleOperationCoordinator, } from "./operation-coordinator.js";
 import { LOCAL_CONSOLE_SESSION_COOKIE, LocalConsoleSessionRegistry, localConsoleSessionCookie, parseCookieHeader, } from "./session.js";
 import { createLocalConsoleSecret, deleteLocalConsoleRuntimeEndpoint, writeLocalConsoleRuntimeEndpoint, } from "./runtime-endpoint.js";
 export const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
@@ -66,10 +71,51 @@ export function createLocalConsoleServer(options) {
     const sessions = new LocalConsoleSessionRegistry({
         ...(options.now === undefined ? {} : { now: options.now }),
     });
+    const operations = options.operationCoordinator ?? new LocalConsoleOperationCoordinator();
     const projects = new LocalConsoleProjectService({
         tuttiHome,
+        operations,
         ...(options.env === undefined ? {} : { serviceEnvironment: options.env }),
     });
+    const packageUpdates = options.packageUpdateService ??
+        new LocalConsolePackageUpdateService({
+            tuttiHome,
+            operations,
+            ...(options.env === undefined ? {} : { env: options.env }),
+        });
+    const startPackageUpdate = options.startPackageUpdate ??
+        (async (preparation) => {
+            try {
+                const entrypoint = options.runtime?.entrypoint;
+                if (entrypoint === undefined) {
+                    throw new Error("Local Console package update entrypoint is unavailable.");
+                }
+                const completionEnvironment = createLocalConsoleServiceEnvironment({
+                    env: options.env ?? process.env,
+                    tuttiHome,
+                });
+                completionEnvironment.PATH = preparation.installation.npmEnvironment.PATH;
+                const noProxy = preparation.installation.npmEnvironment.NO_PROXY;
+                if (noProxy !== undefined && noProxy !== "") {
+                    completionEnvironment.NO_PROXY = noProxy;
+                }
+                return await spawnPackageUpdateWorkerProcess({
+                    input: createPackageUpdateWorkerInput({
+                        tuttiHome,
+                        cliEntrypoint: entrypoint,
+                        installation: preparation.installation,
+                        target: preparation.target,
+                        restoreProjectIds: preparation.restore_project_ids,
+                        completionEnvironment,
+                    }),
+                    lease: preparation.lease,
+                });
+            }
+            catch (error) {
+                preparation.lease.release();
+                throw error;
+            }
+        });
     app.addHook("onRequest", (request, reply, done) => {
         try {
             requireLoopbackHost(request);
@@ -88,7 +134,9 @@ export function createLocalConsoleServer(options) {
         }
     });
     app.setErrorHandler((error, _request, reply) => {
-        const normalized = error instanceof LocalConsoleHttpError || error instanceof LocalConsoleProjectError
+        const normalized = error instanceof LocalConsoleHttpError ||
+            error instanceof LocalConsoleProjectError ||
+            error instanceof LocalConsoleOperationConflictError
             ? error
             : isValidationError(error)
                 ? new LocalConsoleHttpError(400, "bad_request", "Local Console request is invalid.")
@@ -222,6 +270,7 @@ export function createLocalConsoleServer(options) {
     });
     app.get(`${LOCAL_CONSOLE_API_BASE}/bootstrap`, (request) => {
         const session = requireSession(request);
+        const packageUpdateCompletion = options.getPackageUpdateCompletion?.();
         return {
             csrf_token: session.csrfToken,
             invocation: session.context.source === "terminal"
@@ -232,8 +281,42 @@ export function createLocalConsoleServer(options) {
                 : { source: "desktop" },
             platform: process.platform,
             folder_picker: detectLocalFolderPicker(process.platform, session.context.environment).kind,
+            ...(packageUpdateCompletion === undefined
+                ? {}
+                : { package_update_completion: packageUpdateCompletion }),
         };
     });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/package-update`, {
+        schema: {
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: { refresh: { type: "string", enum: ["true"] } },
+            },
+        },
+    }, async (request) => {
+        requireSession(request);
+        return await packageUpdates.getStatus({ refresh: request.query.refresh === "true" });
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/package-update`, async (request, reply) => {
+        requireSession(request, true);
+        if (request.body !== undefined) {
+            throw new LocalConsoleHttpError(400, "bad_request", "Package update does not accept browser-controlled input.");
+        }
+        const begin = await packageUpdates.beginUpdate();
+        if (begin.status === "blocked") {
+            throw new LocalConsoleHttpError(409, begin.update.reason_code ?? "package_update_blocked", "Package update is currently unavailable.");
+        }
+        await startPackageUpdate(begin.preparation);
+        setImmediate(() => options.onShutdown?.());
+        return await reply.status(202).send({
+            current_version: begin.preparation.installation.currentVersion,
+            latest_version: begin.preparation.target.version,
+            status: "updating",
+            can_update: false,
+            phase: "preparing",
+        });
+    });
     app.get(`${LOCAL_CONSOLE_API_BASE}/projects`, async (request) => {
         const session = requireSession(request);
         return { projects: await projects.listProjects(session.context) };
@@ -244,7 +327,7 @@ export function createLocalConsoleServer(options) {
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/folders/pick`, async (request) => {
         const session = requireSession(request, true);
-        return await pickLocalFolder({ env: session.context.environment });
+        return await operations.runProjectOperation(async () => await pickLocalFolder({ env: session.context.environment }));
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/providers/models`, {
         schema: {
@@ -260,10 +343,10 @@ export function createLocalConsoleServer(options) {
         },
     }, async (request) => {
         requireSession(request, true);
-        return await projects.discoverModels({
+        return await operations.runProjectOperation(async () => await projects.discoverModels({
             baseUrl: request.body.base_url,
             apiKey: request.body.api_key,
-        });
+        }));
     });
     app.post(`${LOCAL_CONSOLE_API_BASE}/projects/launch`, {
         schema: {
@@ -359,6 +442,10 @@ export async function runLocalConsoleProcess(options = {}) {
         throw new Error("The Tutti CLI entrypoint is unavailable.");
     }
     let lastActivityAt = now().getTime();
+    const packageUpdateCompletion = consumePackageUpdateCompletion({
+        tuttiHome,
+        currentVersion: version,
+    });
     let requestClose = () => undefined;
     const app = createLocalConsoleServer({
         controlToken,
@@ -376,6 +463,7 @@ export async function runLocalConsoleProcess(options = {}) {
             lastActivityAt = now().getTime();
         },
         onShutdown: () => requestClose(),
+        getPackageUpdateCompletion: () => packageUpdateCompletion,
         ...(options.now === undefined ? {} : { now: options.now }),
     });
     await app.listen({ host: "127.0.0.1", port: 0 });

package/dist/server-shell/package-installation/command.d.ts

@@ -0,0 +1,36 @@
+export type PackageCommandPlan = {
+    executable: string;
+    args: readonly string[];
+    env: NodeJS.ProcessEnv;
+    timeoutMs: number;
+    maxOutputBytes: number;
+    shell: false;
+};
+export type PackageCommandResult = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    errorCode?: "spawn_failed" | "timeout" | "output_limit";
+};
+export type SyncPackageCommandRunner = (plan: PackageCommandPlan) => PackageCommandResult;
+export type PackageCommandRunner = (plan: PackageCommandPlan) => Promise<PackageCommandResult>;
+export declare const runPackageCommandSync: SyncPackageCommandRunner;
+export declare const runPackageCommand: PackageCommandRunner;
+export declare function collectNpmExecutableCandidates(options: {
+    env: NodeJS.ProcessEnv;
+    nodeExecutable: string;
+    packageRoot: string;
+    packageName: string;
+}): string[];
+export declare function createNpmCommandEnvironment(options: {
+    env: NodeJS.ProcessEnv;
+    nodeExecutable: string;
+}): NodeJS.ProcessEnv;
+export declare function createPackageCommandPlan(options: {
+    executable: string;
+    args: readonly string[];
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+}): PackageCommandPlan;
+//# sourceMappingURL=command.d.ts.map