@nowcrew/daemon 0.5.51 → 0.5.52

package/dist/control-request-types.js

@@ -0,0 +1 @@
+export {};

package/dist/machine-info.js

@@ -17,6 +17,7 @@ import { executionBackendCapability } from "./execution-backend.js";
 import { probeKimiAcp } 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";
 import { probeDeepSeekHarnessAcp } from "./runtimes/deepseek-harness.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
@@ -31,6 +32,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_machine_queue_v1",
     "execution_agent_memory_policy_v1",
     "project_skills_v1",
+    RUNTIME_HEALTH_PROBE_CAPABILITY,
 ];
 export const daemonCapabilities = (runtimePlatform = process.platform) => runtimePlatform === "darwin" || runtimePlatform === "linux"
     ? DAEMON_CAPABILITIES

package/dist/runtime-health.js

@@ -0,0 +1,158 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { augmentedPath } from "./runtime-path.js";
+export const RUNTIME_HEALTH_PROBE_CAPABILITY = "runtime_health_probe_v1";
+export const RUNTIME_HEALTH_NAMES = ["claude", "codex", "opencode", "kimi"];
+const RuntimeProbeTargetSchema = z.object({
+    runtime: z.enum(RUNTIME_HEALTH_NAMES),
+    modelId: z.string().min(1).max(200).nullable(),
+    configFingerprint: z.string().min(1).max(200).nullable(),
+}).strict();
+export const RuntimeProbeRequestSchema = z.object({
+    runtimes: z.array(RuntimeProbeTargetSchema).min(1).max(RUNTIME_HEALTH_NAMES.length),
+    timeoutMs: z.number().int().min(10).max(60_000),
+}).strict().superRefine((value, context) => {
+    const seen = new Set();
+    for (let index = 0; index < value.runtimes.length; index += 1) {
+        const runtime = value.runtimes[index]?.runtime;
+        if (runtime === undefined || !seen.has(runtime)) {
+            if (runtime !== undefined)
+                seen.add(runtime);
+            continue;
+        }
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["runtimes", index, "runtime"],
+            message: "duplicate runtime",
+        });
+    }
+});
+export const RuntimeProbeFrameSchema = z.object({
+    type: z.literal("runtime-health:probe"),
+    reqId: z.string().min(1).max(128),
+    runtimes: z.array(RuntimeProbeTargetSchema).min(1).max(RUNTIME_HEALTH_NAMES.length),
+    timeoutMs: z.number().int().min(10).max(60_000),
+}).strict();
+const execFileAsync = promisify(execFile);
+const defaultExecutor = async (file, args, options) => {
+    const result = await execFileAsync(file, [...args], options);
+    return { stdout: String(result.stdout), stderr: String(result.stderr) };
+};
+const adapterOf = (_runtime) => "executable";
+function modelArgs(runtime, modelId) {
+    const model = modelId === null ? [] : ["--model", modelId];
+    if (runtime === "claude")
+        return ["--print", "--output-format", "json", ...model, "Reply only OK."];
+    if (runtime === "codex")
+        return ["exec", "--json", "--skip-git-repo-check", ...model, "Reply only OK."];
+    if (runtime === "opencode")
+        return ["run", "--format", "json", ...model, "Reply only OK."];
+    if (runtime === "kimi")
+        return ["--print", "--output-format", "json", ...model, "Reply only OK."];
+    return [];
+}
+function failureText(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    const value = error;
+    return [value.message, value.stdout, value.stderr].filter((part) => typeof part === "string")
+        .join("\n").toLowerCase().slice(0, 32_000);
+}
+function failureCode(error) {
+    const text = failureText(error);
+    if (/quota|insufficient[_ ]quota|credit balance/.test(text))
+        return "quota_exhausted";
+    if (/\b401\b|unauthori[sz]ed|invalid api[_ -]?key|authentication failed/.test(text))
+        return "auth_failed";
+    if (/model.{0,80}(not found|does not exist|unknown)/.test(text))
+        return "model_not_found";
+    if (/model.{0,80}(mapping|alias).{0,40}(invalid|missing|failed)/.test(text))
+        return "mapping_invalid";
+    if (/\b429\b|rate.?limit|too many requests/.test(text))
+        return "rate_limited";
+    if (/\b5\d\d\b|upstream|bad gateway|service unavailable/.test(text))
+        return "upstream_error";
+    return "upstream_error";
+}
+const isMissing = (error) => typeof error === "object" && error !== null && error.code === "ENOENT";
+const isAbort = (error) => typeof error === "object" && error !== null && error.name === "AbortError";
+async function runBounded(execute, file, args, timeoutMs, env) {
+    const controller = new AbortController();
+    let timer;
+    try {
+        return await Promise.race([
+            execute(file, args, {
+                env,
+                signal: controller.signal,
+                timeout: timeoutMs,
+                maxBuffer: 64 * 1024,
+            }),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(Object.assign(new Error("runtime health probe timed out"), { name: "AbortError" }));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export async function probeRuntimeHealth(request, dependencies = {}) {
+    const parsed = RuntimeProbeRequestSchema.parse(request);
+    const execute = dependencies.execute ?? defaultExecutor;
+    const now = dependencies.now ?? (() => new Date());
+    const monotonicNow = dependencies.monotonicNow ?? (() => performance.now());
+    const sourceEnv = dependencies.env ?? process.env;
+    const env = { ...sourceEnv, PATH: augmentedPath(sourceEnv) };
+    return Promise.all(parsed.runtimes.map(async (target) => {
+        const started = monotonicNow();
+        const checkedAt = now().toISOString();
+        const base = {
+            runtime: target.runtime,
+            adapter: adapterOf(target.runtime),
+            modelId: target.modelId,
+            configFingerprint: target.configFingerprint,
+            checkedAt,
+        };
+        const latencyMs = () => Math.max(0, Math.round(monotonicNow() - started));
+        try {
+            await runBounded(execute, target.runtime, ["--version"], parsed.timeoutMs, env);
+        }
+        catch (error) {
+            return {
+                ...base,
+                installation: isMissing(error) ? "missing" : "timeout",
+                model: "not_checked",
+                latencyMs: latencyMs(),
+                detailCode: isMissing(error) ? "executable_missing" : "version_timeout",
+            };
+        }
+        if (base.adapter !== "executable") {
+            return { ...base, installation: "available", model: "not_checked", latencyMs: latencyMs(), detailCode: null };
+        }
+        try {
+            await runBounded(execute, target.runtime, modelArgs(target.runtime, target.modelId), parsed.timeoutMs, env);
+            return { ...base, installation: "available", model: "ok", latencyMs: latencyMs(), detailCode: null };
+        }
+        catch (error) {
+            const code = isAbort(error) ? "timeout" : failureCode(error);
+            return { ...base, installation: "available", model: code, latencyMs: latencyMs(), detailCode: code };
+        }
+    }));
+}
+export async function handleRuntimeProbeFrame(decoded, probe = probeRuntimeHealth) {
+    const frame = RuntimeProbeFrameSchema.safeParse(decoded);
+    if (!frame.success)
+        return null;
+    try {
+        const data = await probe({ runtimes: frame.data.runtimes, timeoutMs: frame.data.timeoutMs });
+        return { reqId: frame.data.reqId, ok: true, data };
+    }
+    catch {
+        return { reqId: frame.data.reqId, ok: false, error: "runtime_health_probe_failed" };
+    }
+}

package/dist/serve.js

@@ -42,6 +42,7 @@ import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
 import { createProjectSkillsReconciler, ProjectProjectionError, } from "./project-skills/reconciler.js";
 import { parseMemoryPruneTraceId } from "./memory-prune-diagnostics.js";
+import { handleRuntimeProbeFrame, probeRuntimeHealth } from "./runtime-health.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -698,6 +699,16 @@ export function serve(config, opts = {}) {
                 catch { /* server 会按请求超时处理 */ }
                 return;
             }
+            if (msg.type === "runtime-health:probe") {
+                const result = await handleRuntimeProbeFrame(msg, opts.runtimeHealth?.probe ?? probeRuntimeHealth);
+                if (result !== null) {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", ...result }));
+                    }
+                    catch { /* server 会超时 */ }
+                }
+                return;
+            }
             // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
             if (msg.type === "raft:inspect" || msg.type === "raft:import") {
                 const req = msg;

package/package.json

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