@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/runtimes/codex-home.js

@@ -1,236 +0,0 @@
-import { chmod, copyFile, lstat, mkdir, open, readdir, readlink, rename, rm, symlink, unlink, link, writeFile, } from "node:fs/promises";
-import { constants } from "node:fs";
-import { dirname, join, relative, resolve, sep } from "node:path";
-const PRIVATE_CODEX_HOME = ".codex";
-export function defaultCodexHome(homeDir) {
-    return resolve(homeDir, PRIVATE_CODEX_HOME);
-}
-async function linkIfMissing(source, target) {
-    try {
-        await lstat(target);
-        return;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    try {
-        await lstat(source);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    try {
-        await symlink(source, target, "file");
-    }
-    catch (error) {
-        if (error.code !== "EEXIST")
-            throw error;
-    }
-}
-function isBelow(root, candidate) {
-    const child = relative(root, candidate);
-    return child !== "" && child !== ".." && !child.startsWith(`..${sep}`) && !child.startsWith(sep);
-}
-async function isExactSymlink(target, expectedSource) {
-    const linkTarget = await readlink(target);
-    return resolve(dirname(target), linkTarget) === resolve(expectedSource);
-}
-async function ensurePrivateSessions(target, legacySource) {
-    try {
-        const current = await lstat(target);
-        if (current.isSymbolicLink()) {
-            if (legacySource === undefined || !(await isExactSymlink(target, legacySource))) {
-                throw new Error(`Refusing to replace unexpected Codex sessions symlink: ${target}`);
-            }
-            const replacement = `${target}.private-${process.pid}-${Math.random().toString(36).slice(2)}`;
-            const legacyBackup = `${target}.legacy-${process.pid}-${Math.random().toString(36).slice(2)}`;
-            try {
-                await mkdir(replacement, { mode: 0o700 });
-                await rename(target, legacyBackup);
-                try {
-                    await rename(replacement, target);
-                }
-                catch (error) {
-                    await rename(legacyBackup, target).catch(() => undefined);
-                    throw error;
-                }
-            }
-            finally {
-                await rm(replacement, { recursive: true, force: true }).catch(() => undefined);
-                await rm(legacyBackup, { recursive: true, force: true }).catch(() => undefined);
-            }
-        }
-        else if (!current.isDirectory()) {
-            throw new Error(`Codex sessions target is not a directory: ${target}`);
-        }
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-        await mkdir(target, { mode: 0o700 });
-    }
-    await chmod(target, 0o700);
-}
-async function atomicCopyFile(source, target, mode) {
-    const parent = dirname(target);
-    await mkdir(parent, { recursive: true, mode: 0o700 });
-    const temporary = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-    try {
-        await copyFile(source, temporary, constants.COPYFILE_EXCL);
-        await chmod(temporary, mode);
-        try {
-            await link(temporary, target);
-            return true;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            return false;
-        }
-    }
-    finally {
-        await unlink(temporary).catch(() => undefined);
-    }
-}
-async function ensurePrivateIndex(target, source) {
-    let current;
-    try {
-        current = await lstat(target);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    if (current?.isSymbolicLink()) {
-        if (source === undefined || !(await isExactSymlink(target, source))) {
-            throw new Error(`Refusing to replace unexpected Codex session index symlink: ${target}`);
-        }
-        const replacement = `${target}.private-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        const legacyBackup = `${target}.legacy-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        try {
-            try {
-                await lstat(source);
-                await copyFile(source, replacement, constants.COPYFILE_EXCL);
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    throw error;
-                await writeFile(replacement, "", { encoding: "utf8", flag: "wx" });
-            }
-            await chmod(replacement, 0o600);
-            await rename(target, legacyBackup);
-            try {
-                await rename(replacement, target);
-            }
-            catch (error) {
-                await rename(legacyBackup, target).catch(() => undefined);
-                throw error;
-            }
-        }
-        finally {
-            await rm(replacement, { force: true }).catch(() => undefined);
-            await rm(legacyBackup, { force: true }).catch(() => undefined);
-        }
-        current = undefined;
-    }
-    if (current !== undefined && !current.isFile()) {
-        throw new Error(`Codex session index target is not a regular file: ${target}`);
-    }
-    if (current !== undefined) {
-        await chmod(target, 0o600);
-        return;
-    }
-    if (source !== undefined) {
-        try {
-            await lstat(source);
-            if (await atomicCopyFile(source, target, 0o600))
-                return;
-            return;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    const handle = await open(target, "wx", 0o600).catch((error) => {
-        if (error.code === "EEXIST")
-            return null;
-        throw error;
-    });
-    await handle?.close();
-}
-async function findRollout(root, sessionId) {
-    const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    });
-    const matches = [];
-    for (const entry of entries) {
-        const path = join(root, entry.name);
-        if (entry.isDirectory()) {
-            const nested = await findRollout(path, sessionId);
-            if (nested !== null)
-                matches.push(nested);
-        }
-        else if (entry.isFile() && entry.name.includes(sessionId)) {
-            matches.push(path);
-        }
-    }
-    if (matches.length > 1)
-        throw new Error(`Multiple Codex rollout files match session ${sessionId}`);
-    return matches[0] ?? null;
-}
-async function hydrateResumeRollout(sourceSessions, privateSessions, sessionId) {
-    if (sessionId.includes("/") || sessionId.includes("\\") || sessionId.includes("..")) {
-        throw new Error("Invalid Codex resume session id");
-    }
-    const sourcePath = await findRollout(sourceSessions, sessionId);
-    if (sourcePath === null)
-        return;
-    const relativePath = relative(sourceSessions, sourcePath);
-    const destination = resolve(privateSessions, relativePath);
-    if (!isBelow(resolve(privateSessions), destination)) {
-        throw new Error("Codex resume rollout escaped the private sessions directory");
-    }
-    let existing;
-    try {
-        existing = await lstat(destination);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    if (existing !== undefined) {
-        if (!existing.isFile() || existing.isSymbolicLink()) {
-            throw new Error(`Refusing to replace existing Codex rollout: ${destination}`);
-        }
-        return;
-    }
-    const mode = (await lstat(sourcePath)).mode & 0o777;
-    await atomicCopyFile(sourcePath, destination, mode);
-}
-/** Isolate Codex high-volume state per Agent while preserving auth and exact resume. */
-export async function materializeDefaultCodexHome(agentHome, sourceHome, resumeSessionId) {
-    const codexHome = defaultCodexHome(agentHome);
-    await mkdir(codexHome, { recursive: true, mode: 0o700 });
-    await chmod(codexHome, 0o700);
-    const source = sourceHome === undefined ? null : resolve(sourceHome);
-    if (source !== null && source !== codexHome) {
-        await Promise.all([
-            linkIfMissing(join(source, "auth.json"), join(codexHome, "auth.json")),
-            linkIfMissing(join(source, "config.toml"), join(codexHome, "config.toml")),
-        ]);
-    }
-    const sourceSessions = source === null || source === codexHome ? undefined : join(source, "sessions");
-    await ensurePrivateSessions(join(codexHome, "sessions"), sourceSessions);
-    const sourceIndex = source === null || source === codexHome ? undefined : join(source, "session_index.jsonl");
-    await ensurePrivateIndex(join(codexHome, "session_index.jsonl"), sourceIndex);
-    if (sourceSessions !== undefined && resumeSessionId) {
-        await hydrateResumeRollout(sourceSessions, join(codexHome, "sessions"), resumeSessionId);
-    }
-    return codexHome;
-}

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 });
-}