@nowcrew/daemon 0.6.103 → 0.6.105

package/dist/project-skills/serve-capability.js

@@ -1,28 +0,0 @@
-import { WebSocket } from "ws";
-import { daemonCapabilityBindings, } from "../machine-info.js";
-import { prepareProjectSkillConnectionCapabilities, } from "./capability.js";
-export function createProjectSkillConnectionCapabilityProvider(input) {
-    return async () => daemonCapabilityBindings(input.platform, await prepareProjectSkillConnectionCapabilities(input));
-}
-export function createProjectSkillMachineHelloPublisher(input) {
-    let latest = null;
-    let latestSocket = null;
-    const republish = () => {
-        if (latest === null || latestSocket?.readyState !== WebSocket.OPEN)
-            return;
-        const hello = input.effective(latest, input.status());
-        try {
-            latestSocket.send(JSON.stringify(hello));
-            input.onSent(hello);
-        }
-        catch { /* 非 OPEN,忽略 */ }
-    };
-    return Object.freeze({
-        publish: (hello, socket) => {
-            latest = hello;
-            latestSocket = socket;
-            republish();
-        },
-        republish,
-    });
-}

package/dist/project-skills/serve-startup.js

@@ -1,37 +0,0 @@
-import { createExecutionJournal } from "../execution-journal.js";
-import { reconcileExecutionJournal } from "../execution-recovery.js";
-import { dslog, flushSlog } from "../slog.js";
-export async function initializeProjectSkillProtectedExecutionJournal(input) {
-    return input.startup.initializeAfterLeaseProtection(input.config.agentsRoot, async (snapshot) => {
-        input.protectedExecutionIds.clear();
-        for (const executionId of snapshot)
-            input.protectedExecutionIds.add(executionId);
-        const journal = input.injectedJournal ?? createExecutionJournal(input.config.agentsRoot, {
-            protectedExecutionIds: () => input.protectedExecutionIds,
-            onOperationTiming: (event) => {
-                if (event.operation !== "mark_runtime_ready"
-                    && event.queueWaitMs < 250
-                    && event.operationMs < 250)
-                    return;
-                dslog("execution.journal_operation", "execution journal 操作完成", {
-                    level: event.outcome === "succeeded" ? "INFO" : "ERROR",
-                    execution_id: event.executionId,
-                    operation: event.operation,
-                    outcome: event.outcome,
-                    queue_wait_ms: event.queueWaitMs,
-                    operation_ms: event.operationMs,
-                    total_ms: event.queueWaitMs + event.operationMs,
-                });
-            },
-        });
-        await reconcileExecutionJournal(journal, {
-            agentsRoot: input.config.agentsRoot,
-            serverUrl: input.config.serverUrl,
-            ...(input.profileName === undefined ? {} : { profileName: input.profileName }),
-            log: dslog,
-            flush: flushSlog,
-            writeStderr: (line) => process.stderr.write(line),
-        });
-        return journal;
-    });
-}

package/dist/runtimes/codex-home-migration-cli.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { migrateCodexHome } from "./codex-home-migration.js";
-const { values } = parseArgs({
-    args: process.argv.slice(2),
-    strict: true,
-    options: {
-        "agent-home": { type: "string" },
-        "source-home": { type: "string" },
-        "backup-root": { type: "string" },
-        yes: { type: "boolean", default: false },
-    },
-});
-function required(value, name) {
-    if (!value?.trim())
-        throw new Error(`Missing --${name}`);
-    return value;
-}
-if (!values.yes)
-    throw new Error("Refusing Codex home migration without --yes");
-const result = await migrateCodexHome({
-    agentHome: required(values["agent-home"], "agent-home"),
-    sourceHome: required(values["source-home"], "source-home"),
-    backupRoot: required(values["backup-root"], "backup-root"),
-});
-process.stdout.write(`${result.status}${result.backupDir ? ` backup=${result.backupDir}` : ""}\n`);

package/dist/runtimes/codex-home-migration.js

@@ -1,112 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { lstat, mkdir, readlink, rename, rm, symlink, unlink, } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { randomUUID } from "node:crypto";
-import { atomicPrivateWrite } from "../atomic-private-write.js";
-import { defaultCodexHome, materializeDefaultCodexHome } from "./codex-home.js";
-const execFileAsync = promisify(execFile);
-const SQLITE_FILES = ["state_5.sqlite", "state_5.sqlite-wal", "state_5.sqlite-shm"];
-const MARKER_NAME = ".codex-home-migration.json";
-async function exists(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-async function assertNoOpenSqliteFiles(codexHome) {
-    for (const name of SQLITE_FILES) {
-        const path = join(codexHome, name);
-        if (!(await exists(path)))
-            continue;
-        try {
-            const result = await execFileAsync("lsof", ["-t", "--", path], { encoding: "utf8" });
-            if (result.stdout.trim()) {
-                throw new Error(`Codex SQLite file is still open: ${path}`);
-            }
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 1)
-                continue;
-            if (code === "ENOENT")
-                throw new Error("lsof is required to verify Codex home quiescence");
-            throw error;
-        }
-    }
-}
-async function symlinkTarget(path) {
-    try {
-        const info = await lstat(path);
-        if (!info.isSymbolicLink())
-            return null;
-        return await readlink(path);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-export async function migrateCodexHome(input, dependencies = {}) {
-    const agentHome = resolve(input.agentHome);
-    const sourceHome = resolve(input.sourceHome);
-    const backupRoot = resolve(input.backupRoot);
-    const codexHome = defaultCodexHome(agentHome);
-    const sessions = join(codexHome, "sessions");
-    const index = join(codexHome, "session_index.jsonl");
-    const expectedSessions = resolve(sourceHome, "sessions");
-    const expectedIndex = resolve(sourceHome, "session_index.jsonl");
-    const marker = join(codexHome, MARKER_NAME);
-    const sessionLink = await symlinkTarget(sessions);
-    const indexLink = await symlinkTarget(index);
-    if (sessionLink === null && indexLink === null && await exists(marker)) {
-        return { status: "already-migrated" };
-    }
-    if (sessionLink === null || indexLink === null) {
-        throw new Error("Refusing migration: Codex home is not in the complete legacy symlink layout");
-    }
-    if (resolve(codexHome, sessionLink) !== expectedSessions || resolve(codexHome, indexLink) !== expectedIndex) {
-        throw new Error("Refusing migration: legacy symlinks do not point to the configured source home");
-    }
-    await (dependencies.ensureQuiesced ?? assertNoOpenSqliteFiles)(codexHome);
-    const stamp = (dependencies.now ?? (() => new Date()))().toISOString().replaceAll(/[^0-9]/g, "").slice(0, 14);
-    const backupDir = join(backupRoot, `${stamp}-${dependencies.id?.() ?? randomUUID()}`);
-    await mkdir(backupDir, { recursive: true, mode: 0o700 });
-    await symlink(sessionLink, join(backupDir, "sessions"), "dir");
-    await symlink(indexLink, join(backupDir, "session_index.jsonl"), "file");
-    const moved = [];
-    try {
-        for (const name of SQLITE_FILES) {
-            const current = join(codexHome, name);
-            if (await exists(current)) {
-                await rename(current, join(backupDir, name));
-                moved.push(name);
-            }
-        }
-        await materializeDefaultCodexHome(agentHome, sourceHome);
-        await atomicPrivateWrite(marker, JSON.stringify({
-            version: 1,
-            migrated_at: new Date().toISOString(),
-            source_home: sourceHome,
-            backup_dir: backupDir,
-        }) + "\n");
-        return { status: "migrated", backupDir };
-    }
-    catch (error) {
-        for (const name of moved.reverse()) {
-            await rename(join(backupDir, name), join(codexHome, name)).catch(() => undefined);
-        }
-        await rm(sessions, { recursive: true, force: true });
-        await unlink(index).catch(() => undefined);
-        await symlink(sessionLink, sessions, "dir").catch(() => undefined);
-        await symlink(indexLink, index, "file").catch(() => undefined);
-        throw error;
-    }
-}
-export const codexHomeMigrationMarkerName = MARKER_NAME;

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