@xfey/tutti 0.1.61 → 0.1.62

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

@@ -0,0 +1,72 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type MachineProjectInspection } from "../cli/machine-project-inspector.js";
+import { type GlobalPackageInstallation, type GlobalPackageInstallationResolution, type PackageInstallationUnavailableReason, type PackageUpdateDiscovery, type PublishedPackageTarget } from "../package-installation/index.js";
+import { LocalConsoleOperationCoordinator } from "./operation-coordinator.js";
+import { type PackageUpdateLockAcquisition, type PackageUpdateLockInspection } from "./package-update-lock.js";
+import { type PackageUpdateRuntimeRecordRead } from "./package-update-record.js";
+export type LocalConsolePackageUpdateReason = PackageInstallationUnavailableReason | "registry_unavailable" | "console_busy" | "host_busy" | "host_identity_unverified" | "host_update_unsupported" | "update_in_progress" | "update_recovery_required" | "npm_install_failed" | "post_install_validation_failed" | "completion_start_failed" | "completion_failed" | "worker_crashed" | "host_restore_failed";
+export type LocalConsolePackageUpdateStatus = {
+    current_version: string;
+    latest_version?: string;
+    status: "up_to_date" | "ready" | "blocked" | "updating" | "failed";
+    can_update: boolean;
+    reason_code?: LocalConsolePackageUpdateReason;
+    phase?: "preparing" | "stopping_hosts" | "installing" | "restarting";
+};
+export type PackageUpdateHostReadiness = {
+    status: "ready";
+    restore_project_ids: ProjectId[];
+} | {
+    status: "blocked";
+    reason_code: "host_busy" | "host_identity_unverified" | "host_update_unsupported";
+};
+export type PackageUpdatePreparationLease = {
+    handoffTo: (pid: number) => void;
+    release: () => void;
+    cancel: () => void;
+};
+export type LocalConsolePackageUpdatePreparation = {
+    installation: GlobalPackageInstallation;
+    target: PublishedPackageTarget;
+    restore_project_ids: ProjectId[];
+    lease: PackageUpdatePreparationLease;
+};
+export type BeginLocalConsolePackageUpdateResult = {
+    status: "ready";
+    preparation: LocalConsolePackageUpdatePreparation;
+} | {
+    status: "blocked";
+    update: LocalConsolePackageUpdateStatus;
+};
+type HostReadinessReader = (inspection: MachineProjectInspection) => Promise<"ready" | "busy" | "unsupported">;
+export declare function inspectPackageUpdateHosts(options: {
+    projects: readonly MachineProjectInspection[];
+    readReadiness: HostReadinessReader;
+}): Promise<PackageUpdateHostReadiness>;
+export declare class LocalConsolePackageUpdateService {
+    #private;
+    constructor(options: {
+        tuttiHome: string;
+        env?: NodeJS.ProcessEnv;
+        currentVersion?: string;
+        operations?: LocalConsoleOperationCoordinator;
+        resolveInstallation?: () => GlobalPackageInstallationResolution;
+        discover?: (resolution: GlobalPackageInstallationResolution, options: {
+            refresh?: boolean;
+        }) => Promise<PackageUpdateDiscovery>;
+        inspectProjects?: () => Promise<MachineProjectInspection[]>;
+        readReadiness?: HostReadinessReader;
+        inspectLock?: () => PackageUpdateLockInspection;
+        acquireLock?: () => PackageUpdateLockAcquisition;
+        readRecord?: () => PackageUpdateRuntimeRecordRead;
+        clearFailedRecord?: (record: Extract<PackageUpdateRuntimeRecordRead, {
+            status: "valid";
+        }>["record"]) => boolean;
+    });
+    getStatus(options?: {
+        refresh?: boolean;
+    }): Promise<LocalConsolePackageUpdateStatus>;
+    beginUpdate(): Promise<BeginLocalConsolePackageUpdateResult>;
+}
+export {};
+//# sourceMappingURL=package-update-service.d.ts.map

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

@@ -0,0 +1,400 @@
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { inspectMachineProjects, } from "../cli/machine-project-inspector.js";
+import { readHostLocalPackageUpdateReadiness } from "../cli/local-control-client.js";
+import { readCliPackageIdentity, readCliVersion } from "../cli/version.js";
+import { PackageUpdateDiscoveryService, resolveGlobalPackageInstallation, } from "../package-installation/index.js";
+import { LocalConsoleOperationCoordinator, } from "./operation-coordinator.js";
+import { inspectPackageUpdateLock, tryAcquirePackageUpdateLock, } from "./package-update-lock.js";
+import { deletePackageUpdateRuntimeRecord, readPackageUpdateRuntimeRecord, } from "./package-update-record.js";
+const HOST_REASON_PRIORITY = {
+    host_identity_unverified: 0,
+    host_update_unsupported: 1,
+    host_busy: 2,
+};
+export async function inspectPackageUpdateHosts(options) {
+    const restoreProjectIds = [];
+    const reasons = [];
+    await Promise.all(options.projects.map(async (project) => {
+        if (project.host.kind === "stopped" && project.endpoint.kind === "missing") {
+            return;
+        }
+        if (project.host.kind !== "running" ||
+            !project.host.identity_verified ||
+            project.endpoint.kind !== "valid") {
+            reasons.push("host_identity_unverified");
+            return;
+        }
+        let readiness;
+        try {
+            readiness = await options.readReadiness(project);
+        }
+        catch {
+            reasons.push("host_identity_unverified");
+            return;
+        }
+        if (readiness === "busy") {
+            reasons.push("host_busy");
+            return;
+        }
+        if (readiness === "unsupported") {
+            reasons.push("host_update_unsupported");
+            return;
+        }
+        restoreProjectIds.push(project.project_id);
+    }));
+    const reason = reasons.sort((left, right) => HOST_REASON_PRIORITY[left] - HOST_REASON_PRIORITY[right])[0];
+    return reason === undefined
+        ? { status: "ready", restore_project_ids: restoreProjectIds.sort() }
+        : { status: "blocked", reason_code: reason };
+}
+function blocked(options) {
+    return {
+        current_version: options.currentVersion,
+        ...(options.latestVersion === undefined ? {} : { latest_version: options.latestVersion }),
+        status: "blocked",
+        can_update: false,
+        reason_code: options.reasonCode,
+    };
+}
+function lockBlockedStatus(inspection, currentVersion) {
+    return blocked({
+        currentVersion,
+        reasonCode: inspection.status === "active" ? "update_in_progress" : "update_recovery_required",
+    });
+}
+export class LocalConsolePackageUpdateService {
+    #tuttiHome;
+    #currentVersion;
+    #operations;
+    #resolveInstallation;
+    #discover;
+    #inspectProjects;
+    #readReadiness;
+    #inspectLock;
+    #acquireLock;
+    #readRecord;
+    #clearFailedRecord;
+    constructor(options) {
+        this.#tuttiHome = options.tuttiHome;
+        this.#currentVersion = options.currentVersion ?? readCliVersion();
+        this.#operations = options.operations ?? new LocalConsoleOperationCoordinator();
+        const env = options.env ?? process.env;
+        let installation;
+        this.#resolveInstallation =
+            options.resolveInstallation ??
+                (() => {
+                    installation ??= resolveGlobalPackageInstallation({
+                        packageIdentity: readCliPackageIdentity(),
+                        tuttiHome: this.#tuttiHome,
+                        defaultTuttiHome: resolveTuttiHome(undefined),
+                        env,
+                    });
+                    return installation;
+                });
+        const discovery = new PackageUpdateDiscoveryService();
+        this.#discover =
+            options.discover ?? ((resolution, input) => discovery.discover(resolution, input));
+        this.#inspectProjects =
+            options.inspectProjects ?? (() => inspectMachineProjects({ tuttiHome: this.#tuttiHome }));
+        this.#readReadiness =
+            options.readReadiness ??
+                (async (project) => {
+                    if (project.endpoint.kind !== "valid") {
+                        throw new Error("Host endpoint is unavailable.");
+                    }
+                    return await readHostLocalPackageUpdateReadiness({ endpoint: project.endpoint.record });
+                });
+        this.#inspectLock =
+            options.inspectLock ?? (() => inspectPackageUpdateLock({ tuttiHome: this.#tuttiHome }));
+        this.#acquireLock =
+            options.acquireLock ?? (() => tryAcquirePackageUpdateLock({ tuttiHome: this.#tuttiHome }));
+        this.#readRecord =
+            options.readRecord ?? (() => readPackageUpdateRuntimeRecord({ tuttiHome: this.#tuttiHome }));
+        this.#clearFailedRecord =
+            options.clearFailedRecord ??
+                ((record) => deletePackageUpdateRuntimeRecord({
+                    tuttiHome: this.#tuttiHome,
+                    expectedTargetVersion: record.target_version,
+                    expectedUpdaterPid: record.updater_pid,
+                }));
+    }
+    async getStatus(options = {}) {
+        return (await this.#evaluate({ refresh: options.refresh === true, ownsUpdateLock: false }))
+            .update;
+    }
+    async beginUpdate() {
+        const lock = this.#acquireLock();
+        if (lock.status !== "acquired") {
+            return {
+                status: "blocked",
+                update: lockBlockedStatus(lock, this.#currentVersion),
+            };
+        }
+        const operationLease = this.#operations.tryBeginPackageUpdate();
+        if (operationLease === null) {
+            lock.lease.release();
+            return {
+                status: "blocked",
+                update: blocked({ currentVersion: this.#currentVersion, reasonCode: "console_busy" }),
+            };
+        }
+        try {
+            const evaluation = await this.#evaluate({ refresh: true, ownsUpdateLock: true });
+            if (evaluation.update.status !== "ready" ||
+                evaluation.installation === undefined ||
+                evaluation.target === undefined ||
+                evaluation.restore_project_ids === undefined) {
+                operationLease.release();
+                lock.lease.release();
+                return { status: "blocked", update: evaluation.update };
+            }
+            return {
+                status: "ready",
+                preparation: {
+                    installation: evaluation.installation,
+                    target: evaluation.target,
+                    restore_project_ids: evaluation.restore_project_ids,
+                    lease: this.#combinedLease(lock.lease, operationLease),
+                },
+            };
+        }
+        catch (error) {
+            operationLease.release();
+            lock.lease.release();
+            throw error;
+        }
+    }
+    #combinedLease(lock, operation) {
+        let released = false;
+        let handedOff = false;
+        return {
+            handoffTo: (pid) => {
+                if (released || handedOff) {
+                    throw new Error("Package update preparation lease was already settled.");
+                }
+                lock.transferTo(pid);
+                handedOff = true;
+            },
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                if (!handedOff) {
+                    operation.release();
+                    lock.release();
+                }
+            },
+            cancel: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                operation.release();
+                lock.release();
+            },
+        };
+    }
+    async #evaluate(options) {
+        const runtime = options.skipRuntimeRecord
+            ? { status: "missing" }
+            : this.#readRecord();
+        if (runtime.status === "invalid") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    reasonCode: "update_recovery_required",
+                }),
+            };
+        }
+        if (runtime.status === "valid") {
+            const record = runtime.record;
+            if (record.source_version !== this.#currentVersion &&
+                record.target_version !== this.#currentVersion) {
+                return {
+                    update: blocked({
+                        currentVersion: this.#currentVersion,
+                        reasonCode: "update_recovery_required",
+                    }),
+                };
+            }
+            if (record.phase === "failed") {
+                if (options.refresh &&
+                    this.#inspectLock().status === "unlocked" &&
+                    this.#clearFailedRecord(record)) {
+                    return await this.#evaluate({ ...options, refresh: true, skipRuntimeRecord: true });
+                }
+                const knownReasons = new Set([
+                    "host_busy",
+                    "host_identity_unverified",
+                    "host_update_unsupported",
+                    "npm_install_failed",
+                    "post_install_validation_failed",
+                    "completion_start_failed",
+                    "completion_failed",
+                    "worker_crashed",
+                ]);
+                return {
+                    update: {
+                        current_version: this.#currentVersion,
+                        latest_version: record.target_version,
+                        status: "failed",
+                        can_update: false,
+                        reason_code: record.failure_reason_code !== undefined &&
+                            knownReasons.has(record.failure_reason_code)
+                            ? record.failure_reason_code
+                            : "update_recovery_required",
+                    },
+                };
+            }
+            const lock = this.#inspectLock();
+            if (record.phase === "restarting" &&
+                record.target_version === this.#currentVersion &&
+                lock.status === "unlocked") {
+                return {
+                    update: (record.restart_failure_count ?? 0) > 0
+                        ? {
+                            current_version: this.#currentVersion,
+                            latest_version: record.target_version,
+                            status: "failed",
+                            can_update: false,
+                            reason_code: "host_restore_failed",
+                        }
+                        : {
+                            current_version: this.#currentVersion,
+                            latest_version: record.target_version,
+                            status: "up_to_date",
+                            can_update: false,
+                        },
+                };
+            }
+            if (lock.status !== "active") {
+                return {
+                    update: blocked({
+                        currentVersion: this.#currentVersion,
+                        reasonCode: "update_recovery_required",
+                    }),
+                };
+            }
+            return {
+                update: {
+                    current_version: this.#currentVersion,
+                    latest_version: record.target_version,
+                    status: "updating",
+                    can_update: false,
+                    phase: record.phase === "stopping_hosts"
+                        ? "stopping_hosts"
+                        : record.phase === "installing"
+                            ? "installing"
+                            : record.phase === "restarting"
+                                ? "restarting"
+                                : "preparing",
+                },
+            };
+        }
+        if (!options.ownsUpdateLock) {
+            const lock = this.#inspectLock();
+            if (lock.status !== "unlocked") {
+                return { update: lockBlockedStatus(lock, this.#currentVersion) };
+            }
+            if (this.#operations.state() === "package_update") {
+                return {
+                    update: blocked({
+                        currentVersion: this.#currentVersion,
+                        reasonCode: "update_in_progress",
+                    }),
+                };
+            }
+        }
+        const resolution = this.#resolveInstallation();
+        if (resolution.status === "unavailable") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    reasonCode: resolution.reasonCode,
+                }),
+            };
+        }
+        const discovery = await this.#discover(resolution, { refresh: options.refresh });
+        if (discovery.status === "unavailable") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    reasonCode: discovery.reasonCode,
+                }),
+            };
+        }
+        if (discovery.status === "up_to_date") {
+            return {
+                update: {
+                    current_version: this.#currentVersion,
+                    latest_version: discovery.latestVersion,
+                    status: "up_to_date",
+                    can_update: false,
+                },
+            };
+        }
+        if (this.#operations.state() === "project_busy") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    latestVersion: discovery.latestVersion,
+                    reasonCode: "console_busy",
+                }),
+            };
+        }
+        let projects;
+        try {
+            projects = await this.#inspectProjects();
+        }
+        catch {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    latestVersion: discovery.latestVersion,
+                    reasonCode: "host_identity_unverified",
+                }),
+            };
+        }
+        const hosts = await inspectPackageUpdateHosts({
+            projects,
+            readReadiness: this.#readReadiness,
+        });
+        if (hosts.status === "blocked") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    latestVersion: discovery.latestVersion,
+                    reasonCode: hosts.reason_code,
+                }),
+            };
+        }
+        if (this.#operations.state() === "project_busy") {
+            return {
+                update: blocked({
+                    currentVersion: this.#currentVersion,
+                    latestVersion: discovery.latestVersion,
+                    reasonCode: "console_busy",
+                }),
+            };
+        }
+        if (!options.ownsUpdateLock) {
+            const lock = this.#inspectLock();
+            if (lock.status !== "unlocked") {
+                return { update: lockBlockedStatus(lock, this.#currentVersion) };
+            }
+        }
+        return {
+            update: {
+                current_version: this.#currentVersion,
+                latest_version: discovery.latestVersion,
+                status: "ready",
+                can_update: true,
+            },
+            installation: resolution.installation,
+            target: discovery.target,
+            restore_project_ids: hosts.restore_project_ids,
+        };
+    }
+}
+//# sourceMappingURL=package-update-service.js.map

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

@@ -0,0 +1,55 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { readCliPackageIdentity } from "../cli/version.js";
+import { type GlobalPackageInstallation, type PackageCommandRunner, type PublishedPackageTarget } from "../package-installation/index.js";
+import { PackageUpdateLogger } from "./package-update-log.js";
+import { type PackageUpdateRuntimeRecord } from "./package-update-record.js";
+import { type PackageUpdateHostStopResult } from "./package-update-hosts.js";
+export type PackageUpdateWorkerInput = {
+    schema_version: 1;
+    tutti_home: string;
+    cli_entrypoint: string;
+    installation: GlobalPackageInstallation;
+    target: PublishedPackageTarget;
+    restore_project_ids: ProjectId[];
+    completion_environment: NodeJS.ProcessEnv;
+};
+export type PackageUpdateWorkerResult = {
+    status: "handed_off";
+} | {
+    status: "failed";
+    reason_code: string;
+    restart_failure_count: number;
+};
+export declare function parsePackageUpdateWorkerInput(value: unknown, options?: {
+    defaultTuttiHome?: string;
+}): PackageUpdateWorkerInput | null;
+export type PackageUpdateWorkerDependencies = {
+    now?: () => Date;
+    logger?: PackageUpdateLogger;
+    commandRunner?: PackageCommandRunner;
+    stopHost?: (projectId: ProjectId) => Promise<PackageUpdateHostStopResult>;
+    restoreHosts?: (projectIds: readonly ProjectId[]) => Promise<{
+        restored_project_ids: ProjectId[];
+        failed_project_ids: ProjectId[];
+    }>;
+    verifyPostInstall?: (input: PackageUpdateWorkerInput) => Promise<boolean>;
+    startCompletion: (input: PackageUpdateWorkerInput, record: PackageUpdateRuntimeRecord) => Promise<void>;
+    releaseLock?: () => boolean;
+    writeRecord?: (record: PackageUpdateRuntimeRecord) => void;
+    updateRecord?: (record: PackageUpdateRuntimeRecord, options: {
+        phase: PackageUpdateRuntimeRecord["phase"];
+        failureReasonCode?: string;
+        restartFailureCount?: number;
+    }) => PackageUpdateRuntimeRecord;
+};
+export declare function createPackageUpdateWorkerInput(options: {
+    tuttiHome: string;
+    cliEntrypoint: string;
+    installation: GlobalPackageInstallation;
+    target: PublishedPackageTarget;
+    restoreProjectIds: readonly ProjectId[];
+    completionEnvironment: NodeJS.ProcessEnv;
+}): PackageUpdateWorkerInput;
+export declare function verifyPackageUpdatePostInstall(input: PackageUpdateWorkerInput, runner?: PackageCommandRunner, readIdentity?: typeof readCliPackageIdentity): Promise<boolean>;
+export declare function runPackageUpdateWorker(input: PackageUpdateWorkerInput, dependencies: PackageUpdateWorkerDependencies): Promise<PackageUpdateWorkerResult>;
+//# sourceMappingURL=package-update-worker.d.ts.map