@nowcrew/daemon 0.6.102 → 0.6.103

package/dist/runtimes/opencode-runner.js

@@ -6,6 +6,8 @@ import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildOpenCodeArgs, createOpenCodeEventDecoder } from "./opencode.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 const ERROR_CAP = 2_000;
 async function readPrompt() {
     process.stdin.setEncoding("utf8");
@@ -25,7 +27,8 @@ export function isOpenCodeSessionNotFound(message) {
     return /(?:session|conversation).*(?:not found|does not exist|unknown|invalid)|(?:not found|unknown|invalid).*(?:session|conversation)/iu
         .test(message);
 }
-async function runAttempt(options, prompt) {
+async function runAttempt(options, prompt, capture, attempt) {
+    const observer = createObservationMapper("opencode", capture, `attempt:${attempt}`);
     const cwd = process.cwd();
     const child = spawn(options.bin, buildOpenCodeArgs({ cwd, ...options }), {
         cwd,
@@ -37,6 +40,7 @@ async function runAttempt(options, prompt) {
     }
     child.stderr.pipe(process.stderr, { end: false });
     const childExit = once(child, "close");
+    observer.context({ prompt });
     child.stdin.end(prompt);
     const decoder = createOpenCodeEventDecoder();
     const lines = createInterface({ input: child.stdout });
@@ -50,6 +54,7 @@ async function runAttempt(options, prompt) {
         catch {
             continue;
         }
+        observer.observe(event);
         for (const normalized of decoder.push(event)) {
             const type = normalized.type;
             const semantic = type === "opencode.text_delta"
@@ -87,17 +92,26 @@ async function runAttempt(options, prompt) {
     return { code: 0, staleSession: false };
 }
 export async function runOpenCode(options) {
+    const capture = createRuntimeObservationCapture("opencode");
+    try {
+        return await runOpenCodeObserved(options, capture);
+    }
+    finally {
+        capture.finish();
+    }
+}
+async function runOpenCodeObserved(options, capture) {
     const prompt = (await prepareThreadDelivery({ env: process.env, resumed: false,
         sessionId: "unverified-cold-opencode", wakePrompt: await readPrompt() })).prompt;
     if (process.env.CREW_THREAD_ROOT) {
         const { sessionId: _unverified, ...coldOptions } = options;
-        return (await runAttempt(coldOptions, prompt)).code;
+        return (await runAttempt(coldOptions, prompt, capture, 1)).code;
     }
-    const first = await runAttempt(options, prompt);
+    const first = await runAttempt(options, prompt, capture, 1);
     if (!first.staleSession)
         return first.code;
     const { sessionId: _staleSessionId, ...freshOptions } = options;
-    return (await runAttempt(freshOptions, prompt)).code;
+    return (await runAttempt(freshOptions, prompt, capture, 2)).code;
 }
 function optionsFromArgv(argv) {
     const { values } = parseArgs({

package/dist/runtimes/pi-runner.js

@@ -6,11 +6,24 @@ import spawn from "cross-spawn";
 import { augmentedPath } from "../runtime-path.js";
 import { prepareThreadDelivery } from "../thread-input-delivery.js";
 import { buildPiArgs, createPiEventDecoder } from "./pi.js";
+import { createRuntimeObservationCapture } from "../runtime-observation.js";
+import { createObservationMapper } from "./observation-mapper.js";
 async function readInput() { process.stdin.setEncoding("utf8"); let text = ""; for await (const chunk of process.stdin)
     text += String(chunk); return JSON.parse(text); }
 async function emit(event) { if (process.stdout.write(`${JSON.stringify(event)}\n`))
     return; await once(process.stdout, "drain"); }
 export async function runPi(bin) {
+    const capture = createRuntimeObservationCapture("pi");
+    const observer = createObservationMapper("pi", capture);
+    try {
+        return await runPiObserved(bin, observer);
+    }
+    finally {
+        observer.finish();
+        capture.finish();
+    }
+}
+async function runPiObserved(bin, observer) {
     const input = await readInput();
     // Pi 不持久化原生会话，每轮都须在启动模型前补齐当前线程快照。
     const delivery = await prepareThreadDelivery({
@@ -27,11 +40,14 @@ export async function runPi(bin) {
     let inputError;
     child.stdin.on("error", error => { inputError = error; });
     // Pi print 模式读取 stdin；完整线程历史不能塞进受长度限制的 argv。
+    observer.context({ systemPrompt: input.systemPrompt, prompt: delivery.prompt });
     child.stdin.end(delivery.prompt);
     const decoder = createPiEventDecoder();
     for await (const line of createInterface({ input: child.stdout })) {
         try {
-            for (const event of decoder.push(JSON.parse(line)))
+            const raw = JSON.parse(line);
+            observer.observe(raw);
+            for (const event of decoder.push(raw))
                 await emit(event);
         }
         catch { }

package/dist/storage-control.js

@@ -0,0 +1,212 @@
+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 });
+}