@nowcrew/daemon 0.5.18 → 0.5.20

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-lifecycle.js

@@ -0,0 +1,82 @@
+import { dslog, flushSlog } from "./slog.js";
+function defaultDiagnose(diagnostic) {
+    const fields = {
+        signal: diagnostic.signal,
+        stage: diagnostic.stage,
+        active_execution_count: diagnostic.activeExecutionCount,
+        active_legacy_count: diagnostic.activeLegacyCount,
+        deadline_ms: diagnostic.deadlineMs,
+        ...(diagnostic.error === undefined ? {} : { error: diagnostic.error }),
+    };
+    try {
+        dslog(diagnostic.stage === "failed" ? "daemon.shutdown_failed" : "daemon.shutdown", `daemon shutdown ${diagnostic.stage}`, { level: diagnostic.stage === "failed" ? "ERROR" : "INFO", ...fields });
+        process.stderr.write(`${JSON.stringify({
+            level: diagnostic.stage === "failed" ? "ERROR" : "INFO",
+            event_type: diagnostic.stage === "failed" ? "daemon.shutdown_failed" : "daemon.shutdown",
+            ...fields,
+        })}\n`);
+    }
+    catch { /* shutdown diagnostics must never interrupt cleanup */ }
+}
+export async function runServeLifecycle(service, dependencies = {}) {
+    const signals = dependencies.signals ?? process;
+    const flush = dependencies.flush ?? flushSlog;
+    const diagnose = dependencies.diagnose ?? defaultDiagnose;
+    let receivedSignal = null;
+    let resolveSignal;
+    const signalReceived = new Promise((resolve) => { resolveSignal = resolve; });
+    const receive = (signal) => {
+        if (receivedSignal !== null)
+            return;
+        receivedSignal = signal;
+        resolveSignal(signal);
+    };
+    const onSigint = () => receive("SIGINT");
+    const onSigterm = () => receive("SIGTERM");
+    signals.on("SIGINT", onSigint);
+    signals.on("SIGTERM", onSigterm);
+    try {
+        try {
+            await service.ready;
+        }
+        catch (readyError) {
+            try {
+                await service.stop();
+            }
+            catch { /* preserve the readiness error */ }
+            try {
+                await flush();
+            }
+            catch { /* slog is best effort */ }
+            throw readyError;
+        }
+        const signal = await signalReceived;
+        const snapshot = service.shutdownSnapshot();
+        diagnose({ signal, stage: "stopping", ...snapshot });
+        let stopError;
+        try {
+            await service.stop();
+            diagnose({ signal, stage: "completed", ...snapshot });
+        }
+        catch (error) {
+            stopError = error;
+            diagnose({
+                signal,
+                stage: "failed",
+                error: error instanceof Error ? error.message : String(error),
+                ...snapshot,
+            });
+        }
+        try {
+            await flush();
+        }
+        catch { /* slog owns its own spool fallback */ }
+        if (stopError !== undefined)
+            throw stopError;
+        return { signal };
+    }
+    finally {
+        signals.off("SIGINT", onSigint);
+        signals.off("SIGTERM", onSigterm);
+    }
+}