@nowcrew/daemon 0.6.88-beta.16 → 0.6.88-beta.18

package/dist/machine-info.js

@@ -1,7 +1,10 @@
+import { retryHarnessProbe } from "./runtimes/harness-probe-retry.js";
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { hostname, arch, platform as osPlatform } from "node:os";
 import { lookupCmd } from "./platform.js";
 import { augmentedPath } from "./runtime-path.js";
@@ -14,7 +17,7 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { executableRuntimes } from "./runtime-capabilities.js";
 import { executionBackendCapability } from "./execution-backend.js";
-import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./runtimes/kimi-acp-runner.js";
 import { probeHermesAcp } from "./runtimes/hermes.js";
 import { probeOpenCodeRun } from "./runtimes/opencode.js";
 import { RUNTIME_HEALTH_PROBE_CAPABILITY } from "./runtime-health.js";
@@ -117,31 +120,54 @@ export async function detectRuntimes() {
     }));
     return checks.filter((x) => x !== null);
 }
-async function supportsKimiAcp(signal) {
-    return probeKimiAcp({ bin: "kimi", ...(signal ? { signal } : {}) });
+async function supportsKimiAcp(signal, probeId) {
+    return probeKimiAcp({ bin: "kimi", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
 }
-async function supportsHermesAcp(signal) {
-    return probeHermesAcp({ bin: "hermes", ...(signal ? { signal } : {}) });
+async function supportsHermesAcp(signal, probeId) {
+    return probeHermesAcp({ bin: "hermes", ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
 }
 async function supportsOpenCodeRun(signal) {
     return probeOpenCodeRun(signal);
 }
-async function supportsDeepSeekHarnessAcp(signal) {
+async function supportsDeepSeekHarnessAcp(signal, probeId) {
     try {
-        return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher().bin, ...(signal ? { signal } : {}) });
+        return await probeDeepSeekHarnessAcp({ bin: deepSeekHarnessLauncher().bin, ...(probeId ? { probeId } : {}), ...(signal ? { signal } : {}) });
     }
-    catch {
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
         return false;
     }
 }
 /** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
-export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal) {
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp, hermesAcpProbe = supportsHermesAcp, openCodeProbe = supportsOpenCodeRun, deepSeekHarnessProbe = supportsDeepSeekHarnessAcp, signal, probeId = randomUUID()) {
     const present = await installed;
+    const probe = (runtime, detect) => {
+        const startedAt = Date.now();
+        dslog("runtime_probe.optional_start", "开始可选 runtime 探测", { probe_id: probeId, runtime, aborted: signal?.aborted ?? false });
+        const complete = (outcome, ready) => {
+            dslog("runtime_probe.optional_complete", "可选 runtime 探测结束", {
+                probe_id: probeId, runtime, outcome, duration_ms: Date.now() - startedAt,
+                aborted: signal?.aborted ?? false, ...(ready === undefined ? {} : { ready }),
+            });
+        };
+        let pending;
+        try {
+            pending = detect(signal, probeId);
+        }
+        catch (error) {
+            complete("threw");
+            throw error;
+        }
+        return pending.then((ready) => { complete("resolved", ready); return ready; }, (error) => { complete("threw"); throw error; });
+    };
     const [kimiReady, hermesReady, openCodeReady, deepSeekHarnessReady] = await Promise.all([
-        present.includes("kimi") ? kimiAcpProbe(signal) : false,
-        present.includes("hermes") ? hermesAcpProbe(signal) : false,
-        present.includes("opencode") ? openCodeProbe(signal) : false,
-        present.includes("deepseek-harness") ? deepSeekHarnessProbe(signal) : false,
+        present.includes("kimi") ? probe("kimi", kimiAcpProbe) : false,
+        present.includes("hermes") ? probe("hermes", hermesAcpProbe) : false,
+        present.includes("opencode") ? probe("opencode", openCodeProbe) : false,
+        present.includes("deepseek-harness")
+            ? retryHarnessProbe(() => probe("deepseek-harness", deepSeekHarnessProbe), signal, probeId)
+            : false,
     ]);
     return executableRuntimes(present).filter((runtime) => (runtime === "kimi" ? kimiReady
         : runtime === "hermes" ? hermesReady
@@ -149,7 +175,7 @@ export async function detectExecutionRuntimes(installed = detectRuntimes(), kimi
                 : runtime === "deepseek-harness" ? deepSeekHarnessReady
                     : true));
 }
-export const detectExecutionRuntimesWithSignal = (installed, signal) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal);
+export const detectExecutionRuntimesWithSignal = (installed, signal, probeId) => detectExecutionRuntimes(installed, supportsKimiAcp, supportsHermesAcp, supportsOpenCodeRun, supportsDeepSeekHarnessAcp, signal, probeId);
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));

package/dist/runtime-probe.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { dslog } from "./slog.js";
 import { executableRuntimes } from "./runtime-capabilities.js";
 export function conservativeExecutionRuntimes(installed) {
     return executableRuntimes(installed)
@@ -7,16 +9,43 @@ export function createRuntimeProbeCoordinator() {
     const abort = new AbortController();
     const flights = new Map();
     return {
-        detect(installed, detector) {
+        detect(installed, detector, connectionId) {
             const key = [...installed].sort().join("\0");
             const existing = flights.get(key);
-            if (existing)
-                return existing;
-            const pending = detector(installed, abort.signal).catch((error) => {
+            const probeId = existing?.probeId ?? randomUUID();
+            const fields = { probe_id: probeId, connection_id: connectionId, installed_runtimes: JSON.stringify(installed) };
+            dslog("runtime_probe.request", "请求 runtime 执行能力探测", fields);
+            if (existing) {
+                dslog("runtime_probe.cache_hit", "复用 runtime 探测结果", { ...fields, cache_state: existing.state });
+                return existing.promise;
+            }
+            const startedAt = Date.now();
+            const complete = (outcome, executionRuntimes) => {
+                dslog("runtime_probe.complete", "runtime 探测聚合结束", {
+                    ...fields, outcome, duration_ms: Date.now() - startedAt, aborted: abort.signal.aborted,
+                    ...(executionRuntimes === undefined ? {} : { execution_runtimes: JSON.stringify(executionRuntimes) }),
+                });
+            };
+            let detection;
+            try {
+                detection = detector(installed, abort.signal, probeId);
+            }
+            catch (error) {
+                complete("threw");
+                throw error;
+            }
+            const pending = detection.then((result) => {
+                const flight = flights.get(key);
+                if (flight)
+                    flights.set(key, { ...flight, state: "resolved" });
+                complete("resolved", result);
+                return result;
+            }, (error) => {
                 flights.delete(key);
+                complete("threw");
                 throw error;
             });
-            flights.set(key, pending);
+            flights.set(key, { promise: pending, probeId, state: "pending" });
             return pending;
         },
         stop() {

package/dist/runtimes/deepseek-harness.js

@@ -4,7 +4,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { prepareHarnessProfile } from "./deepseek-harness-profile.js";
-import { probeKimiAcp } from "./kimi-acp-runner.js";
+import { probeKimiAcp, AcpProbeCleanupError } from "./kimi-acp-runner.js";
 export const DEEPSEEK_HARNESS_CONFIG_ENV = "NOWCREW_DEEPSEEK_HARNESS_CONFIG";
 export const DEEPSEEK_HARNESS_PATCH_ENV = "NOWCREW_DEEPSEEK_HARNESS_PATCH";
 export function deepSeekHarnessLauncher(env = process.env) {
@@ -61,7 +61,9 @@ export async function probeDeepSeekHarnessAcp(options, spawnProcess = spawn) {
             launchCwd: root,
         }, spawnProcess);
     }
-    catch {
+    catch (error) {
+        if (error instanceof AcpProbeCleanupError)
+            throw error;
         return false;
     }
     finally {

package/dist/runtimes/harness-probe-retry.js

@@ -0,0 +1,42 @@
+import { dslog } from "../slog.js";
+const RETRY_DELAYS_MS = [1_000, 2_000];
+/** 只延迟当前启动探测,不设后台定时任务;stop 立即清除等待。 */
+function waitForRetry(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const finish = (ready) => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(ready);
+        };
+        const onAbort = () => finish(false);
+        const timer = setTimeout(() => finish(true), ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** 成功才公布能力;每次 probe 返回前已完成进程清理,异常保持原有传播。 */
+export async function retryHarnessProbe(probe, signal, probeId) {
+    for (let attempt = 1; attempt <= RETRY_DELAYS_MS.length + 1; attempt++) {
+        if (signal?.aborted)
+            return false;
+        const ready = await probe();
+        dslog("runtime_probe.harness_attempt", "Harness 启动探测尝试结束", {
+            probe_id: probeId, runtime: "deepseek-harness", attempt, ready,
+            aborted: signal?.aborted ?? false,
+        });
+        if (signal?.aborted)
+            return false;
+        if (ready)
+            return true;
+        const delayMs = RETRY_DELAYS_MS[attempt - 1];
+        if (delayMs === undefined)
+            return false;
+        dslog("runtime_probe.harness_retry", "延迟重试 Harness 启动探测", {
+            probe_id: probeId, runtime: "deepseek-harness", next_attempt: attempt + 1, delay_ms: delayMs,
+        });
+        if (!await waitForRetry(delayMs, signal))
+            return false;
+    }
+    return false;
+}

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

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { dslog } from "../slog.js";
 import { once } from "node:events";
 import { isAbsolute } from "node:path";
 import { parseArgs } from "node:util";
@@ -194,10 +196,20 @@ async function stopChild(child) {
         await closed;
     }
 }
+export class AcpProbeCleanupError extends Error {
+    constructor() { super("ACP probe process cleanup unconfirmed"); this.name = "AcpProbeCleanupError"; }
+}
 /** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
 export async function probeKimiAcp(options, spawnProcess = spawn) {
     const provider = options.provider ?? "kimi";
     const permission = options.effectivePermission ?? "sandboxed";
+    const probeId = options.probeId ?? randomUUID();
+    const started = Date.now();
+    let reason = "initializing", protocolVersion;
+    let stderrSeen = false;
+    const fields = () => ({ probe_id: probeId, runtime: provider, duration_ms: Date.now() - started,
+        reason, protocol_version: protocolVersion, stderr_seen: stderrSeen, aborted: options.signal?.aborted ?? false });
+    dslog("execution.acp_probe_started", "ACP 探测开始", { probe_id: probeId, runtime: provider, node_version: process.version });
     const child = spawnProcess(options.bin, options.launchArgs ?? providerArgs(provider, options.configPath), {
         cwd: options.launchCwd ?? process.cwd(),
         // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
@@ -206,6 +218,7 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)
         return false;
+    child.stderr.on("data", () => { stderrSeen = true; });
     child.stderr.resume();
     const app = client({ name: `nowcrew-daemon-${provider}-probe` })
         .onRequest(methods.client.session.requestPermission, () => ({
@@ -222,18 +235,27 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
                 clientCapabilities: {},
                 clientInfo: { name: "nowcrew-daemon", version: "1" },
             });
-            return initialized.protocolVersion === PROTOCOL_VERSION;
+            protocolVersion = initialized.protocolVersion;
+            const ready = protocolVersion === PROTOCOL_VERSION;
+            if (reason === "initializing")
+                reason = ready ? "ready" : "protocol_mismatch";
+            dslog("execution.acp_probe_handshake", "ACP 握手结果", { ...fields(), ready });
+            return ready;
         });
         const result = await Promise.race([
             connected,
             new Promise((resolve) => {
                 timeout = setTimeout(() => {
+                    if (reason === "initializing")
+                        reason = "timeout";
                     void stopChild(child);
                     resolve(false);
                 }, PROBE_TIMEOUT_MS);
             }),
             new Promise((resolve) => {
                 onAbort = () => {
+                    if (reason === "initializing")
+                        reason = "aborted";
                     void stopChild(child);
                     resolve(false);
                 };
@@ -246,6 +268,8 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
         return result;
     }
     catch {
+        if (reason === "initializing")
+            reason = options.signal?.aborted ? "aborted" : "transport_error";
         return false;
     }
     finally {
@@ -253,7 +277,20 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
             clearTimeout(timeout);
         if (onAbort !== undefined)
             options.signal?.removeEventListener("abort", onAbort);
-        await stopChild(child);
+        dslog("execution.acp_probe_cleanup_started", "ACP 探测清理开始", fields());
+        let cleanupFinished = false;
+        try {
+            await stopChild(child);
+            cleanupFinished = true;
+        }
+        catch {
+            throw new AcpProbeCleanupError();
+        }
+        finally {
+            dslog("execution.acp_probe_finished", "ACP 探测结束", { ...fields(),
+                cleanup_finished: cleanupFinished, exit_code: child.exitCode, exit_signal: child.signalCode,
+                level: reason === "ready" && cleanupFinished ? "INFO" : "WARN" });
+        }
     }
 }
 export async function runKimiAcp(requestedOptions) {

package/dist/serve.js

@@ -291,10 +291,11 @@ export function serve(config, opts = {}) {
             connectionEpochToken = projectSkillsController.beginConnectionEpoch();
             storageIdentityAdmission.beginIdentityBinding();
             const openedSocket = ws;
+            const connectionId = randomUUID();
             backoff = 1000;
             connectedAt = Date.now();
             log(`🔌 已连接控制面 ${config.serverUrl}`);
-            dslog("daemon.ws_open", "已连接控制面", { server_url: config.serverUrl });
+            dslog("daemon.ws_open", "已连接控制面", { server_url: config.serverUrl, connection_id: connectionId });
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
@@ -312,21 +313,36 @@ export function serve(config, opts = {}) {
                 .then(async (hello) => {
                 if (hello.executionProtocol === undefined) {
                     executionRuntimesKnown = true;
+                    dslog("runtime_probe.hello_refresh", "runtime hello 刷新决策", {
+                        connection_id: connectionId, reason: "protocol_unavailable",
+                        current_socket: ws === openedSocket, socket_open: openedSocket.readyState === WebSocket.OPEN,
+                        socket_ready_state: openedSocket.readyState, installed_runtimes: JSON.stringify(hello.runtimes),
+                        execution_runtimes: JSON.stringify(hello.executionRuntimes),
+                    });
                     return [];
                 }
-                const detected = await runtimeProbe.detect(hello.runtimes, detectExecutable);
+                const detected = await runtimeProbe.detect(hello.runtimes, detectExecutable, connectionId);
                 executionRuntimesKnown = true;
-                if (ws === openedSocket && openedSocket.readyState === WebSocket.OPEN
-                    && detected.some((runtime) => !hello.executionRuntimes.includes(runtime))) {
+                const currentSocket = ws === openedSocket;
+                const socketOpen = openedSocket.readyState === WebSocket.OPEN;
+                const hasNewRuntime = detected.some((runtime) => !hello.executionRuntimes.includes(runtime));
+                dslog("runtime_probe.hello_refresh", "runtime hello 刷新决策", {
+                    connection_id: connectionId, current_socket: currentSocket, socket_open: socketOpen,
+                    socket_ready_state: openedSocket.readyState, installed_runtimes: JSON.stringify(hello.runtimes),
+                    initial_execution_runtimes: JSON.stringify(hello.executionRuntimes), execution_runtimes: JSON.stringify(detected),
+                    reason: !currentSocket ? "stale_connection" : !socketOpen ? "socket_not_open" : !hasNewRuntime ? "unchanged" : "publish",
+                });
+                if (currentSocket && socketOpen && hasNewRuntime) {
                     detectedExecutionRuntimes = detected;
                     machineHelloPublisher.publish({ ...hello, executionRuntimes: [...detected] }, openedSocket);
                 }
                 return detected;
             })
-                .catch((error) => {
+                .catch(() => {
                 executionRuntimesKnown = true;
                 dslog("execution.runtime_detection_failed", "runtime 探测失败", {
-                    level: "ERROR", error_message: error.message,
+                    level: "ERROR", reason: "detection_threw", connection_id: connectionId,
+                    current_socket: ws === openedSocket, socket_open: openedSocket.readyState === WebSocket.OPEN,
                 });
                 return [];
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.88-beta.16",
+  "version": "0.6.88-beta.18",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",