@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/runtimes/hermes-models.js

@@ -71,9 +71,10 @@ async function stopChild(child) {
 }
 export async function listHermesModels(options = {}) {
     const spawnProcess = options.spawnProcess ?? spawn;
+    const env = options.env ?? { ...process.env, PATH: augmentedPath() };
     const child = spawnProcess("hermes", ["acp"], {
         cwd: process.cwd(),
-        env: { ...process.env, PATH: augmentedPath() },
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
     if (child.stdin === null || child.stdout === null || child.stderr === null)

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

@@ -1,3 +1,6 @@
+import { AcpProbeTransport } from "./acp-probe-transport.js";
+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";
@@ -10,7 +13,12 @@ import { prepareThreadDelivery } from "../thread-input-delivery.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;
+// macOS launchd cold-starts ACP runtimes materially slower than an interactive
+// shell. DeepSeek Harness was measured at ~4.4s before returning initialize
+// under launchd, while the daemon also creates an isolated profile. Keep this
+// bounded below the control-plane request budget, with the existing 1s/2s
+// Harness retries providing the outer bound.
+export const ACP_PROBE_TIMEOUT_MS = 10_000;
 function jsonLine(event) {
     if (process.stdout.write(`${JSON.stringify(event)}\n`))
         return Promise.resolve();
@@ -128,10 +136,10 @@ function deepSeekPermissionMode(permission) {
         return "workspace-write";
     return "danger-full-access";
 }
-function providerEnv(provider, permission) {
+function providerEnv(provider, permission, env = process.env) {
     return provider === "deepseek-harness"
-        ? { ...process.env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
-        : process.env;
+        ? { ...env, DSH_PERMISSION_MODE: deepSeekPermissionMode(permission) }
+        : env;
 }
 function providerDisplayName(provider) {
     if (provider === "deepseek-harness")
@@ -194,18 +202,48 @@ 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 child = spawnProcess(options.bin, providerArgs(provider, options.configPath), {
-        cwd: process.cwd(),
-        // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
-        env: { ...providerEnv(provider, permission), PATH: augmentedPath() },
+    const probeId = options.probeId ?? randomUUID();
+    const started = performance.now();
+    const elapsed = () => Math.round(performance.now() - started);
+    const transport = new AcpProbeTransport(elapsed);
+    let spawnConfirmedMs;
+    let reason = "initializing", protocolVersion;
+    let stderrSeen = false;
+    const fields = () => ({ probe_id: probeId, runtime: provider, duration_ms: elapsed(),
+        ...transport.fields(), spawn_confirmed_ms: spawnConfirmedMs, child_pid: child.pid,
+        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 sourceEnv = options.env ?? { ...process.env, PATH: augmentedPath() };
+    const launchEnv = options.launchEnv ?? providerEnv(provider, permission, sourceEnv);
+    const child = spawnProcess(options.bin, options.launchArgs ?? providerArgs(provider, options.configPath), {
+        cwd: options.launchCwd ?? process.cwd(),
+        // 显式 launchEnv 已准备好 PATH/HOME，不能二次补 PATH 或混入父进程环境。
+        env: launchEnv,
         stdio: ["pipe", "pipe", "pipe"],
     });
+    // spawn errors are emitted by ChildProcess, not its stdio streams. A missing
+    // launcher must fail admission, not become an uncaught daemon exception.
+    const spawnFailed = new Promise((resolve) => {
+        child.once("error", () => {
+            if (reason === "initializing")
+                reason = "spawn_error";
+            resolve(false);
+        });
+    });
+    child.once("spawn", () => {
+        spawnConfirmedMs = elapsed();
+        dslog("execution.acp_probe_spawned", "ACP 探测子进程已启动", fields());
+    });
     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, () => ({
@@ -215,25 +253,37 @@ export async function probeKimiAcp(options, spawnProcess = spawn) {
     let timeout;
     let onAbort;
     try {
-        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const stream = ndJsonStream(transport.writable(child.stdin), transport.readable(child.stdout));
         const connected = app.connectWith(stream, async (context) => {
-            await context.request(methods.agent.initialize, {
+            transport.initializeRequested();
+            const initialized = await context.request(methods.agent.initialize, {
                 protocolVersion: PROTOCOL_VERSION,
                 clientCapabilities: {},
                 clientInfo: { name: "nowcrew-daemon", version: "1" },
             });
-            return true;
+            transport.initializeResponse();
+            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,
+            spawnFailed,
             new Promise((resolve) => {
                 timeout = setTimeout(() => {
+                    if (reason === "initializing")
+                        reason = "timeout";
                     void stopChild(child);
                     resolve(false);
-                }, PROBE_TIMEOUT_MS);
+                }, ACP_PROBE_TIMEOUT_MS);
             }),
             new Promise((resolve) => {
                 onAbort = () => {
+                    if (reason === "initializing")
+                        reason = "aborted";
                     void stopChild(child);
                     resolve(false);
                 };
@@ -246,6 +296,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 +305,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/runtimes/opencode.js

@@ -11,7 +11,7 @@ const REQUIRED_RUN_FLAGS = [
     "--variant",
     "--session",
 ];
-export async function probeOpenCodeRun(signal) {
+export async function probeOpenCodeRun(signal, env = { ...process.env, PATH: augmentedPath() }) {
     try {
         const { stdout, stderr } = await execFileP("opencode", ["run", "--help"], {
             shell: isWin(),
@@ -19,7 +19,7 @@ export async function probeOpenCodeRun(signal) {
             killSignal: "SIGKILL",
             maxBuffer: 1024 * 1024,
             signal,
-            env: { ...process.env, PATH: augmentedPath() },
+            env,
         });
         const help = `${stdout}\n${stderr}`;
         return REQUIRED_RUN_FLAGS.every((flag) => help.includes(flag));