@nowcrew/daemon 0.5.18 → 0.5.19

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

@@ -4,6 +4,9 @@ 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";
+import { augmentedPath } from "../runtime-path.js";
+import { startFirstProgressWatchdog } from "./progress-watchdog.js";
+import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
 const ERROR_MESSAGE_CAP = 2_000;
 const PROBE_TIMEOUT_MS = 5_000;
 function jsonLine(event) {
@@ -60,6 +63,17 @@ function safeErrorMessage(error, prompt) {
     const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
     return redacted.slice(0, ERROR_MESSAGE_CAP);
 }
+export function isKimiAuthenticationRequired(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /\bauthentication required\b/i.test(message);
+}
+export function kimiResumeMethod(capabilities) {
+    if (capabilities?.sessionCapabilities?.resume != null)
+        return "resume";
+    if (capabilities?.loadSession)
+        return "load";
+    return null;
+}
 /** 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");
@@ -100,11 +114,12 @@ async function stopChild(child) {
         await closed;
     }
 }
-/** A help banner is insufficient: Kimi's authenticate RPC re-checks its token without creating a session. */
+/** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
 export async function probeKimiAcp(options, spawnProcess = spawn) {
     const child = spawnProcess(options.bin, ["acp"], {
         cwd: process.cwd(),
-        env: process.env,
+        // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
+        env: { ...process.env, PATH: augmentedPath() },
         stdio: ["pipe", "pipe", "pipe"],
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)
@@ -119,15 +134,11 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     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, {
+            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([
@@ -157,12 +168,15 @@ export async function runKimiAcp(options) {
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],
     });
+    let runtimeChild = child;
     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 acpSemanticProgress = false;
+    let progressTimedOut = false;
     let cancelling = false;
     const cancel = async () => {
         if (cancelling)
@@ -171,7 +185,7 @@ export async function runKimiAcp(options) {
         if (context !== null && sessionId !== null) {
             await context.notify(methods.agent.session.cancel, { sessionId }).catch(() => undefined);
         }
-        await stopChild(child);
+        await stopChild(runtimeChild);
     };
     const onSignal = () => {
         void cancel().finally(() => process.exit(130));
@@ -181,9 +195,13 @@ export async function runKimiAcp(options) {
     const app = client({ name: "nowcrew-daemon-kimi" })
         .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
         .onNotification(methods.client.session.update, async ({ params }) => {
+        acpSemanticProgress = true;
+        firstProgress.observe();
         for (const event of mapKimiAcpUpdate(params.update))
             await jsonLine(event);
     });
+    let firstProgress = startFirstProgressWatchdog(() => undefined);
+    firstProgress.stop();
     try {
         const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
         const result = await app.connectWith(stream, async (nextContext) => {
@@ -196,15 +214,35 @@ export async function runKimiAcp(options) {
             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 });
+            if (options.resume && options.sessionId) {
+                const resumeMethod = kimiResumeMethod(initialized.agentCapabilities);
+                if (resumeMethod === "resume") {
+                    await nextContext.request(methods.agent.session.resume, {
+                        sessionId: options.sessionId,
+                        cwd: process.cwd(),
+                        mcpServers: [],
+                    });
+                }
+                else if (resumeMethod === "load") {
+                    await nextContext.request(methods.agent.session.load, {
+                        sessionId: options.sessionId,
+                        cwd: process.cwd(),
+                        mcpServers: [],
+                    });
+                }
+                else {
+                    throw new Error("Kimi ACP does not advertise session resume support");
+                }
+                sessionId = options.sessionId;
             }
-            const session = await nextContext.request(methods.agent.session.new, {
-                cwd: process.cwd(),
-                mcpServers: [],
-            });
-            sessionId = session.sessionId;
+            else {
+                const session = await nextContext.request(methods.agent.session.new, {
+                    cwd: process.cwd(),
+                    mcpServers: [],
+                });
+                sessionId = session.sessionId;
+            }
+            await jsonLine({ type: "thread.started", thread_id: sessionId });
             if (options.model) {
                 await nextContext.request(methods.agent.session.setConfigOption, {
                     sessionId,
@@ -212,11 +250,20 @@ export async function runKimiAcp(options) {
                     value: options.model,
                 });
             }
+            firstProgress = startFirstProgressWatchdog(() => {
+                progressTimedOut = true;
+                void cancel();
+            });
             return nextContext.request(methods.agent.session.prompt, {
                 sessionId,
                 prompt: [{ type: "text", text: prompt }],
             });
         });
+        firstProgress.stop();
+        if (progressTimedOut) {
+            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            return 1;
+        }
         const usage = result.usage;
         await jsonLine({
             type: "turn.completed",
@@ -233,10 +280,54 @@ export async function runKimiAcp(options) {
         return result.stopReason === "end_turn" ? 0 : result.stopReason === "cancelled" ? 130 : 1;
     }
     catch (error) {
+        if (progressTimedOut) {
+            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
+            return 1;
+        }
+        if (!acpSemanticProgress && isKimiAuthenticationRequired(error)) {
+            firstProgress.stop();
+            await stopChild(child);
+            process.stderr.write("Kimi ACP requires account login; falling back to configured CLI provider transport\n");
+            assertKimiLegacyPromptFits(prompt);
+            const fallback = spawn(options.bin, buildKimiArgs({
+                wakePrompt: prompt,
+                effectivePermission: "full_access",
+                ...(options.model === undefined ? {} : { model: options.model }),
+                ...(options.resume && options.sessionId ? { sessionId: options.sessionId } : {}),
+            }), {
+                cwd: process.cwd(),
+                env: process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            runtimeChild = fallback;
+            if (fallback.stdout === null || fallback.stderr === null) {
+                throw new Error("Kimi CLI fallback did not expose output streams");
+            }
+            firstProgress = startFirstProgressWatchdog(() => {
+                progressTimedOut = true;
+                void stopChild(fallback);
+            });
+            fallback.stdout.on("data", () => firstProgress.observe());
+            fallback.stdout.pipe(process.stdout, { end: false });
+            fallback.stderr.pipe(process.stderr, { end: false });
+            const code = await new Promise((resolve, reject) => {
+                fallback.once("error", reject);
+                fallback.once("close", (exitCode, signal) => {
+                    resolve(exitCode ?? (signal === null ? 1 : 128));
+                });
+            });
+            firstProgress.stop();
+            if (progressTimedOut) {
+                process.stderr.write("Kimi CLI fallback produced no output within the startup window\n");
+                return 1;
+            }
+            return code;
+        }
         process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
         return 1;
     }
     finally {
+        firstProgress.stop();
         process.off("SIGTERM", onSignal);
         process.off("SIGINT", onSignal);
         await stopChild(child);
@@ -248,11 +339,20 @@ function optionsFromArgv(argv) {
         options: {
             bin: { type: "string" },
             model: { type: "string" },
+            session: { type: "string" },
+            resume: { type: "boolean", default: false },
         },
     });
     if (!values.bin)
         throw new Error("--bin is required");
-    return { bin: values.bin, ...(values.model ? { model: values.model } : {}) };
+    if (values.resume && !values.session)
+        throw new Error("--resume requires --session");
+    return {
+        bin: values.bin,
+        ...(values.model ? { model: values.model } : {}),
+        ...(values.session ? { sessionId: values.session } : {}),
+        ...(values.resume ? { resume: true } : {}),
+    };
 }
 if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
     runKimiAcp(optionsFromArgv(process.argv.slice(2)))

package/dist/runtimes/kimi.js

@@ -29,6 +29,8 @@ export function buildKimiArgs(input) {
     const args = ["--output-format", "stream-json"];
     if (input.model)
         args.push("--model", input.model);
+    if (input.sessionId)
+        args.push("--session", input.sessionId);
     args.push("--prompt", input.wakePrompt);
     return args;
 }

package/dist/runtimes/progress-watchdog.js

@@ -0,0 +1,26 @@
+export const DEFAULT_FIRST_PROGRESS_TIMEOUT_MS = 120_000;
+/**
+ * Bound the silent gap after a protocol turn starts. Once any semantic notification arrives,
+ * the runtime's configured total timeout remains authoritative; long-running tools are not killed
+ * merely because they produce no output.
+ */
+export function startFirstProgressWatchdog(onTimeout, timeoutMs = DEFAULT_FIRST_PROGRESS_TIMEOUT_MS) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new RangeError("First-progress timeout must be a positive finite number");
+    }
+    let active = true;
+    const timer = setTimeout(() => {
+        if (!active)
+            return;
+        active = false;
+        onTimeout();
+    }, timeoutMs);
+    timer.unref?.();
+    const stop = () => {
+        if (!active)
+            return;
+        active = false;
+        clearTimeout(timer);
+    };
+    return { observe: stop, stop };
+}

package/dist/serve.js

@@ -237,9 +237,10 @@ export function serve(config, opts = {}) {
     initSlog(config.serverUrl, config.machineToken);
     dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
-    // - running:正在跑的「agent:任务」去重键(同一任务重复唤醒才跳过)。
-    // - agentSlots:每 agent 当前并行数;超过配置上限的进 FIFO 队列(不丢)。
+    // scheduled 重复 run 仍由 running 去重;普通同线程 wake 用 legacyTaskTails 串成 FIFO。
+    // 每 agent 超过并行上限的任务继续进入 sharedQueues(不丢)。
     const running = new Set();
+    const legacyTaskTails = new Map();
     const acquireSlot = async (handle) => {
         await reserveSharedSlot(handle, "legacy").ready;
     };
@@ -436,8 +437,23 @@ export function serve(config, opts = {}) {
                 && "type" in decoded && decoded.type === "agent:start"
                 ? LegacyAgentStartSchema.safeParse(decoded)
                 : null;
-            if (legacy !== null && !legacy.success)
+            if (legacy !== null && !legacy.success) {
+                // 帧结构不合法(如 server 端已升级到 execution v1 但本 daemon 仍按 legacy 校验)。
+                // 曾经静默 return——只表现为"@了 agent 没反应",且完全没有排查线索。记录字段路径和
+                // zod 错误码,不记录消息正文/附件等可能敏感的字段值。
+                const raw = decoded;
+                dslog("run.legacy_frame_rejected", "agent:start 帧未通过 legacy schema 校验,已丢弃", {
+                    level: "WARN",
+                    agent_handle: typeof raw.agentHandle === "string" ? raw.agentHandle : undefined,
+                    channel_id: typeof raw.channelId === "string" ? raw.channelId : undefined,
+                    reason: typeof raw.reason === "string" ? raw.reason : undefined,
+                    issue_count: legacy.error.issues.length,
+                    issue_paths: legacy.error.issues
+                        .map((issue) => `${issue.path.join(".")}:${issue.code}`)
+                        .join(","),
+                });
                 return;
+            }
             const msg = (legacy?.success ? legacy.data : decoded);
             // 控制面鉴权拒绝:server 端 resolveToken 未命中有效的 machine 凭证(失效/被吊销/
             // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
@@ -534,16 +550,28 @@ export function serve(config, opts = {}) {
                 wake_origin: msg.wake?.origin ?? null,
                 content_preview: (msg.wake?.content ?? "").replace(/\s+/g, " ").slice(0, 120),
             });
-            if (running.has(key)) {
+            if (scheduled && running.has(key)) {
                 log(`↩︎ 跳过(该任务已在运行): ${key}`);
                 dslog("run.dedupe_skip", "跳过唤醒:该任务已在运行", { level: "WARN", ...runKeys });
                 return;
             }
+            const queueWaitStart = Date.now();
+            let legacyQueueDone = null;
+            let finishLegacyQueue = () => { };
+            if (!scheduled) {
+                const previous = legacyTaskTails.get(key);
+                legacyQueueDone = new Promise((resolve) => { finishLegacyQueue = resolve; });
+                legacyTaskTails.set(key, legacyQueueDone);
+                if (previous) {
+                    log(`⏳ 排队(该任务已在运行): ${key}`);
+                    dslog("run.wake_queued", "唤醒已排队:该任务正在运行", { ...runKeys });
+                    await previous;
+                }
+            }
             running.add(key);
             // 并行槽:同 agent 超过配置上限的任务在此排队(不丢),有空位再跑。
-            const slotWaitStart = Date.now();
             await acquireSlot(msg.agentHandle);
-            const queueMs = Date.now() - slotWaitStart;
+            const queueMs = Date.now() - queueWaitStart;
             const threadLabel = threadId ?? null;
             const from = msg.wake?.senderHandle ?? "?";
             const incoming = msg.wake?.content ?? "";
@@ -769,6 +797,10 @@ export function serve(config, opts = {}) {
             finally {
                 running.delete(key);
                 releaseSlot(msg.agentHandle);
+                finishLegacyQueue();
+                if (legacyQueueDone && legacyTaskTails.get(key) === legacyQueueDone) {
+                    legacyTaskTails.delete(key);
+                }
                 void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
             }
         });

package/dist/session.js

@@ -1,5 +1,5 @@
 /**
- * per-task claude 会话元数据 —— 让同一任务的重复唤醒用 `--resume` 复用上下文(省 token)。
+ * per-task runtime 会话元数据 —— 让同一任务的重复唤醒复用原生上下文(省 token)。
  *
  * 存在本任务隔离运行目录下(<runDir>/.crew-session.json):天然按 taskKey 隔离、落盘防 daemon
  * 重启丢失。读取一律容错 → 不存在/损坏/字段非法都回退 null(= 当作首轮冷启动),绝不阻断运行。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.18",
+  "version": "0.5.19",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -21,7 +21,7 @@
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.10"
+    "@nowcrew/cli": "^0.4.11"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
@@ -32,7 +32,7 @@
     "vitest": "^2.1.0"
   },
   "scripts": {
-    "daemon": "tsx src/main.ts",
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"