@nowcrew/daemon 0.6.88-beta.2 → 0.6.88-beta.20

package/dist/storage-control.js

@@ -1,212 +0,0 @@
-import { z } from "zod";
-export const STORAGE_MIGRATION_CAPABILITY = "storage_migration_v1";
-export const STORAGE_MIGRATION_STATUS_CAPABILITY = "storage_migration_status_v1";
-const IdentitySchema = z.object({
-    migrationId: z.string().uuid(),
-    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
-    workspaceId: z.string().uuid(),
-    ownerEpoch: z.number().int().positive().safe().optional(),
-    ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
-});
-const DoctorRequestSchema = IdentitySchema.extend({ type: z.literal("daemon:storage-doctor") }).strict();
-const MigrateRequestSchema = IdentitySchema.extend({
-    type: z.literal("daemon:storage-migrate"),
-    manifestDigest: z.string().regex(/^[0-9a-f]{64}$/u),
-}).strict();
-const StatusSchema = z.enum([
-    "preflight_running", "preflight_passed", "backing_up", "initial_sync", "quiescing", "final_sync", "verified",
-    "service_switched", "hello_confirmed", "completed", "failed", "rollback_pending", "rolled_back",
-    "rollback_failed",
-]);
-const TOKEN = /(?:\bsk_(?:machine|user|agent)_[A-Za-z0-9_-]{4,}\b|\bbearer\s+[^\s]+|(?:password|secret|token)\s*[:=]\s*[^\s]+)/giu;
-const safeError = (error) => (error instanceof Error ? error.message : String(error))
-    .replaceAll(TOKEN, "<redacted>").slice(0, 500) || "storage migration failed";
-const stableErrorCode = (candidate, fallback) => typeof candidate === "string" && /^[a-z0-9._-]{1,128}$/u.test(candidate) ? candidate : fallback;
-export function createStorageControlController(input) {
-    const environment = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u).parse(input.environment);
-    const workspaceId = z.string().uuid().parse(input.workspaceId);
-    const profile = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u).parse(input.profile);
-    const sourceStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.sourceStorageFingerprint);
-    const targetStorageFingerprint = z.string().regex(/^sha256:[0-9a-f]{64}$/u).parse(input.targetStorageFingerprint);
-    const ownership = input.ownership === undefined ? undefined : Object.freeze({
-        ownerEpoch: z.number().int().positive().safe().parse(input.ownership.ownerEpoch),
-        ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u)
-            .parse(input.ownership.ownershipClaimFingerprint),
-    });
-    const preflights = new Map();
-    const preflightRuns = new Map();
-    const appliedMigrationIds = new Set();
-    let runningMigrationId = null;
-    const preflightTimeoutMs = z.number().int().positive().max(24 * 60 * 60 * 1000)
-        .parse(input.preflightTimeoutMs ?? 30 * 60 * 1000);
-    const frame = (identity, status, extra = {}) => ({
-        type: "daemon:storage-migration-status",
-        migrationId: identity.migrationId,
-        status,
-        environment,
-        workspaceId,
-        profile,
-        ...(ownership === undefined ? {} : ownership),
-        ...extra,
-    });
-    const failure = (identity, errorCode, error, reopenAdmission = false, extra = {}) => {
-        reportStatus(frame(identity, "failed", {
-            errorCode,
-            ...extra,
-            ...(error === undefined ? {} : { errorMessage: safeError(error) }),
-            ...(reopenAdmission || error?.reopenAdmission === true
-                ? { reopenAdmission: true }
-                : {}),
-        }));
-    };
-    const reportStatus = (statusFrame) => {
-        try {
-            input.sendStatus(statusFrame);
-        }
-        catch (error) {
-            input.onStatusError?.(error, statusFrame);
-        }
-    };
-    const matchesIdentity = (identity) => identity.environment === environment && identity.workspaceId === workspaceId
-        && (ownership === undefined
-            || (identity.ownerEpoch === ownership.ownerEpoch
-                && identity.ownershipClaimFingerprint === ownership.ownershipClaimFingerprint));
-    const preflightKey = (identity) => `${identity.migrationId}\0${identity.environment}\0${identity.workspaceId}`;
-    const runPreflight = (identity, failureFallback = "doctor_failed") => {
-        const key = preflightKey(identity);
-        const existing = preflightRuns.get(key);
-        if (existing !== undefined)
-            return existing;
-        const controller = new AbortController();
-        let scannedEntries = 0;
-        let timedOut = false;
-        reportStatus(frame(identity, "preflight_running", {
-            progress: { state: "running", scannedEntries: 0 },
-        }));
-        const doctorPromise = Promise.resolve().then(() => input.runDoctor(identity.migrationId, {
-            signal: controller.signal,
-            onProgress: (progress) => {
-                if (timedOut)
-                    return;
-                scannedEntries = progress.scannedEntries;
-                reportStatus(frame(identity, "preflight_running", {
-                    progress: { state: "running", scannedEntries },
-                }));
-            },
-        }));
-        let timeoutHandle;
-        const timeout = new Promise((_, reject) => {
-            timeoutHandle = setTimeout(() => {
-                timedOut = true;
-                controller.abort();
-                reject(Object.assign(new Error("storage doctor preflight timed out"), {
-                    code: "preflight_stale",
-                    scannedEntries,
-                }));
-            }, preflightTimeoutMs);
-            timeoutHandle.unref?.();
-        });
-        void doctorPromise.catch(() => undefined);
-        let outcome;
-        outcome = Promise.race([doctorPromise, timeout]).then((doctor) => {
-            if (doctor.manifest.migrationId !== identity.migrationId
-                || doctor.environment !== environment || doctor.workspaceId !== workspaceId
-                || doctor.profile !== profile) {
-                failure(identity, "storage_identity_mismatch", undefined, true);
-                return null;
-            }
-            if (!doctor.applyAllowed) {
-                failure(identity, doctor.blockers[0]?.code ?? "doctor_blocked", undefined, true);
-                return null;
-            }
-            preflights.set(identity.migrationId, doctor);
-            reportStatus(frame(identity, "preflight_passed", {
-                sourceStorageFingerprint,
-                targetStorageFingerprint,
-                manifestDigest: doctor.manifestDigest,
-            }));
-            return doctor;
-        }).catch((error) => {
-            const code = error.code;
-            if (code === "preflight_stale") {
-                failure(identity, "preflight_stale", undefined, true, {
-                    retryable: true,
-                    progress: { state: "stale", scannedEntries: Number(error.scannedEntries) || scannedEntries },
-                });
-            }
-            else if (code === "preflight_aborted") {
-                failure(identity, "preflight_aborted", error, true, {
-                    retryable: true,
-                    progress: { state: "stale", scannedEntries },
-                });
-            }
-            else {
-                failure(identity, stableErrorCode(code, failureFallback), error, true);
-            }
-            return null;
-        }).finally(() => {
-            if (timeoutHandle !== undefined)
-                clearTimeout(timeoutHandle);
-            if (preflightRuns.get(key) === outcome)
-                preflightRuns.delete(key);
-        });
-        preflightRuns.set(key, outcome);
-        return outcome;
-    };
-    const handle = async (raw) => {
-        const type = typeof raw === "object" && raw !== null && "type" in raw ? raw.type : null;
-        if (type !== "daemon:storage-doctor" && type !== "daemon:storage-migrate")
-            return false;
-        const schema = type === "daemon:storage-doctor" ? DoctorRequestSchema : MigrateRequestSchema;
-        const parsed = schema.safeParse(raw);
-        if (!parsed.success)
-            return true;
-        const identity = parsed.data;
-        if (!matchesIdentity(identity)) {
-            failure(identity, "storage_identity_mismatch", undefined, true);
-            return true;
-        }
-        if (type === "daemon:storage-doctor") {
-            await runPreflight(identity);
-            return true;
-        }
-        if (runningMigrationId !== null) {
-            if (runningMigrationId !== identity.migrationId)
-                failure(identity, "migration_active");
-            return true;
-        }
-        const migrate = MigrateRequestSchema.parse(identity);
-        if (appliedMigrationIds.has(identity.migrationId))
-            return true;
-        let doctor = preflights.get(identity.migrationId);
-        if (doctor === undefined) {
-            const rebuilt = await runPreflight(identity, "preflight_rebuild_failed");
-            if (rebuilt === null)
-                return true;
-            doctor = rebuilt;
-        }
-        if (!doctor.applyAllowed || doctor.manifestDigest !== migrate.manifestDigest
-            || doctor.manifest.migrationId !== identity.migrationId
-            || doctor.environment !== environment || doctor.workspaceId !== workspaceId || doctor.profile !== profile) {
-            failure(identity, "preflight_digest_mismatch", undefined, true);
-            return true;
-        }
-        preflights.delete(identity.migrationId);
-        runningMigrationId = identity.migrationId;
-        try {
-            await input.runMigration(doctor, (status) => {
-                if (StatusSchema.safeParse(status).success)
-                    reportStatus(frame(identity, status));
-            });
-            appliedMigrationIds.add(identity.migrationId);
-        }
-        catch (error) {
-            failure(identity, stableErrorCode(error.code, "storage_migration_failed"), error);
-        }
-        finally {
-            runningMigrationId = null;
-        }
-        return true;
-    };
-    return Object.freeze({ handle });
-}