@nowcrew/daemon 0.5.19 → 0.5.21

package/dist/execution-journal-lock.js

@@ -1,6 +1,7 @@
 import { mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, } from "node:fs/promises";
+import { renameSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { z } from "zod";
 const OwnerSchema = z.object({
     pid: z.number().int().positive(),
@@ -8,9 +9,15 @@ const OwnerSchema = z.object({
     token: z.string().uuid(),
 }).strict();
 export class JournalLockedError extends Error {
-    constructor(message) {
+    journalPath;
+    ownerPid;
+    constructor(message, diagnostics = {}) {
         super(message);
         this.name = "JournalLockedError";
+        if (diagnostics.journalPath !== undefined)
+            this.journalPath = diagnostics.journalPath;
+        if (diagnostics.ownerPid !== undefined)
+            this.ownerPid = diagnostics.ownerPid;
     }
 }
 export class JournalLockCorruptionError extends Error {
@@ -24,6 +31,7 @@ export const defaultJournalLockFileSystem = {
     readFile: (path) => readFile(path, "utf8"),
     readdir,
     rename,
+    renameSync,
     rm,
     rmdir,
     stat,
@@ -44,6 +52,141 @@ export function createJournalLeaseRegistry() {
     return { leases: new Map() };
 }
 const codeOf = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+const ownerFileName = (token) => `owner.${token}.json`;
+const releasedLockName = (token) => `.journal.released.${token}.lock`;
+const RELEASED_LOCK_PATTERN = /^\.journal\.released\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.lock$/i;
+const MAX_RELEASED_LOCK_CLEANUP = 8;
+const throwIfAborted = (signal) => {
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("Journal close aborted");
+};
+function awaitAbortable(operation, signal) {
+    if (signal === undefined)
+        return operation;
+    throwIfAborted(signal);
+    return new Promise((resolveOperation, rejectOperation) => {
+        let settled = false;
+        const settle = (continuation) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            continuation();
+        };
+        const onAbort = () => settle(() => {
+            rejectOperation(signal.reason ?? new Error("Journal close aborted"));
+        });
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        operation.then((value) => settle(() => resolveOperation(value)), (error) => settle(() => rejectOperation(error)));
+    });
+}
+async function parseLockOwner(lockDirectory, fileName, fileSystem) {
+    const path = join(lockDirectory, fileName);
+    try {
+        const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(path)));
+        if (fileName !== ownerFileName(owner.token))
+            throw new Error("owner token does not match filename");
+        return owner;
+    }
+    catch (error) {
+        throw new JournalLockCorruptionError(path, error);
+    }
+}
+export async function inspectJournalLock(options) {
+    const fileSystem = options.fileSystem ?? defaultJournalLockFileSystem;
+    const lockDirectory = join(options.directory, ".journal.lock");
+    const orphanGraceMs = options.orphanGraceMs ?? 30_000;
+    const now = options.now ?? (() => new Date());
+    const missingDuringOwnerRead = (error) => codeOf(error) === "ENOENT"
+        || (error instanceof Error && codeOf(error.cause) === "ENOENT");
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let names;
+        try {
+            names = (await fileSystem.readdir(lockDirectory)).map(String).sort();
+        }
+        catch (error) {
+            if (codeOf(error) === "ENOENT") {
+                return { status: "unlocked", detail: "lock directory does not exist" };
+            }
+            return { status: "corrupt", detail: `lock directory cannot be read: ${error.message}` };
+        }
+        if (names.length === 0) {
+            try {
+                const lockStat = await fileSystem.stat(lockDirectory);
+                const ageMs = now().valueOf() - lockStat.mtimeMs;
+                return ageMs < orphanGraceMs
+                    ? { status: "installing", detail: "lock owner installation is in progress" }
+                    : { status: "stale", detail: "empty lock directory exceeded the owner installation grace period" };
+            }
+            catch (error) {
+                if (codeOf(error) === "ENOENT" && attempt === 0)
+                    continue;
+                if (codeOf(error) === "ENOENT") {
+                    return { status: "unlocked", detail: "lock directory disappeared during inspection" };
+                }
+                return { status: "corrupt", detail: `empty lock directory cannot be inspected: ${error.message}` };
+            }
+        }
+        if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
+            return { status: "corrupt", detail: "lock directory must contain one owner" };
+        }
+        let owner;
+        try {
+            owner = await parseLockOwner(lockDirectory, names[0], fileSystem);
+        }
+        catch (error) {
+            if (attempt === 0 && missingDuringOwnerRead(error))
+                continue;
+            return { status: "corrupt", detail: error.message };
+        }
+        let inspection;
+        try {
+            const identity = await options.inspectIdentity(owner.pid);
+            inspection = identity === owner.processIdentity
+                ? {
+                    status: "owned",
+                    ownerPid: owner.pid,
+                    ownerAlive: true,
+                    detail: `owned by live process ${owner.pid}`,
+                }
+                : {
+                    status: "stale",
+                    ownerPid: owner.pid,
+                    ownerAlive: false,
+                    detail: `owner process ${owner.pid} is absent or its identity changed`,
+                };
+        }
+        catch (error) {
+            inspection = {
+                status: "corrupt",
+                ownerPid: owner.pid,
+                detail: `owner process cannot be inspected: ${error.message}`,
+            };
+        }
+        try {
+            const confirmedOwner = await parseLockOwner(lockDirectory, names[0], fileSystem);
+            const confirmedNames = (await fileSystem.readdir(lockDirectory)).map(String).sort();
+            const unchanged = JSON.stringify(confirmedOwner) === JSON.stringify(owner)
+                && JSON.stringify(confirmedNames) === JSON.stringify(names);
+            if (!unchanged && attempt === 0)
+                continue;
+            if (!unchanged)
+                return { status: "corrupt", detail: "lock snapshot changed during bounded inspection" };
+            return inspection;
+        }
+        catch (error) {
+            if (attempt === 0 && missingDuringOwnerRead(error))
+                continue;
+            if (missingDuringOwnerRead(error)) {
+                return { status: "corrupt", detail: "lock snapshot remained unstable after bounded inspection" };
+            }
+            return { status: "corrupt", detail: error.message };
+        }
+    }
+    return { status: "corrupt", detail: "lock snapshot remained unstable after bounded inspection" };
+}
 function processLeaseMap(registry) {
     return registry.leases;
 }
@@ -52,21 +195,29 @@ export function createJournalLease(options) {
     const registry = processLeaseMap(options.registry ?? defaultRegistry);
     const now = options.now ?? (() => new Date());
     const orphanGraceMs = options.orphanGraceMs ?? 30_000;
+    const journalPath = resolve(options.directory);
     const lockDirectory = join(options.directory, ".journal.lock");
     let attached = false;
     let status = "open";
-    const ownerFileName = (token) => `owner.${token}.json`;
-    const parseOwner = async (fileName) => {
-        const path = join(lockDirectory, fileName);
+    const cleanupReleasedDirectory = async (path) => {
         try {
-            const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(path)));
-            if (fileName !== ownerFileName(owner.token))
-                throw new Error("owner token does not match filename");
-            return owner;
+            await fileSystem.rm(path, { recursive: true, force: true });
+            await options.syncDirectory(options.directory);
         }
-        catch (error) {
-            throw new JournalLockCorruptionError(path, error);
+        catch { /* released tombstones never block ownership or reverse a committed close */ }
+    };
+    const cleanupReleasedDirectories = async () => {
+        let names;
+        try {
+            names = (await fileSystem.readdir(options.directory)).map(String).sort();
         }
+        catch {
+            return;
+        }
+        await Promise.all(names
+            .filter((name) => RELEASED_LOCK_PATTERN.test(name))
+            .slice(0, MAX_RELEASED_LOCK_CLEANUP)
+            .map((name) => cleanupReleasedDirectory(join(options.directory, name))));
     };
     const readOwner = async () => {
         let names;
@@ -81,7 +232,7 @@ export function createJournalLease(options) {
         if (names.length === 0) {
             const lockStat = await fileSystem.stat(lockDirectory);
             if (now().valueOf() - lockStat.mtimeMs < orphanGraceMs) {
-                throw new JournalLockedError("Execution journal lock owner installation is in progress");
+                throw new JournalLockedError("Execution journal lock owner installation is in progress", { journalPath });
             }
             try {
                 await fileSystem.rmdir(lockDirectory);
@@ -96,7 +247,7 @@ export function createJournalLease(options) {
         if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
             throw new JournalLockCorruptionError(lockDirectory, new Error("lock directory must contain one owner"));
         }
-        return { owner: await parseOwner(names[0]), fileName: names[0] };
+        return { owner: await parseLockOwner(lockDirectory, names[0], fileSystem), fileName: names[0] };
     };
     const validateInstalledOwner = async (lease) => {
         const observed = await readOwner();
@@ -151,9 +302,6 @@ export function createJournalLease(options) {
                         lockDirectorySynced: false,
                         executionsDirectorySynced: false,
                         releasing: false,
-                        ownerRemoved: false,
-                        lockDirectoryRemoved: false,
-                        releaseSynced: false,
                     };
                     registry.set(options.directory, lease);
                     attached = true;
@@ -169,7 +317,7 @@ export function createJournalLease(options) {
                     continue;
                 const identity = await options.inspectIdentity(observed.owner.pid);
                 if (identity === observed.owner.processIdentity) {
-                    throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`);
+                    throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`, { journalPath, ownerPid: observed.owner.pid });
                 }
                 await options.hooks?.beforeRemoveObservedOwner?.(observed.owner);
                 try {
@@ -196,37 +344,48 @@ export function createJournalLease(options) {
         }
     };
     const acquire = async () => {
-        if (status !== "open")
-            throw new JournalLockedError(`Journal lease is ${status}`);
+        if (status !== "open") {
+            throw new JournalLockedError(`Journal lease is ${status}`, { journalPath });
+        }
         if (attached) {
             const lease = registry.get(options.directory);
-            if (lease === undefined)
-                throw new JournalLockedError("In-process journal lease is missing");
+            if (lease === undefined) {
+                throw new JournalLockedError("In-process journal lease is missing", { journalPath });
+            }
             await finishInstall(lease);
             return;
         }
         const existing = registry.get(options.directory);
         if (existing !== undefined) {
-            if (existing.releasing)
-                throw new JournalLockedError("Journal lease release is pending");
+            if (existing.releasing) {
+                throw new JournalLockedError("Journal lease release is pending", {
+                    journalPath,
+                    ownerPid: existing.owner.pid,
+                });
+            }
             await finishInstall(existing);
             existing.refs += 1;
             attached = true;
             return;
         }
+        void cleanupReleasedDirectories();
         await install();
     };
-    const close = async () => {
+    const close = async (closeOptions = {}) => {
         if (status === "closed")
             return;
+        const signal = closeOptions.signal;
+        throwIfAborted(signal);
         if (!attached) {
             status = "closed";
             return;
         }
         const lease = registry.get(options.directory);
-        if (lease === undefined)
-            throw new JournalLockedError("In-process journal lease is missing");
+        if (lease === undefined) {
+            throw new JournalLockedError("In-process journal lease is missing", { journalPath });
+        }
         if (status === "open" && lease.refs > 1) {
+            throwIfAborted(signal);
             lease.refs -= 1;
             attached = false;
             status = "closed";
@@ -234,28 +393,28 @@ export function createJournalLease(options) {
         }
         status = "closing";
         lease.releasing = true;
-        if (!lease.ownerRemoved) {
-            await fileSystem.unlink(join(lockDirectory, lease.ownerFile));
-            lease.ownerRemoved = true;
-        }
-        if (!lease.lockDirectoryRemoved) {
-            await fileSystem.rmdir(lockDirectory);
-            lease.lockDirectoryRemoved = true;
-        }
-        if (!lease.releaseSynced) {
-            await options.syncDirectory(options.directory);
-            lease.releaseSynced = true;
-        }
+        await awaitAbortable((async () => {
+            await validateInstalledOwner(lease);
+            await options.hooks?.beforeReleaseOwner?.(lease.owner, {
+                ...(signal === undefined ? {} : { signal }),
+            });
+            await validateInstalledOwner(lease);
+        })(), signal);
+        throwIfAborted(signal);
+        const releasedDirectory = join(options.directory, releasedLockName(lease.owner.token));
+        fileSystem.renameSync(lockDirectory, releasedDirectory);
         lease.refs -= 1;
         registry.delete(options.directory);
         attached = false;
         status = "closed";
+        void cleanupReleasedDirectory(releasedDirectory);
     };
     return {
         acquire,
         assertUsable: () => {
-            if (status !== "open")
-                throw new JournalLockedError(`Execution journal lease is ${status}`);
+            if (status !== "open") {
+                throw new JournalLockedError(`Execution journal lease is ${status}`, { journalPath });
+            }
         },
         close,
     };

package/dist/execution-journal.js

@@ -558,7 +558,7 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                 return { kind: "created", ...entry };
             });
         },
-        startGuarded: async (executionId, processStartedAt, startDormant) => {
+        startGuarded: async (executionId, processStartedAt, startDormant, hooks) => {
             validateExecutionId(executionId);
             TimestampSchema.parse(processStartedAt);
             return serialized(async () => {
@@ -567,9 +567,21 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                     return { kind: "existing", entry: await confirmDurable(entry) };
                 }
                 const dormant = await startDormant();
+                let abortPromise = null;
+                const abort = () => {
+                    if (abortPromise === null) {
+                        try {
+                            abortPromise = Promise.resolve(dormant.abort());
+                        }
+                        catch (error) {
+                            abortPromise = Promise.reject(error);
+                        }
+                    }
+                    return abortPromise;
+                };
                 const abortWith = async (error) => {
                     try {
-                        await dormant.abort();
+                        await abort();
                     }
                     catch (abortError) {
                         throw new AggregateError([error, abortError], "Dormant runtime abort failed");
@@ -591,6 +603,9 @@ export function createExecutionJournal(agentsRoot, options = {}) {
                     });
                     await writeRecord(updated);
                     try {
+                        const gate = hooks?.beforeRelease?.({ entry: updated, handle: dormant, abort });
+                        if (gate !== undefined)
+                            await gate;
                         await dormant.release();
                     }
                     catch (error) {
@@ -671,8 +686,31 @@ export function createExecutionJournal(agentsRoot, options = {}) {
             }
         }),
         prune: async () => serialized(pruneInternal),
-        close: async () => {
-            await runSerialized(directory, lease.close);
+        close: async (closeOptions = {}) => {
+            const signal = closeOptions.signal;
+            let started = false;
+            const closing = runSerialized(directory, async () => {
+                started = true;
+                if (signal?.aborted)
+                    throw signal.reason ?? new Error("Journal close aborted");
+                await lease.close(closeOptions);
+            });
+            if (signal === undefined)
+                return closing;
+            await new Promise((resolveClose, rejectClose) => {
+                const settle = (settler) => {
+                    signal.removeEventListener("abort", onAbort);
+                    settler();
+                };
+                const onAbort = () => {
+                    if (!started)
+                        settle(() => rejectClose(signal.reason ?? new Error("Journal close aborted")));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+                closing.then(() => settle(resolveClose), (error) => settle(() => rejectClose(error)));
+            });
         },
     };
 }

package/dist/execution-protocol.js

@@ -122,6 +122,7 @@ export const ExecutionStartSchema = z.object({
         threadId: z.string().min(1).optional(),
         wakeMessageId: z.string().min(1).optional(),
         externalResponseSessionId: ExecutionIdSchema.optional(),
+        answerStream: z.boolean().optional(),
         attachments: z.array(ExecutionAttachmentSchema).max(20).optional(),
     }).strict(),
     reporting: z.object({
@@ -222,6 +223,7 @@ const RawExecutionCompletedSchema = z.object({
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),
+    externalAnswer: z.string().min(1).optional(),
     boundImDecision: z.enum(["notify", "silent"]).optional(),
     usage: ExecutionUsageSchema.optional(),
     startedAt: TimestampSchema,

package/dist/execution-recovery.js

@@ -0,0 +1,95 @@
+import { join, resolve } from "node:path";
+import { JournalLockedError } from "./execution-journal.js";
+import { DaemonAlreadyRunningError } from "./daemon-startup-error.js";
+export async function reconcileExecutionJournal(journal, dependencies) {
+    try {
+        await journal.reconcileAfterRestart();
+    }
+    catch (error) {
+        const agentsRoot = resolve(dependencies.agentsRoot);
+        const errorRecord = typeof error === "object" && error !== null
+            ? error
+            : {};
+        const journalPath = typeof errorRecord.journalPath === "string"
+            ? resolve(errorRecord.journalPath)
+            : join(agentsRoot, ".crew", "executions");
+        const ownerPid = typeof errorRecord.ownerPid === "number" ? errorRecord.ownerPid : undefined;
+        const errorType = error instanceof Error ? error.name : typeof error;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const alreadyRunning = error instanceof JournalLockedError && ownerPid !== undefined;
+        const diagnostics = {
+            server_url: dependencies.serverUrl,
+            agents_root: agentsRoot,
+            journal_path: journalPath,
+            owner_pid: ownerPid,
+            ...(dependencies.profileName === undefined ? {} : { profile_name: dependencies.profileName }),
+            error_type: errorType,
+            error_message: errorMessage,
+        };
+        const failureEvent = alreadyRunning ? "daemon.already_running" : "execution.recovery_failed";
+        const failureMessage = alreadyRunning ? "daemon 已在运行" : "execution journal 恢复失败";
+        const failureLevel = alreadyRunning ? "WARN" : "ERROR";
+        dependencies.log(failureEvent, failureMessage, {
+            level: failureLevel,
+            ...diagnostics,
+        });
+        dependencies.writeStderr(`${JSON.stringify({
+            level: failureLevel,
+            event_type: failureEvent,
+            message: failureMessage,
+            ...diagnostics,
+        })}\n`);
+        const reportCleanupFailure = (stage, cleanupError) => {
+            const cleanupErrorType = cleanupError instanceof Error ? cleanupError.name : typeof cleanupError;
+            const cleanupErrorMessage = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+            const cleanupDiagnostics = {
+                server_url: dependencies.serverUrl,
+                agents_root: agentsRoot,
+                journal_path: journalPath,
+                owner_pid: ownerPid,
+                cleanup_stage: stage,
+                error_type: cleanupErrorType,
+                error_message: cleanupErrorMessage,
+                ...(alreadyRunning
+                    ? { startup_error_type: errorType, startup_error_message: errorMessage }
+                    : { recovery_error_type: errorType, recovery_error_message: errorMessage }),
+            };
+            const cleanupEvent = alreadyRunning
+                ? "daemon.already_running_cleanup_failed"
+                : "execution.recovery_cleanup_failed";
+            const cleanupMessage = alreadyRunning
+                ? "daemon 重复启动后的清理失败"
+                : "execution journal 恢复失败后的清理失败";
+            dependencies.log(cleanupEvent, cleanupMessage, { level: "ERROR", ...cleanupDiagnostics });
+            dependencies.writeStderr(`${JSON.stringify({
+                level: "ERROR",
+                event_type: cleanupEvent,
+                message: cleanupMessage,
+                ...cleanupDiagnostics,
+            })}\n`);
+        };
+        try {
+            await dependencies.flush();
+        }
+        catch (cleanupError) {
+            reportCleanupFailure("slog_flush", cleanupError);
+        }
+        try {
+            await journal.close();
+        }
+        catch (cleanupError) {
+            reportCleanupFailure("journal_close", cleanupError);
+        }
+        if (alreadyRunning) {
+            throw new DaemonAlreadyRunningError({
+                ownerPid,
+                agentsRoot,
+                journalPath,
+                serverUrl: dependencies.serverUrl,
+                ...(dependencies.profileName === undefined ? {} : { profileName: dependencies.profileName }),
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}