@xfey/tutti 0.1.61 → 0.1.63

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

@@ -0,0 +1,92 @@
+import { inspectMachineProject, } from "../cli/machine-project-inspector.js";
+import { readHostLocalPackageUpdateReadiness, requestHostLocalIdleShutdown, } from "../cli/local-control-client.js";
+import { createRuntimeEndpointProbe, waitForHostShutdown } from "../cli/host-runtime-endpoint.js";
+import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
+import { resolveManagedProjectContext } from "../cli/project-resolver.js";
+const PACKAGE_UPDATE_HOST_SHUTDOWN_WAIT_MS = 5_000;
+export async function stopPackageUpdateHost(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    let inspection;
+    try {
+        inspection = await inspectMachineProject(options.projectId, {
+            tuttiHome: options.tuttiHome,
+            fetchImpl,
+        });
+    }
+    catch {
+        return "host_identity_unverified";
+    }
+    if (inspection.host.kind !== "running" ||
+        !inspection.host.identity_verified ||
+        inspection.endpoint.kind !== "valid") {
+        return "host_identity_unverified";
+    }
+    const endpoint = inspection.endpoint.record;
+    try {
+        const readiness = await readHostLocalPackageUpdateReadiness({ endpoint, fetchImpl });
+        if (readiness === "busy") {
+            return "host_busy";
+        }
+        if (readiness === "unsupported") {
+            return "host_update_unsupported";
+        }
+        const disposition = await requestHostLocalIdleShutdown({ endpoint, fetchImpl });
+        if (disposition === "busy") {
+            return "host_busy";
+        }
+        if (disposition !== "accepted") {
+            return "host_update_unsupported";
+        }
+        await waitForHostShutdown({
+            endpoint,
+            probeRuntimeEndpoint: createRuntimeEndpointProbe(fetchImpl),
+            shutdownWaitMs: PACKAGE_UPDATE_HOST_SHUTDOWN_WAIT_MS,
+        });
+        return "stopped";
+    }
+    catch {
+        return "host_identity_unverified";
+    }
+}
+export async function restorePackageUpdateHosts(options) {
+    const restored = [];
+    const failed = [];
+    for (const projectId of [...new Set(options.projectIds)].sort()) {
+        try {
+            const inspection = await inspectMachineProject(projectId, {
+                tuttiHome: options.tuttiHome,
+                ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+            });
+            if (inspection.host.kind === "running" && inspection.host.identity_verified) {
+                restored.push(projectId);
+                continue;
+            }
+            const project = resolveManagedProjectContext({
+                target: projectId,
+                env: { ...options.env, TUTTI_HOME: options.tuttiHome },
+            });
+            if (!project.workspace_exists || project.provider_config.status !== "configured") {
+                failed.push(projectId);
+                continue;
+            }
+            spawnDetachedHost({
+                workspaceRoot: project.workspace_root,
+                env: { ...options.env, TUTTI_HOME: options.tuttiHome },
+                inheritProcessEnv: false,
+            });
+            await waitForManagedHostReady({
+                tuttiHome: options.tuttiHome,
+                projectId,
+                workspaceRoot: project.workspace_root,
+                inviteMode: "preserve",
+                ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+            });
+            restored.push(projectId);
+        }
+        catch {
+            failed.push(projectId);
+        }
+    }
+    return { restored_project_ids: restored, failed_project_ids: failed };
+}
+//# sourceMappingURL=package-update-hosts.js.map

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

@@ -0,0 +1,46 @@
+export type PackageUpdateLockInspection = {
+    status: "unlocked";
+} | {
+    status: "active";
+} | {
+    status: "recovery_required";
+};
+export type PackageUpdateLockLease = {
+    path: string;
+    transferTo: (pid: number) => void;
+    release: () => void;
+};
+export type PackageUpdateLockAcquisition = {
+    status: "acquired";
+    lease: PackageUpdateLockLease;
+} | {
+    status: "active" | "recovery_required";
+};
+export declare function packageUpdateLockPath(tuttiHome: string): string;
+export declare function inspectPackageUpdateLock(options: {
+    tuttiHome: string;
+    now?: () => number;
+    staleMs?: number;
+    processAlive?: (pid: number) => boolean;
+}): PackageUpdateLockInspection;
+export declare function tryAcquirePackageUpdateLock(options: {
+    tuttiHome: string;
+    now?: () => number;
+    pid?: number;
+    staleMs?: number;
+    processAlive?: (pid: number) => boolean;
+}): PackageUpdateLockAcquisition;
+export declare function removeRecoverablePackageUpdateLock(options: {
+    tuttiHome: string;
+    now?: () => number;
+    staleMs?: number;
+    processAlive?: (pid: number) => boolean;
+}): boolean;
+export declare function transferPackageUpdateLockFromCurrentProcess(options: {
+    tuttiHome: string;
+    nextPid: number;
+    now?: () => number;
+}): boolean;
+export declare function releasePackageUpdateLockForCurrentProcess(tuttiHome: string): boolean;
+export declare function releasePackageUpdateLockForExpectedPid(tuttiHome: string, expectedPid: number): boolean;
+//# sourceMappingURL=package-update-lock.d.ts.map

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

@@ -0,0 +1,223 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, closeSync, constants, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const DEFAULT_STALE_MS = 30_000;
+export function packageUpdateLockPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "package-update.lock");
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function parseRecord(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (Object.keys(value).sort().join("\n") !==
+            ["acquired_at", "owner_id", "pid", "schema_version", "updated_at"].join("\n") ||
+            value.schema_version !== 1 ||
+            !isPositiveInteger(value.pid) ||
+            typeof value.owner_id !== "string" ||
+            value.owner_id === "" ||
+            typeof value.acquired_at !== "string" ||
+            typeof value.updated_at !== "string" ||
+            !Number.isFinite(Date.parse(value.acquired_at)) ||
+            !Number.isFinite(Date.parse(value.updated_at))) {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "EPERM");
+    }
+}
+function fileAge(path, now) {
+    try {
+        return Math.max(0, now() - statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+export function inspectPackageUpdateLock(options) {
+    const path = packageUpdateLockPath(options.tuttiHome);
+    const age = fileAge(path, options.now ?? Date.now);
+    if (age === null) {
+        return { status: "unlocked" };
+    }
+    const record = parseRecord(path);
+    if (record === null) {
+        return { status: "recovery_required" };
+    }
+    if ((options.processAlive ?? defaultProcessAlive)(record.pid)) {
+        return { status: "active" };
+    }
+    return age < (options.staleMs ?? DEFAULT_STALE_MS)
+        ? { status: "active" }
+        : { status: "recovery_required" };
+}
+function ensurePrivateRuntimeDirectory(path) {
+    const directory = dirname(path);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+}
+function writeRecord(path, record) {
+    const temporaryPath = `${path}.${record.owner_id}.tmp`;
+    try {
+        writeFileSync(temporaryPath, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+        chmodSync(temporaryPath, 0o600);
+        renameSync(temporaryPath, path);
+        chmodSync(path, 0o600);
+    }
+    finally {
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // Atomic rename normally removes the temporary path.
+        }
+    }
+}
+export function tryAcquirePackageUpdateLock(options) {
+    const path = packageUpdateLockPath(options.tuttiHome);
+    const now = options.now ?? Date.now;
+    ensurePrivateRuntimeDirectory(path);
+    const ownerId = randomBytes(16).toString("base64url");
+    const timestamp = new Date(now()).toISOString();
+    const record = {
+        schema_version: 1,
+        pid: options.pid ?? process.pid,
+        owner_id: ownerId,
+        acquired_at: timestamp,
+        updated_at: timestamp,
+    };
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "EEXIST") {
+            const inspection = inspectPackageUpdateLock(options);
+            return inspection.status === "unlocked" ? { status: "active" } : inspection;
+        }
+        throw error;
+    }
+    try {
+        writeFileSync(descriptor, `${JSON.stringify(record)}\n`, "utf8");
+    }
+    finally {
+        closeSync(descriptor);
+    }
+    chmodSync(path, 0o600);
+    let released = false;
+    return {
+        status: "acquired",
+        lease: {
+            path,
+            transferTo: (pid) => {
+                if (released || !isPositiveInteger(pid)) {
+                    throw new Error("Package update lock transfer is invalid.");
+                }
+                const current = parseRecord(path);
+                if (current?.owner_id !== ownerId) {
+                    throw new Error("Package update lock ownership changed before transfer.");
+                }
+                writeRecord(path, {
+                    ...current,
+                    pid,
+                    updated_at: new Date(now()).toISOString(),
+                });
+            },
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                if (parseRecord(path)?.owner_id !== ownerId) {
+                    return;
+                }
+                try {
+                    unlinkSync(path);
+                }
+                catch (error) {
+                    if (typeof error !== "object" ||
+                        error === null ||
+                        !("code" in error) ||
+                        error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            },
+        },
+    };
+}
+export function removeRecoverablePackageUpdateLock(options) {
+    if (inspectPackageUpdateLock(options).status !== "recovery_required") {
+        return false;
+    }
+    try {
+        unlinkSync(packageUpdateLockPath(options.tuttiHome));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function transferPackageUpdateLockFromCurrentProcess(options) {
+    if (!isPositiveInteger(options.nextPid)) {
+        return false;
+    }
+    const path = packageUpdateLockPath(options.tuttiHome);
+    const record = parseRecord(path);
+    if (record === null || record.pid !== process.pid) {
+        return false;
+    }
+    writeRecord(path, {
+        ...record,
+        pid: options.nextPid,
+        updated_at: new Date((options.now ?? Date.now)()).toISOString(),
+    });
+    return true;
+}
+export function releasePackageUpdateLockForCurrentProcess(tuttiHome) {
+    const path = packageUpdateLockPath(tuttiHome);
+    const record = parseRecord(path);
+    if (record === null || record.pid !== process.pid) {
+        return false;
+    }
+    try {
+        unlinkSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function releasePackageUpdateLockForExpectedPid(tuttiHome, expectedPid) {
+    const path = packageUpdateLockPath(tuttiHome);
+    const record = parseRecord(path);
+    if (record === null || record.pid !== expectedPid) {
+        return false;
+    }
+    try {
+        unlinkSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=package-update-lock.js.map

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

@@ -0,0 +1,20 @@
+export declare function packageUpdateLogPath(tuttiHome: string): string;
+export declare function withPackageUpdateLogDescriptor<T>(tuttiHome: string, run: (descriptor: number) => T): T;
+export declare function redactPackageUpdateOutput(value: string, privatePaths: readonly string[]): string;
+export declare class PackageUpdateLogger {
+    #private;
+    constructor(options: {
+        tuttiHome: string;
+        privatePaths?: readonly string[];
+        now?: () => Date;
+    });
+    append(options: {
+        level: "info" | "warn" | "error";
+        message: string;
+        phase?: string;
+        reasonCode?: string;
+        stdout?: string;
+        stderr?: string;
+    }): void;
+}
+//# sourceMappingURL=package-update-log.d.ts.map

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

@@ -0,0 +1,75 @@
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, renameSync, statSync, unlinkSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { redactAndTruncateText, serializeRuntimeLogLine } from "@tutti/shared/utils";
+const PACKAGE_UPDATE_LOG_MAX_BYTES = 2 * 1024 * 1024;
+const PACKAGE_UPDATE_OUTPUT_MAX_CHARS = 16 * 1024;
+export function packageUpdateLogPath(tuttiHome) {
+    return join(tuttiHome, "logs", "package-update.log");
+}
+function preparePackageUpdateLog(tuttiHome) {
+    const path = packageUpdateLogPath(tuttiHome);
+    const directory = dirname(path);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+    if (existsSync(path) && statSync(path).size >= PACKAGE_UPDATE_LOG_MAX_BYTES) {
+        const previous = `${path}.1`;
+        if (existsSync(previous)) {
+            unlinkSync(previous);
+        }
+        renameSync(path, previous);
+    }
+    return path;
+}
+export function withPackageUpdateLogDescriptor(tuttiHome, run) {
+    const path = preparePackageUpdateLog(tuttiHome);
+    const descriptor = openSync(path, "a", 0o600);
+    chmodSync(path, 0o600);
+    try {
+        return run(descriptor);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+export function redactPackageUpdateOutput(value, privatePaths) {
+    let redacted = redactAndTruncateText(value, PACKAGE_UPDATE_OUTPUT_MAX_CHARS);
+    for (const path of [...privatePaths, tmpdir()].filter((entry) => entry !== "")) {
+        redacted = redacted.replaceAll(path, "[REDACTED:local_path]");
+    }
+    return redacted.replace(/(^|[\s"'`=:(])(?:\/tmp\/|\/private\/tmp\/)[^\s"',)]+/gu, "$1[REDACTED:local_path]");
+}
+export class PackageUpdateLogger {
+    #tuttiHome;
+    #privatePaths;
+    #now;
+    constructor(options) {
+        this.#tuttiHome = options.tuttiHome;
+        this.#privatePaths = options.privatePaths ?? [];
+        this.#now = options.now ?? (() => new Date());
+    }
+    append(options) {
+        const path = preparePackageUpdateLog(this.#tuttiHome);
+        const fields = {
+            ...(options.phase === undefined ? {} : { phase: options.phase }),
+            ...(options.reasonCode === undefined ? {} : { reason_code: options.reasonCode }),
+            ...(options.stdout === undefined
+                ? {}
+                : { stdout: redactPackageUpdateOutput(options.stdout, this.#privatePaths) }),
+            ...(options.stderr === undefined
+                ? {}
+                : { stderr: redactPackageUpdateOutput(options.stderr, this.#privatePaths) }),
+        };
+        const line = serializeRuntimeLogLine({
+            level: options.level,
+            service: "tutti-package-update",
+            component: "worker",
+            message: options.message,
+            fields,
+            now: this.#now,
+        });
+        appendFileSync(path, `${line}\n`, { encoding: "utf8", mode: 0o600 });
+        chmodSync(path, 0o600);
+    }
+}
+//# sourceMappingURL=package-update-log.js.map

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

@@ -0,0 +1,22 @@
+import type { PackageUpdatePreparationLease } from "./package-update-service.js";
+import { type PackageUpdateWorkerInput } from "./package-update-worker.js";
+export type HiddenPackageUpdateProcessPlan = {
+    executable: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    shell: false;
+};
+export declare function buildHiddenPackageUpdateProcessPlan(options: {
+    input: PackageUpdateWorkerInput;
+    role: "worker" | "completion";
+}): HiddenPackageUpdateProcessPlan;
+export declare function spawnPackageUpdateWorkerProcess(options: {
+    input: PackageUpdateWorkerInput;
+    lease: PackageUpdatePreparationLease;
+}): Promise<{
+    pid: number;
+}>;
+export declare function runPackageUpdateWorkerProtocol(): Promise<void>;
+export declare function runPackageUpdateCompletionProtocol(): Promise<void>;
+//# sourceMappingURL=package-update-process.d.ts.map