@nowcrew/daemon 0.6.101-beta.6 → 0.6.101-beta.8

package/dist/memory-migration-runtime.js

@@ -1,367 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, lstat, realpath, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { z } from "zod";
-import { ExecutionCompletedSchema } from "./execution-protocol.js";
-import { startDormantSupervisor } from "./execution-supervisor.js";
-import { MemoryMigrationStartSchema } from "./memory-migration-protocol.js";
-import { MigrationHistorySchema, MigrationIdentitySchema, MigrationStateSchema } from "./local-memory/migration-schema.js";
-import { readMemoryInventorySource, inventoryLimits } from "./local-memory/inventory-source.js";
-const digest = (value) => createHash("sha256").update(value).digest("hex");
-const PROTECTED_WINDOW_PROBE_MS = 5 * 60_000;
-const protectedWindows = new Map();
-const Operation = z.object({ id: z.string(), revision: z.number().int(), executionId: z.string().nullable(),
-    status: z.string(), sourceDigest: z.string().nullable(), planDigest: z.string().nullable(),
-    writeIntentConfirmedAt: z.string().nullable(), newAgentConfirmed: z.boolean().optional(),
-    cancelRequestedAt: z.string().nullable(),
-}).passthrough();
-const Summary = z.object({ result: z.enum(["success", "failed", "needs_review", "repair_required", "missing"]),
-    phase: z.string().nullable().optional(), issues: z.array(z.object({ path: z.string(), reason: z.string() }).passthrough()) }).passthrough();
-const HistoryEnvelope = z.object({ operations: z.array(Operation) }).passthrough();
-function canReleaseProtectedWindow(operation) {
-    if (!operation)
-        return true;
-    if (["committed", "rolled_back"].includes(operation.status))
-        return true;
-    return operation.writeIntentConfirmedAt === null
-        && ["pending", "needs_review", "waiting_maintenance_window"].includes(operation.status);
-}
-function clearProtectedWindow(key, window) {
-    if (window.timer !== undefined)
-        clearTimeout(window.timer);
-    if (protectedWindows.get(key) === window)
-        protectedWindows.delete(key);
-    return window.reservation.release();
-}
-function scheduleProtectedWindowProbe(key, window, deps, common) {
-    if (window.timer !== undefined)
-        clearTimeout(window.timer);
-    const timer = setTimeout(async () => {
-        if (protectedWindows.get(key) !== window || window.active)
-            return;
-        try {
-            const history = HistoryEnvelope.parse(await deps.control("history", {}));
-            if (protectedWindows.get(key) !== window || window.active)
-                return;
-            const operation = history.operations.find(entry => entry.id === common.migrationId);
-            if (canReleaseProtectedWindow(operation)) {
-                await clearProtectedWindow(key, window);
-                return;
-            }
-        }
-        catch {
-            // Keep the protection when the control plane is unavailable. A later
-            // probe or the next recovery request must re-establish the proof.
-        }
-        scheduleProtectedWindowProbe(key, window, deps, common);
-    }, PROTECTED_WINDOW_PROBE_MS);
-    timer.unref?.();
-    window.timer = timer;
-}
-/** 系统维护在普通执行槽之前分流；只有 server 持久确认意图后才运行活动替换。 */
-export async function runMemoryMigration(raw, deps) {
-    const frame = MemoryMigrationStartSchema.parse(raw);
-    const common = { agentId: frame.agentId, migrationId: frame.migrationId, machineId: frame.machineId,
-        executionId: frame.executionId, attemptKey: frame.attemptKey };
-    const protectionKey = `${deps.agentsRoot}:${frame.migrationId}`;
-    const protectedWindow = protectedWindows.get(protectionKey);
-    if (protectedWindow) {
-        protectedWindow.active = true;
-        if (protectedWindow.timer !== undefined)
-            clearTimeout(protectedWindow.timer);
-        protectedWindow.timer = undefined;
-    }
-    const exclusive = protectedWindow?.reservation ?? await deps.coordinator.tryAcquireExclusiveExecution();
-    if (!exclusive) {
-        await deps.control("busy", { ...common, expectedRevision: frame.expectedRevision });
-        return { kind: "busy" };
-    }
-    let revision = frame.expectedRevision, intentConfirmed = false, acquired = false, acquisitionRequested = false, keepProtection = false;
-    let bound;
-    let identity, state;
-    let serverHistory;
-    let intentReceipt;
-    let lastPid = null, stopped = true, phaseCount = 0;
-    const startedAt = new Date().toISOString();
-    const dir = join(deps.agentsRoot, frame.handle);
-    const timeoutMs = deps.timeoutMs ?? 60_000;
-    const guard = () => ({ ...common, expectedRevision: revision, ...bound });
-    const control = async (step, extra = {}) => {
-        const response = await deps.control(step, { ...guard(), ...extra });
-        const parsed = z.object({ operation: Operation }).parse(response);
-        revision = parsed.operation.revision;
-        return parsed.operation;
-    };
-    const readKnownState = async (path) => {
-        const source = await readMemoryInventorySource(await realpath(dir), path, inventoryLimits.fileBytes);
-        return MigrationStateSchema.parse(JSON.parse(source.content));
-    };
-    const readState = () => readKnownState(".crew/memory/migration.v1.json");
-    const runTool = async (command, extra = {}) => {
-        if (!identity)
-            throw new Error("migration_identity_missing");
-        if (command === "recover" && deps.cancellation?.isRequested())
-            extra = { ...extra, cancelled: true };
-        const rollback = command === "recover" && extra.cancelled === true;
-        if (!rollback && deps.cancellation?.isRequested())
-            throw new Error("migration_cancelled");
-        if (phaseCount++ > 0) {
-            if (!stopped || !deps.journal.retry)
-                throw new Error("migration_stop_unproven");
-            await deps.journal.retry(frame.executionId);
-        }
-        const sourceMode = import.meta.url.endsWith(".ts");
-        const entry = fileURLToPath(new URL(`./local-memory/migration-tool-entry.${sourceMode ? "ts" : "js"}`, import.meta.url));
-        const args = sourceMode ? ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href, entry] : [entry];
-        let stdout = "";
-        const launched = await deps.journal.startGuarded(frame.executionId, new Date().toISOString(), () => (deps.startSupervisor ?? startDormantSupervisor)({ command: process.execPath, args, cwd: dir,
-            env: { PATH: process.env.PATH ?? "", CREW_SLS_LOG: "off" },
-            stdinText: JSON.stringify({ command, agentDir: dir, identity, ...extra }),
-        }, sourceMode ? {
-            childEntry: fileURLToPath(new URL("./execution-supervisor-child.ts", import.meta.url)),
-            execArgv: ["--import", pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm")).href],
-        } : {}), { beforeRelease: async ({ handle }) => {
-                lastPid = handle.pid;
-                stopped = false;
-                handle.stdout.on("data", chunk => { stdout += String(chunk); if (stdout.length > 2 * 1024 * 1024)
-                    void handle.cancel(); });
-                handle.stderr.resume();
-            } });
-        if (launched.kind !== "started")
-            throw new Error("migration_execution_already_running");
-        const processHandle = launched.handle;
-        deps.send({ type: "execution:started", protocolVersion: 1, executionId: frame.executionId, at: new Date().toISOString() });
-        let timedOut = false;
-        const timer = setTimeout(() => { timedOut = true; void processHandle.cancel(); }, timeoutMs);
-        if (!rollback)
-            deps.cancellation?.register(async () => { if (!stopped)
-                await processHandle.cancel(); });
-        try {
-            await processHandle.exit;
-            await processHandle.cancel();
-            stopped = true;
-            if (timedOut)
-                throw new Error("migration_window_timeout");
-            return Summary.parse(JSON.parse(stdout.trim()));
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    };
-    const finish = async (outcome, reason) => {
-        const completion = ExecutionCompletedSchema.parse({ type: "execution:completed", protocolVersion: 1,
-            executionId: frame.executionId, runtime: "memory_migration", resumed: false, outcome,
-            exitCode: outcome === "succeeded" ? 0 : 1, ...(reason ? { errorCode: reason, errorMessage: reason } : {}),
-            startedAt, finishedAt: new Date().toISOString() });
-        await deps.journal.complete(frame.executionId, completion);
-        deps.send(completion);
-    };
-    try {
-        const history = z.object({ operations: z.array(Operation), serverHistory: MigrationHistorySchema }).passthrough().parse(await deps.control("history", {}));
-        serverHistory = history.serverHistory;
-        const operation = history.operations.find(op => op.id === frame.migrationId);
-        if (!operation || operation.revision !== revision || operation.executionId !== frame.executionId)
-            throw new Error("migration_server_identity_mismatch");
-        intentConfirmed = operation.writeIntentConfirmedAt !== null;
-        await mkdir(dir, { recursive: true });
-        const root = await realpath(dir);
-        if ((await lstat(dir)).isSymbolicLink())
-            throw new Error("migration_root_invalid");
-        bound = { storageRootFingerprint: digest(root), ownerIdentity: String((await lstat(root)).uid) };
-        identity = MigrationIdentitySchema.parse({ agentId: frame.agentId, migrationId: frame.migrationId,
-            machineId: frame.machineId, executionId: frame.executionId, workspaceId: frame.workspaceId,
-            rootFingerprint: bound.storageRootFingerprint, ownerIdentity: bound.ownerIdentity,
-            sourceStorageVersion: frame.sourceStorageVersion, targetStorageVersion: 2 });
-        const { reqId: _transportRequest, ...stableFrame } = frame;
-        const accepted = await deps.journal.accept(frame.executionId, digest(JSON.stringify(stableFrame)), { runtime: "memory_migration" });
-        if (accepted.kind === "existing" && accepted.completion) {
-            deps.send(accepted.completion);
-            return { kind: "completed" };
-        }
-        deps.send({ type: "execution:accepted", protocolVersion: 1, executionId: frame.executionId,
-            state: "ready", effectivePermission: "workspace_write", at: new Date().toISOString() });
-        acquisitionRequested = true;
-        await control("acquired");
-        acquired = true;
-        if (frame.action === "recover") {
-            state = await readState().catch(() => undefined);
-            if (state && state.migrationId !== frame.migrationId && state.phase === "rolled_back"
-                && history.serverHistory.rolledBackOperations?.some(previous => previous.migrationId === state.migrationId
-                    && previous.sourceDigest === state.sourceDigest && previous.planDigest === state.planDigest))
-                state = undefined;
-            if (state) {
-                if (state.migrationId !== frame.migrationId || state.identity.rootFingerprint !== bound.storageRootFingerprint
-                    || state.identity.machineId !== frame.machineId || state.identity.agentId !== frame.agentId)
-                    throw new Error("migration_state_identity_mismatch");
-                identity = state.identity;
-            }
-            if (!state) {
-                state = await readKnownState(`.crew/memory/migrations/${frame.migrationId}/terminal.json`).catch((e) => {
-                    if (e.code !== "ENOENT")
-                        throw e;
-                    return readKnownState(`.crew/memory/migrations/${frame.migrationId}/manifest.json`);
-                });
-                identity = state.identity;
-            }
-            if (state.planDigest !== operation.planDigest || state.sourceDigest !== operation.sourceDigest)
-                throw new Error("migration_server_plan_mismatch");
-            const prior = await deps.journal.get(identity.executionId);
-            if (state.phase !== "committed" && (!prior || (prior.state !== "completed" && prior.state !== "interrupted"))) {
-                throw new Error("migration_stop_unproven");
-            }
-            const result = await runTool("recover", { serverHistory: history.serverHistory, cancelled: !intentConfirmed || operation.cancelRequestedAt !== null,
-                stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
-                    executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: null,
-                    stoppedAt: new Date().toISOString(), proof: "journal_reconciled" } });
-            if (result.result !== "success")
-                throw new Error("migration_recovery_failed");
-        }
-        else {
-            const prepared = await runTool("prepare", { serverHistory: history.serverHistory,
-                ...(frame.recordMappings ? { recordMappings: frame.recordMappings } : {}) });
-            if (prepared.result === "needs_review") {
-                await control("needs-review", { issues: prepared.issues });
-                await finish("failed", "migration_needs_review");
-                return { kind: "needs_review" };
-            }
-            if (prepared.result !== "success")
-                throw new Error("migration_prepare_failed");
-            state = await readState();
-            const confirmed = await control("intent", { sourceDigest: state.sourceDigest, planDigest: state.planDigest,
-                minReaderCapabilities: ["memory_storage_v2", "memory_state_guard_v1"], minWriterCapabilities: ["memory_storage_v2", "memory_state_guard_v1"] });
-            intentConfirmed = true;
-            intentReceipt = { ...identity, kind: "server_write_intent", sourceDigest: state.sourceDigest,
-                planDigest: state.planDigest, intentVersion: confirmed.revision, confirmedAt: confirmed.writeIntentConfirmedAt };
-            const result = await runTool("apply", { intentReceipt });
-            if (result.result !== "success")
-                throw new Error("migration_apply_failed");
-        }
-        state = await readState();
-        if (state.phase !== "committed" && state.phase !== "rolled_back")
-            throw new Error("migration_terminal_unverified");
-        if (!intentConfirmed) {
-            if (state.phase !== "rolled_back")
-                throw new Error("migration_commit_without_intent");
-            await control("no-write", { sourceDigest: state.sourceDigest, planDigest: state.planDigest, verified: true });
-        }
-        else
-            await control("result", { outcome: state.phase, storageVersion: state.storageVersion,
-                sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin, verified: true });
-        await finish("succeeded");
-        return { kind: "completed", phase: state.phase };
-    }
-    catch (error) {
-        // A recovery window must remain protected when the control plane cannot
-        // prove that no migration is active. The next request or bounded probe
-        // can release it after reading a terminal/no-write operation.
-        if (protectedWindow !== undefined && !acquisitionRequested)
-            keepProtection = true;
-        const reason = error instanceof Error && /^[a-z_]+$/u.test(error.message) ? error.message : "migration_execution_failed";
-        if (acquisitionRequested) {
-            try {
-                const latest = z.object({ operations: z.array(Operation) }).passthrough().parse(await deps.control("history", {}))
-                    .operations.find(op => op.id === frame.migrationId);
-                if (!latest || latest.executionId !== frame.executionId)
-                    throw new Error("migration_control_owner_changed");
-                revision = latest.revision;
-                intentConfirmed = latest.writeIntentConfirmedAt !== null;
-                acquired = !["needs_review", "rolled_back"].includes(latest.status);
-                if (intentConfirmed && identity && state && latest.sourceDigest === state.sourceDigest && latest.planDigest === state.planDigest) {
-                    intentReceipt = { ...identity, kind: "server_write_intent", sourceDigest: state.sourceDigest, planDigest: state.planDigest,
-                        intentVersion: latest.revision, confirmedAt: latest.writeIntentConfirmedAt };
-                }
-            }
-            catch {
-                keepProtection = true;
-            }
-        }
-        if (acquired) {
-            if (intentConfirmed) {
-                keepProtection = true;
-                if (stopped && identity && lastPid !== null) {
-                    try {
-                        const recovered = await runTool("recover", { cancelled: true, ...(intentReceipt ? { intentReceipt } : {}),
-                            stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
-                                executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: lastPid,
-                                stoppedAt: new Date().toISOString(), proof: "supervisor_exit" } });
-                        state = await readState();
-                        if (recovered.result === "success" && (state.phase === "committed" || state.phase === "rolled_back")) {
-                            await control("result", { outcome: state.phase, storageVersion: state.storageVersion,
-                                sourceDigest: state.sourceDigest, planDigest: state.planDigest, origin: state.origin, verified: true });
-                            keepProtection = false;
-                        }
-                    }
-                    catch { /* 未证明提交或完整回退时保留保护。 */ }
-                }
-                if (keepProtection)
-                    await control("repair", { reason }).catch(() => undefined);
-            }
-            else if (stopped) {
-                let digests;
-                try {
-                    let local = await readState().catch((error) => { if (error.code === "ENOENT")
-                        return undefined; throw error; });
-                    if (local?.migrationId !== frame.migrationId) {
-                        local = await readKnownState(`.crew/memory/migrations/${frame.migrationId}/manifest.json`).catch(async (error) => {
-                            if (error.code !== "ENOENT")
-                                throw error;
-                            const residue = await lstat(join(dir, ".crew/memory/migrations", frame.migrationId)).catch((statError) => {
-                                if (statError.code === "ENOENT")
-                                    return undefined;
-                                throw statError;
-                            });
-                            if (residue)
-                                throw new Error("migration_prepare_residue_unverified");
-                            return undefined;
-                        });
-                    }
-                    if (local?.migrationId === frame.migrationId) {
-                        if (!identity || lastPid === null || Object.keys(local.identity).some(key => local.identity[key] !== identity[key])
-                            || local.intentReceipt || !["prepared", "rolled_back"].includes(local.phase))
-                            throw new Error("migration_no_write_state_unverified");
-                        digests = { sourceDigest: local.sourceDigest, planDigest: local.planDigest };
-                        const recovered = await runTool("recover", { cancelled: true,
-                            serverHistory: { kind: "existing", migrationId: frame.migrationId, writeIntentConfirmed: false,
-                                ...(serverHistory?.rolledBackOperations ? { rolledBackOperations: serverHistory.rolledBackOperations } : {}) },
-                            stoppedReceipt: { kind: "migration_process_stopped", migrationId: frame.migrationId, machineId: frame.machineId,
-                                executionId: identity.executionId, ownerIdentity: identity.ownerIdentity, pid: lastPid,
-                                stoppedAt: new Date().toISOString(), proof: "supervisor_exit" } });
-                        state = await readState();
-                        if (recovered.result !== "success" || state.phase !== "rolled_back")
-                            throw new Error("migration_no_write_rollback_unverified");
-                        digests = { sourceDigest: state.sourceDigest, planDigest: state.planDigest };
-                    }
-                    await control("no-write", { verified: true, ...digests });
-                    keepProtection = false;
-                }
-                catch {
-                    keepProtection = true;
-                    await control("repair", { reason: "migration_no_write_rollback_unverified", ...digests }).catch(() => undefined);
-                }
-            }
-            else
-                keepProtection = true;
-        }
-        if (stopped)
-            await finish("failed", reason).catch(() => undefined);
-        return { kind: "failed", reason, processStopped: stopped, lastPid };
-    }
-    finally {
-        if (!keepProtection && stopped) {
-            if (protectedWindow !== undefined) {
-                await clearProtectedWindow(protectionKey, protectedWindow);
-            }
-            else {
-                await exclusive.release();
-            }
-        }
-        else {
-            const window = protectedWindow ?? { reservation: exclusive, executionId: frame.executionId, active: false, timer: undefined };
-            window.active = false;
-            protectedWindows.set(protectionKey, window);
-            scheduleProtectedWindowProbe(protectionKey, window, deps, common);
-        }
-    }
-}