@nowcrew/daemon 0.5.12 → 0.5.13

package/dist/execution-protocol.js

@@ -0,0 +1,310 @@
+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"]).optional(),
+    }).passthrough().optional(),
+    scheduledRun: z.object({
+        jobId: z.string().min(1),
+        runId: z.string().min(1),
+        title: z.string().optional(),
+        outputPolicy: 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 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(),
+    }).strict(),
+    reporting: z.object({
+        captureFinal: z.boolean(),
+        streamActivity: z.boolean(),
+        streamConsole: z.boolean(),
+    }).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 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(),
+    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(),
+    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,
+]);
+const RawDaemonToServerExecutionFrameSchema = z.discriminatedUnion("type", [
+    ExecutionAcceptedSchema,
+    ExecutionRejectedSchema,
+    ExecutionStartedSchema,
+    ExecutionActivitySchema,
+    ExecutionConsoleSchema,
+    RawExecutionCompletedSchema,
+    ExecutionSnapshotSchema,
+]);
+export const DaemonToServerExecutionFrameSchema = RawDaemonToServerExecutionFrameSchema.superRefine((frame, ctx) => {
+    if (frame.type === "execution:completed")
+        validateCompletionSemantics(frame, ctx);
+});