@nowcrew/daemon 0.5.14 → 0.5.16

package/dist/runtimes/kimi-acp-runner.js

@@ -0,0 +1,264 @@
+import { once } from "node:events";
+import { parseArgs } from "node:util";
+import { Readable, Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+const ERROR_MESSAGE_CAP = 2_000;
+const PROBE_TIMEOUT_MS = 5_000;
+function jsonLine(event) {
+    if (process.stdout.write(`${JSON.stringify(event)}\n`))
+        return Promise.resolve();
+    return once(process.stdout, "drain").then(() => undefined);
+}
+function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return [part.text];
+        }
+        if (part && typeof part === "object" && "content" in part
+            && part.content && typeof part.content === "object"
+            && "type" in part.content && part.content.type === "text"
+            && "text" in part.content && typeof part.content.text === "string") {
+            return [part.content.text];
+        }
+        return [];
+    }).join("\n");
+}
+/** Translate stable ACP updates into daemon-owned NDJSON, without exposing thought chunks. */
+export function mapKimiAcpUpdate(update) {
+    if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+        return [{ type: "kimi.acp.text_delta", text: update.content.text }];
+    }
+    if (update.sessionUpdate === "tool_call") {
+        return [{
+                type: "kimi.acp.tool_call",
+                id: update.toolCallId,
+                title: update.title,
+                ...(update.kind === undefined ? {} : { kind: update.kind }),
+                ...(update.status === undefined ? {} : { status: update.status }),
+                ...(update.rawInput === undefined ? {} : { input: update.rawInput }),
+            }];
+    }
+    if (update.sessionUpdate === "tool_call_update") {
+        const output = textContent(update.content);
+        return [{
+                type: "kimi.acp.tool_result",
+                id: update.toolCallId,
+                ...(update.status === undefined ? {} : { status: update.status }),
+                ...(output ? { content: output } : {}),
+            }];
+    }
+    return [];
+}
+function safeErrorMessage(error, prompt) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
+    return redacted.slice(0, ERROR_MESSAGE_CAP);
+}
+/** Full access may approve an operation, but it must never fabricate an answer to an agent question. */
+export function selectKimiPermission(params) {
+    const allowOnce = params.options.filter((option) => option.kind === "allow_once");
+    if (params.toolCall.title === "AskUserQuestion" || allowOnce.length > 1) {
+        return { outcome: { outcome: "cancelled" } };
+    }
+    const allowed = allowOnce[0]
+        ?? (params.options.filter((option) => option.kind === "allow_always").length === 1
+            ? params.options.find((option) => option.kind === "allow_always")
+            : undefined);
+    return allowed === undefined
+        ? { outcome: { outcome: "cancelled" } }
+        : { outcome: { outcome: "selected", optionId: allowed.optionId } };
+}
+async function readPrompt() {
+    process.stdin.setEncoding("utf8");
+    let prompt = "";
+    for await (const chunk of process.stdin)
+        prompt += String(chunk);
+    if (!prompt)
+        throw new Error("Kimi ACP prompt is empty");
+    return prompt;
+}
+async function stopChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = once(child, "close").then(() => undefined);
+    child.kill("SIGTERM");
+    let timer;
+    const graceful = await Promise.race([
+        closed.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (!graceful && child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+        await closed;
+    }
+}
+/** A help banner is insufficient: Kimi's authenticate RPC re-checks its token without creating a session. */
+export async function probeKimiAcp(options, spawnProcess = spawn) {
+    const child = spawnProcess(options.bin, ["acp"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null)
+        return false;
+    child.stderr.resume();
+    const app = client({ name: "nowcrew-daemon-kimi-probe" })
+        .onRequest(methods.client.session.requestPermission, () => ({
+        outcome: { outcome: "cancelled" },
+    }))
+        .onNotification(methods.client.session.update, () => undefined);
+    let timeout;
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connected = app.connectWith(stream, async (context) => {
+            const initialized = await context.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            const authMethod = initialized.authMethods?.[0];
+            if (authMethod !== undefined) {
+                await context.request(methods.agent.authenticate, { methodId: authMethod.id });
+            }
+            return true;
+        });
+        const result = await Promise.race([
+            connected,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => {
+                    void stopChild(child);
+                    resolve(false);
+                }, PROBE_TIMEOUT_MS);
+            }),
+        ]);
+        return result;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        await stopChild(child);
+    }
+}
+export async function runKimiAcp(options) {
+    const prompt = await readPrompt();
+    const child = spawn(options.bin, ["acp"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null) {
+        throw new Error("Kimi ACP process did not expose stdio");
+    }
+    child.stderr.pipe(process.stderr, { end: false });
+    let context = null;
+    let sessionId = null;
+    let cancelling = false;
+    const cancel = async () => {
+        if (cancelling)
+            return;
+        cancelling = true;
+        if (context !== null && sessionId !== null) {
+            await context.notify(methods.agent.session.cancel, { sessionId }).catch(() => undefined);
+        }
+        await stopChild(child);
+    };
+    const onSignal = () => {
+        void cancel().finally(() => process.exit(130));
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+    const app = client({ name: "nowcrew-daemon-kimi" })
+        .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
+        .onNotification(methods.client.session.update, async ({ params }) => {
+        for (const event of mapKimiAcpUpdate(params.update))
+            await jsonLine(event);
+    });
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const result = await app.connectWith(stream, async (nextContext) => {
+            context = nextContext;
+            const initialized = await nextContext.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            if (process.env.CREW_KIMI_ACP_DEBUG === "1") {
+                process.stderr.write(`Kimi ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
+            }
+            const authMethod = initialized.authMethods?.[0];
+            if (authMethod !== undefined) {
+                await nextContext.request(methods.agent.authenticate, { methodId: authMethod.id });
+            }
+            const session = await nextContext.request(methods.agent.session.new, {
+                cwd: process.cwd(),
+                mcpServers: [],
+            });
+            sessionId = session.sessionId;
+            if (options.model) {
+                await nextContext.request(methods.agent.session.setConfigOption, {
+                    sessionId,
+                    configId: "model",
+                    value: options.model,
+                });
+            }
+            return nextContext.request(methods.agent.session.prompt, {
+                sessionId,
+                prompt: [{ type: "text", text: prompt }],
+            });
+        });
+        const usage = result.usage;
+        await jsonLine({
+            type: "turn.completed",
+            stop_reason: result.stopReason,
+            ...(usage === undefined || usage === null ? {} : {
+                usage: {
+                    input_tokens: usage.inputTokens,
+                    output_tokens: usage.outputTokens,
+                    cache_read_input_tokens: usage.cachedReadTokens ?? 0,
+                    cache_creation_input_tokens: usage.cachedWriteTokens ?? 0,
+                },
+            }),
+        });
+        return result.stopReason === "end_turn" ? 0 : result.stopReason === "cancelled" ? 130 : 1;
+    }
+    catch (error) {
+        process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
+        return 1;
+    }
+    finally {
+        process.off("SIGTERM", onSignal);
+        process.off("SIGINT", onSignal);
+        await stopChild(child);
+    }
+}
+function optionsFromArgv(argv) {
+    const { values } = parseArgs({
+        args: [...argv],
+        options: {
+            bin: { type: "string" },
+            model: { type: "string" },
+        },
+    });
+    if (!values.bin)
+        throw new Error("--bin is required");
+    return { bin: values.bin, ...(values.model ? { model: values.model } : {}) };
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runKimiAcp(optionsFromArgv(process.argv.slice(2)))
+        .then((code) => { process.exitCode = code; })
+        .catch((error) => {
+        process.stderr.write(`Kimi ACP runner failed: ${safeErrorMessage(error, "")}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/runtimes/kimi.js

@@ -10,6 +10,15 @@
  */
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
+// Windows CreateProcess receives one UTF-16 command line. Reserve room for the executable, flags,
+// model and cmd shim quoting instead of relying on the theoretical 32767-character ceiling.
+export const KIMI_LEGACY_PROMPT_MAX_UTF16 = 28_000;
+export function assertKimiLegacyPromptFits(prompt, platform = process.platform) {
+    if (platform !== "win32" || prompt.length <= KIMI_LEGACY_PROMPT_MAX_UTF16)
+        return;
+    throw new Error(`Kimi legacy prompt exceeds the Windows argv limit (${prompt.length}/${KIMI_LEGACY_PROMPT_MAX_UTF16}); `
+        + "shorten the prompt (protocol-v1 remains disabled on Windows until Job Object ownership is available)");
+}
 // Kimi Code 思考强度档位(kimi-code 0.23.0 实测+源码):无 CLI 参数,
 // 由 runner 经 KIMI_MODEL_THINKING_EFFORT env 注入;白名单外的值不注。
 export const KIMI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -24,6 +33,7 @@ export function buildKimiArgs(input) {
     return args;
 }
 export function spawnKimi(input) {
+    assertKimiLegacyPromptFits(input.wakePrompt);
     // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
     return spawn(input.bin, buildKimiArgs(input), {
         cwd: input.cwd,

package/dist/scheduled-report.js

@@ -1,12 +1,16 @@
 export function normalizeScheduledPolicy(value) {
     return value === "always_report" ? "always_report" : "silent_unless_report";
 }
+export function normalizeExternalNotificationPolicy(value) {
+    return value === "agent_decides" ? "agent_decides" : "disabled";
+}
 export function normalizeScheduledContext(input) {
     return {
         jobId: input.jobId,
         runId: input.runId,
         title: input.title?.trim() || "Scheduled job",
         outputPolicy: normalizeScheduledPolicy(input.outputPolicy),
+        externalNotificationPolicy: normalizeExternalNotificationPolicy(input.externalNotificationPolicy),
     };
 }
 export async function deliverScheduledReport(input) {

package/dist/scheduled-run-report.js

@@ -27,6 +27,7 @@ export function reportAgentRunComplete(socket, input, log) {
         exitCode: input.exitCode,
         ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
         ...(input.originDecision ? { originDecision: input.originDecision } : {}),
+        ...(input.contextUpToSeq !== undefined ? { contextUpToSeq: input.contextUpToSeq } : {}),
         ...(input.runtime ? { runtime: input.runtime } : {}),
         ...(input.model !== undefined ? { model: input.model } : {}),
         ...(input.resumed !== undefined ? { resumed: input.resumed } : {}),

package/dist/serve.js

@@ -8,7 +8,7 @@ import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, DAEMON_CAPABILITIES, EXECUTION_PROTOCOL } from "./machine-info.js";
+import { collectMachineHello, DAEMON_CAPABILITIES, EXECUTION_PROTOCOL, } from "./machine-info.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
 import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
@@ -18,8 +18,10 @@ import { formatDaemonLogLine } from "./log-format.js";
 import { reportAgentRunComplete } from "./scheduled-run-report.js";
 import { runWithOriginDecisionGuard } from "./origin-decision.js";
 import { createExecutionJournal } from "./execution-journal.js";
+import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
 import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
 import { hashExecutionSpec, runExecution, } from "./execution-runner.js";
+import { executionBackendCapability } from "./execution-backend.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -28,7 +30,7 @@ const ACTIVITY_MAP = {
 };
 export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform) {
     const query = new URLSearchParams({ key: machineToken });
-    if (runtimePlatform !== "win32") {
+    if (executionBackendCapability(runtimePlatform).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
@@ -43,8 +45,9 @@ export function serve(config, opts = {}) {
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
     const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
+    const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
-    let detectedRuntimes = [];
+    let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
     const executionReady = executionJournal.reconcileAfterRestart().then(() => true, (error) => {
         dslog("execution.recovery_failed", "execution journal 恢复失败", {
@@ -66,6 +69,26 @@ export function serve(config, opts = {}) {
         }
         catch { /* reconnect/sync replays durable lifecycle */ }
     };
+    const reportExecutionFrame = async (frame) => {
+        if (frame.type === "execution:activity" || frame.type === "execution:console") {
+            try {
+                await executionTelemetry.append(frame);
+            }
+            catch (error) {
+                dslog("execution.telemetry_journal_failed", "execution telemetry 持久化失败", {
+                    level: "ERROR", execution_id: frame.executionId,
+                    error_message: error.message,
+                });
+                throw error;
+            }
+        }
+        safeExecutionSend(frame);
+    };
+    const replayExecutionTelemetry = async () => {
+        const frames = await executionTelemetry.replay();
+        for (const frame of frames)
+            safeExecutionSend(frame);
+    };
     const snapshotEntry = (entry) => {
         if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
             return { executionId: entry.executionId, state: entry.state, completion: entry.completion, updatedAt: entry.updatedAt };
@@ -238,7 +261,7 @@ export function serve(config, opts = {}) {
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
             const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits);
-            runtimeFacts = helloPromise.then((hello) => hello.runtimes, (error) => {
+            runtimeFacts = helloPromise.then((hello) => hello.executionRuntimes, (error) => {
                 dslog("execution.runtime_detection_failed", "runtime 探测失败", {
                     level: "ERROR", error_message: error.message,
                 });
@@ -246,16 +269,21 @@ export function serve(config, opts = {}) {
             });
             void helloPromise
                 .then((hello) => {
-                detectedRuntimes = hello.runtimes;
+                detectedExecutionRuntimes = hello.executionRuntimes;
                 try {
                     ws?.send(JSON.stringify(hello));
-                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · runtimes=[${hello.runtimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
+                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
                 }
                 catch { /* 非 OPEN,忽略 */ }
             })
                 .catch(() => { });
             opts.onOpen?.(ws);
             void executionReady.then((ready) => ready ? sendSnapshot(`reconnect-${randomUUID()}`) : undefined);
+            void replayExecutionTelemetry().catch((error) => {
+                dslog("execution.telemetry_replay_failed", "execution telemetry 重放失败", {
+                    level: "ERROR", error_message: error.message,
+                });
+            });
         });
         ws.on("message", async (data) => {
             let decoded;
@@ -292,6 +320,15 @@ export function serve(config, opts = {}) {
                         await executionJournal.acknowledgeCompletion(frame.executionId).catch(() => { });
                         return;
                     }
+                    if (frame.type === "execution:event-ack") {
+                        await executionTelemetry.acknowledge(frame.executionId, frame.kind, frame.seq).catch((error) => {
+                            dslog("execution.telemetry_ack_failed", "execution telemetry ACK 处理失败", {
+                                level: "ERROR", execution_id: frame.executionId,
+                                error_message: error.message,
+                            });
+                        });
+                        return;
+                    }
                     if (frame.type === "execution:cancel") {
                         if (!knownExecutionHashes.has(frame.executionId)
                             && !executionRuns.has(frame.executionId)
@@ -352,7 +389,7 @@ export function serve(config, opts = {}) {
                     let availableRuntimes;
                     try {
                         availableRuntimes = opts.execution?.availableRuntimes?.()
-                            ?? await (runtimeFacts ?? Promise.resolve(detectedRuntimes));
+                            ?? await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes));
                     }
                     catch (error) {
                         reservation.release();
@@ -373,7 +410,7 @@ export function serve(config, opts = {}) {
                             availableRuntimes,
                             ...reservation.facts,
                         },
-                        report: safeExecutionSend,
+                        report: reportExecutionFrame,
                         ...(reservation.state === undefined ? {} : {
                             slot: { state: reservation.state, ready: reservation.ready },
                         }),
@@ -478,6 +515,9 @@ export function serve(config, opts = {}) {
                     ...(msg.scheduledRun.outputPolicy !== undefined
                         ? { outputPolicy: msg.scheduledRun.outputPolicy }
                         : {}),
+                    ...(msg.scheduledRun.externalNotificationPolicy !== undefined
+                        ? { externalNotificationPolicy: msg.scheduledRun.externalNotificationPolicy }
+                        : {}),
                 })
                 : null;
             const threadId = msg.wake?.threadId;
@@ -582,7 +622,7 @@ export function serve(config, opts = {}) {
                     ? `crew thread read`
                     : `crew message read --channel ${msg.channelId}`;
                 const wakeText = scheduled
-                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy)
+                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy, scheduled.externalNotificationPolicy)
                     : (msg.wake?.content
                         ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
                         : undefined);
@@ -602,7 +642,11 @@ export function serve(config, opts = {}) {
                         taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
                         runId, // 贯穿 SLS 日志的单轮关联键
                         ...(scheduled ? {
-                            scheduled: { title: scheduled.title, outputPolicy: scheduled.outputPolicy },
+                            scheduled: {
+                                title: scheduled.title,
+                                outputPolicy: scheduled.outputPolicy,
+                                externalNotificationPolicy: scheduled.externalNotificationPolicy,
+                            },
                         } : {}),
                         ...(wakeOrigin ? { wakeOrigin, originDecisionAttempt: attempt } : {}),
                         // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
@@ -648,6 +692,7 @@ export function serve(config, opts = {}) {
                     ...(wakeOrigin ? {
                         wakeOrigin,
                         originDecision: result.originDecision ?? "missing",
+                        ...(msg.wake?.seq !== undefined ? { contextUpToSeq: msg.wake.seq } : {}),
                     } : {}),
                     ...(scheduled ? { scheduledRunId: scheduled.runId } : {}),
                     ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.14",
+  "version": "0.5.16",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -17,10 +17,11 @@
     "access": "public"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "1.2.1",
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.6"
+    "@nowcrew/cli": "^0.4.8"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",