@nowcrew/daemon 0.5.26 → 0.5.28

package/dist/execution-protocol.js

@@ -1,342 +0,0 @@
-import { z } from "zod";
-const ExecutionIdSchema = z.string().uuid();
-const ProtocolVersionSchema = z.literal(1);
-const TimestampSchema = z.string().datetime({ offset: true });
-export const MAX_PG_INTEGER = 2_147_483_647;
-const MIN_SIGNED_32_INTEGER = -2_147_483_648;
-const SequenceSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
-const TokenCountSchema = z.number().int().min(0).max(MAX_PG_INTEGER);
-const ExitCodeSchema = z.number().int().min(MIN_SIGNED_32_INTEGER).max(MAX_PG_INTEGER);
-const RuntimeSchema = z.enum(["claude", "codex", "kimi"]);
-const UnsafePathCharacterSchema = /[\p{Cc}<>:"/\\|?*]/u;
-const WindowsReservedNameSchema = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
-const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."
-    && handle !== ".."
-    && !UnsafePathCharacterSchema.test(handle)
-    && !WindowsReservedNameSchema.test(handle)
-    && !handle.endsWith(".")
-    && !handle.endsWith(" ")
-    && Buffer.byteLength(handle, "utf8") <= 255, "agent handle must be a cross-platform safe filesystem component");
-export const ReasoningSchema = z.enum([
-    "default",
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-]);
-export const PermissionSchema = z.enum([
-    "local_default",
-    "sandboxed",
-    "workspace_write",
-    "full_access",
-]);
-export const EffectivePermissionSchema = z.enum([
-    "sandboxed",
-    "workspace_write",
-    "full_access",
-]);
-export const LegacyAgentStartSchema = z.object({
-    type: z.literal("agent:start"),
-    agentHandle: z.string().min(1),
-    channelId: z.string().min(1),
-    reason: z.string().optional(),
-    wake: z.object({
-        seq: z.number().int().nonnegative().optional(),
-        content: z.string().optional(),
-        senderHandle: z.string().optional(),
-        threadId: z.string().optional(),
-        origin: z.enum(["wecom", "feishu"]).optional(),
-    }).passthrough().optional(),
-    scheduledRun: z.object({
-        jobId: z.string().min(1),
-        runId: z.string().min(1),
-        title: z.string().optional(),
-        outputPolicy: z.unknown().optional(),
-        externalNotificationPolicy: z.unknown().optional(),
-    }).passthrough().optional(),
-    silent: z.boolean().optional(),
-}).passthrough();
-export const RejectionReasonSchema = z.enum([
-    "invalid_spec",
-    "runtime_unavailable",
-    "capability_missing",
-    "local_policy_denied",
-    "resource_limit",
-]);
-export const ActivityKindSchema = z.enum([
-    "working",
-    "thinking",
-    "reading",
-    "sending",
-    "claiming",
-    "checking",
-    "done",
-    "error",
-]);
-export const ConsoleStreamSchema = z.enum([
-    "system",
-    "thinking",
-    "text",
-    "tool",
-    "tool_result",
-    "result",
-    "error",
-]);
-export const ExecutionAttachmentSchema = z.object({
-    id: z.string().min(1).max(200),
-    filename: z.string().min(1).max(255),
-    mime: z.string().min(1).max(200),
-    sizeBytes: z.number().int().nonnegative().max(25 * 1024 * 1024),
-}).strict();
-export const ExecutionStartSchema = z.object({
-    type: z.literal("execution:start"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    agent: z.object({
-        id: z.string().min(1),
-        handle: AgentHandleSchema,
-    }).strict(),
-    workspace: z.object({
-        taskKey: z.string().min(1).max(200),
-        resumeKey: z.string().min(1).max(200).optional(),
-    }).strict(),
-    instructions: z.object({
-        language: z.enum(["zh", "en"]),
-        systemPrompt: z.string(),
-        wakePrompt: z.string(),
-    }).strict(),
-    runtime: z.object({
-        name: RuntimeSchema,
-        model: z.string().optional(),
-        reasoning: ReasoningSchema.optional(),
-        timeoutMs: z.number().int().positive().optional(),
-    }).strict(),
-    permissions: z.object({
-        requested: PermissionSchema,
-    }).strict(),
-    context: z.object({
-        channelId: z.string().min(1),
-        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({
-        captureFinal: z.boolean(),
-        streamActivity: z.boolean(),
-        streamConsole: z.boolean(),
-        allowBoundImDecision: z.boolean().optional(),
-    }).strict(),
-}).strict();
-export const ExecutionCancelSchema = z.object({
-    type: z.literal("execution:cancel"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-}).strict();
-export const ExecutionSyncSchema = z.object({
-    type: z.literal("execution:sync"),
-    protocolVersion: ProtocolVersionSchema,
-    reqId: z.string().min(1).max(200),
-}).strict();
-export const ExecutionCompletionAckSchema = z.object({
-    type: z.literal("execution:completion-ack"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-}).strict();
-export const ExecutionEventAckSchema = z.object({
-    type: z.literal("execution:event-ack"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    kind: z.enum(["activity", "console"]),
-    seq: SequenceSchema,
-}).strict();
-export const ExecutionAcceptedSchema = z.object({
-    type: z.literal("execution:accepted"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    state: z.enum(["queued", "ready"]),
-    effectivePermission: EffectivePermissionSchema,
-    at: TimestampSchema,
-}).strict();
-export const ExecutionRejectedSchema = z.object({
-    type: z.literal("execution:rejected"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    reason: RejectionReasonSchema,
-    message: z.string().optional(),
-    at: TimestampSchema,
-}).strict();
-export const ExecutionStartedSchema = z.object({
-    type: z.literal("execution:started"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    at: TimestampSchema,
-}).strict();
-export const ExecutionActivitySchema = z.object({
-    type: z.literal("execution:activity"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    activity: ActivityKindSchema,
-    detail: z.string(),
-    seq: SequenceSchema,
-    at: TimestampSchema,
-}).strict();
-export const ExecutionConsoleSchema = z.object({
-    type: z.literal("execution:console"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    stream: ConsoleStreamSchema,
-    text: z.string(),
-    payload: z.record(z.string(), z.unknown()).optional(),
-    seq: SequenceSchema,
-    at: TimestampSchema,
-}).strict();
-export const ExecutionOutputSchema = z.object({
-    type: z.literal("execution:output"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    channel: z.literal("external_answer"),
-    text: z.string().min(1),
-    seq: SequenceSchema,
-    at: TimestampSchema,
-}).strict();
-export const ExecutionUsageSchema = z.object({
-    inputTokens: TokenCountSchema,
-    outputTokens: TokenCountSchema,
-    cacheReadTokens: TokenCountSchema,
-    cacheCreationTokens: TokenCountSchema,
-    costUsd: z.number().finite().nonnegative().optional(),
-}).strict();
-const RawExecutionCompletedSchema = z.object({
-    type: z.literal("execution:completed"),
-    protocolVersion: ProtocolVersionSchema,
-    executionId: ExecutionIdSchema,
-    outcome: z.enum(["succeeded", "failed", "cancelled"]),
-    exitCode: ExitCodeSchema.optional(),
-    terminationSignal: z.string().min(1).optional(),
-    errorCode: z.string().min(1).optional(),
-    errorMessage: z.string().min(1).optional(),
-    runtime: RuntimeSchema,
-    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,
-    finishedAt: TimestampSchema,
-}).strict();
-function validateCompletionSemantics(completion, ctx) {
-    const addIssue = (message, path) => {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message, path });
-    };
-    if (Date.parse(completion.finishedAt) < Date.parse(completion.startedAt)) {
-        addIssue("finishedAt must be greater than or equal to startedAt", ["finishedAt"]);
-    }
-    if (completion.outcome === "succeeded") {
-        if (completion.exitCode !== 0) {
-            addIssue("succeeded completion requires exitCode 0", ["exitCode"]);
-        }
-        for (const field of ["terminationSignal", "errorCode", "errorMessage"]) {
-            if (completion[field] !== undefined) {
-                addIssue(`succeeded completion cannot include ${field}`, [field]);
-            }
-        }
-        return;
-    }
-    const hasNonExitDiagnostic = completion.terminationSignal !== undefined
-        || completion.errorCode !== undefined
-        || completion.errorMessage !== undefined;
-    const hasDiagnostic = completion.outcome === "failed"
-        ? (completion.exitCode !== undefined && completion.exitCode !== 0) || hasNonExitDiagnostic
-        : completion.exitCode !== undefined || hasNonExitDiagnostic;
-    if (!hasDiagnostic) {
-        addIssue(`${completion.outcome} completion requires a diagnostic fact`, ["outcome"]);
-    }
-}
-export const ExecutionCompletedSchema = RawExecutionCompletedSchema.superRefine(validateCompletionSemantics);
-const SnapshotAcceptedEntrySchema = z.object({
-    executionId: ExecutionIdSchema,
-    state: z.literal("accepted"),
-    updatedAt: TimestampSchema,
-}).strict();
-const SnapshotRunningEntrySchema = z.object({
-    executionId: ExecutionIdSchema,
-    state: z.literal("running"),
-    updatedAt: TimestampSchema,
-}).strict();
-const SnapshotCompletedEntrySchema = z.object({
-    executionId: ExecutionIdSchema,
-    state: z.literal("completed"),
-    completion: ExecutionCompletedSchema,
-    updatedAt: TimestampSchema,
-}).strict();
-const SnapshotInterruptedEntrySchema = z.object({
-    executionId: ExecutionIdSchema,
-    state: z.literal("interrupted"),
-    completion: ExecutionCompletedSchema,
-    updatedAt: TimestampSchema,
-}).strict();
-const RawExecutionSnapshotEntrySchema = z.discriminatedUnion("state", [
-    SnapshotAcceptedEntrySchema,
-    SnapshotRunningEntrySchema,
-    SnapshotCompletedEntrySchema,
-    SnapshotInterruptedEntrySchema,
-]);
-export const ExecutionSnapshotEntrySchema = RawExecutionSnapshotEntrySchema.superRefine((entry, ctx) => {
-    if ((entry.state === "completed" || entry.state === "interrupted")
-        && entry.executionId !== entry.completion.executionId) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "snapshot entry executionId must match completion executionId",
-            path: ["completion", "executionId"],
-        });
-    }
-    if (entry.state === "interrupted") {
-        if (entry.completion.outcome !== "failed") {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "interrupted snapshot entry requires a failed completion",
-                path: ["completion", "outcome"],
-            });
-        }
-        if (entry.completion.errorCode !== "interrupted") {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: "interrupted snapshot entry requires errorCode interrupted",
-                path: ["completion", "errorCode"],
-            });
-        }
-    }
-});
-export const ExecutionSnapshotSchema = z.object({
-    type: z.literal("execution:snapshot"),
-    protocolVersion: ProtocolVersionSchema,
-    reqId: z.string().min(1).max(200),
-    entries: z.array(ExecutionSnapshotEntrySchema),
-}).strict();
-export const ServerToDaemonExecutionFrameSchema = z.discriminatedUnion("type", [
-    ExecutionStartSchema,
-    ExecutionCancelSchema,
-    ExecutionSyncSchema,
-    ExecutionCompletionAckSchema,
-    ExecutionEventAckSchema,
-]);
-const RawDaemonToServerExecutionFrameSchema = z.discriminatedUnion("type", [
-    ExecutionAcceptedSchema,
-    ExecutionRejectedSchema,
-    ExecutionStartedSchema,
-    ExecutionActivitySchema,
-    ExecutionConsoleSchema,
-    ExecutionOutputSchema,
-    RawExecutionCompletedSchema,
-    ExecutionSnapshotSchema,
-]);
-export const DaemonToServerExecutionFrameSchema = RawDaemonToServerExecutionFrameSchema.superRefine((frame, ctx) => {
-    if (frame.type === "execution:completed")
-        validateCompletionSemantics(frame, ctx);
-});

package/dist/execution-recovery.js

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