@nowcrew/daemon 0.5.45 → 0.5.46

package/dist/runtimes/opencode.js

@@ -0,0 +1,181 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isWin } from "../platform.js";
+import { augmentedPath } from "../runtime-path.js";
+const execFileP = promisify(execFile);
+const REQUIRED_RUN_FLAGS = [
+    "--format",
+    "--dangerously-skip-permissions",
+    "--dir",
+    "--model",
+    "--variant",
+    "--session",
+];
+export async function probeOpenCodeRun(signal) {
+    try {
+        const { stdout, stderr } = await execFileP("opencode", ["run", "--help"], {
+            shell: isWin(),
+            timeout: 8_000,
+            killSignal: "SIGKILL",
+            maxBuffer: 1024 * 1024,
+            signal,
+            env: { ...process.env, PATH: augmentedPath() },
+        });
+        const help = `${stdout}\n${stderr}`;
+        return REQUIRED_RUN_FLAGS.every((flag) => help.includes(flag));
+    }
+    catch {
+        return false;
+    }
+}
+export function buildOpenCodeArgs(options) {
+    return [
+        "run", "--format", "json", "--dangerously-skip-permissions",
+        "--dir", options.cwd,
+        ...(options.model ? ["--model", options.model] : []),
+        ...(options.reasoning ? ["--variant", options.reasoning] : []),
+        ...(options.sessionId ? ["--session", options.sessionId] : []),
+    ];
+}
+function outputText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined || value === null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function reportedUsage(part) {
+    if ((part.cost ?? 0) > 0)
+        return true;
+    const tokens = part.tokens;
+    if (!tokens)
+        return false;
+    return (tokens.input ?? 0) > 0 || (tokens.output ?? 0) > 0
+        || (tokens.reasoning ?? 0) > 0 || (tokens.total ?? 0) > 0
+        || (tokens.cache?.read ?? 0) > 0 || (tokens.cache?.write ?? 0) > 0;
+}
+export function createOpenCodeEventDecoder() {
+    let sessionId = null;
+    let announcedSession = null;
+    let finalText = "";
+    let error = null;
+    let openStep = false;
+    let stepHasContinuationTool = false;
+    let awaitingContinuation = false;
+    let stepProducedOutput = false;
+    let lastStepVoid = false;
+    let sawEvent = false;
+    let sawStepFinish = false;
+    const usage = {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+    };
+    return {
+        push(raw) {
+            const event = (raw ?? {});
+            const out = [];
+            if (typeof event.type === "string" && event.type)
+                sawEvent = true;
+            if (typeof event.sessionID === "string" && event.sessionID) {
+                sessionId = event.sessionID;
+                if (announcedSession !== sessionId) {
+                    announcedSession = sessionId;
+                    out.push({ type: "thread.started", thread_id: sessionId });
+                }
+            }
+            const part = event.part ?? {};
+            if (event.type === "step_start") {
+                openStep = true;
+                awaitingContinuation = false;
+                stepHasContinuationTool = false;
+                stepProducedOutput = false;
+                out.push({ type: "opencode.step_start" });
+            }
+            else if (event.type === "text" && typeof part.text === "string" && part.text) {
+                finalText += part.text;
+                stepProducedOutput = true;
+                out.push({ type: "opencode.text_delta", text: part.text });
+            }
+            else if (event.type === "tool_use") {
+                stepProducedOutput = true;
+                if (part.metadata?.providerExecuted !== true)
+                    stepHasContinuationTool = true;
+                out.push({
+                    type: "opencode.tool_call",
+                    ...(part.callID ? { id: part.callID } : {}),
+                    ...(part.tool ? { title: part.tool } : {}),
+                    ...(part.state?.input === undefined ? {} : { input: part.state.input }),
+                });
+                if (part.state?.status === "completed" || part.state?.status === "error") {
+                    const content = part.state.status === "error" && part.state.error
+                        ? part.state.error
+                        : outputText(part.state.output);
+                    out.push({
+                        type: "opencode.tool_result",
+                        ...(part.callID ? { id: part.callID } : {}),
+                        status: part.state.status,
+                        ...(content ? { content } : {}),
+                    });
+                }
+            }
+            else if (event.type === "step_finish") {
+                openStep = false;
+                sawStepFinish = true;
+                awaitingContinuation = part.reason === "tool-calls"
+                    || (Boolean(part.reason) && stepHasContinuationTool);
+                stepHasContinuationTool = false;
+                if (reportedUsage(part))
+                    stepProducedOutput = true;
+                lastStepVoid = !stepProducedOutput;
+                const tokens = part.tokens;
+                if (tokens) {
+                    usage.input_tokens += tokens.input ?? 0;
+                    usage.output_tokens += tokens.output ?? 0;
+                    usage.cache_read_input_tokens += tokens.cache?.read ?? 0;
+                    usage.cache_creation_input_tokens += tokens.cache?.write ?? 0;
+                }
+                out.push({
+                    type: "opencode.step_finish",
+                    ...(part.reason ? { stop_reason: part.reason } : {}),
+                    ...(tokens ? { usage: {
+                            input_tokens: tokens.input ?? 0,
+                            output_tokens: tokens.output ?? 0,
+                            cache_read_input_tokens: tokens.cache?.read ?? 0,
+                            cache_creation_input_tokens: tokens.cache?.write ?? 0,
+                        } } : {}),
+                });
+            }
+            else if (event.type === "error") {
+                error = event.error?.data?.message || event.error?.name || "unknown OpenCode error";
+                out.push({ type: "opencode.error", message: error });
+            }
+            return out;
+        },
+        finish() {
+            const structuralError = openStep
+                ? "OpenCode stream ended while a step was still open"
+                : awaitingContinuation
+                    ? "OpenCode stream ended before the required continuation"
+                    : lastStepVoid
+                        ? "OpenCode stream ended on an empty step"
+                        : !sawEvent || !sawStepFinish
+                            ? "OpenCode stream ended with no events proving completion"
+                            : null;
+            const failure = error ?? structuralError;
+            return {
+                ok: failure === null,
+                ...(failure === null ? {} : { error: failure }),
+                finalText,
+                sessionId,
+                ...(sawStepFinish ? { usage } : {}),
+            };
+        },
+    };
+}

package/dist/serve.js

@@ -8,7 +8,8 @@ import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, daemonCapabilities, EXECUTION_PROTOCOL, } from "./machine-info.js";
+import { collectMachineHello, cliVersion, daemonVersion, daemonCapabilities, detectExecutionRuntimesWithSignal, EXECUTION_PROTOCOL, } from "./machine-info.js";
+import { conservativeExecutionRuntimes, createRuntimeProbeCoordinator, } from "./runtime-probe.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
 import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
@@ -79,6 +80,7 @@ export function serve(config, opts = {}) {
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     let detectedExecutionRuntimes = [];
     let runtimeFacts = null;
+    const runtimeProbe = createRuntimeProbeCoordinator();
     const hostCoordinator = opts.execution?.hostCoordinator ?? createHostExecutionCoordinator();
     const localSlots = createSharedSlotManager(config.executionLimits);
     const sharedSlots = hostCoordinatedSlotManager(localSlots, hostCoordinator);
@@ -280,7 +282,7 @@ export function serve(config, opts = {}) {
             reservation.release();
     };
     let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
-    initSlog(config.serverUrl, config.machineToken);
+    initSlog(config.serverUrl, config.machineToken, { daemonVersion: daemonVersion(), cliVersion: cliVersion(), ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }), agentsRoot: config.agentsRoot });
     dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
     // scheduled 重复 run 仍由 running 去重;普通同线程 wake 用 legacyTaskTails 串成 FIFO。
@@ -303,7 +305,11 @@ export function serve(config, opts = {}) {
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
+            const { detectInstalled, detectExecutable = detectExecutionRuntimesWithSignal } = opts.machineInfo ?? {};
             const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits, process.platform, {
+                ...(detectInstalled ? { detectInstalled } : {}),
+                // First hello must not wait for third-party handshakes; optional transports arrive in the refresh.
+                detectExecutable: async (installed) => conservativeExecutionRuntimes(installed),
                 additionalCapabilities: async () => {
                     try {
                         return (await updateEligibility()).eligible ? ["daemon_update_v1"] : [];
@@ -313,7 +319,21 @@ export function serve(config, opts = {}) {
                     }
                 },
             });
-            runtimeFacts = helloPromise.then((hello) => hello.executionRuntimes, (error) => {
+            runtimeFacts = helloPromise
+                .then(async (hello) => {
+                if (hello.executionProtocol === undefined)
+                    return [];
+                const detected = await runtimeProbe.detect(hello.runtimes, detectExecutable);
+                if (ws === openedSocket && openedSocket.readyState === WebSocket.OPEN
+                    && detected.some((runtime) => !hello.executionRuntimes.includes(runtime))) {
+                    detectedExecutionRuntimes = detected;
+                    latestMachineHello = { ...hello, executionRuntimes: [...detected] };
+                    latestHelloSocket = openedSocket;
+                    sendEffectiveMachineHello();
+                }
+                return detected;
+            })
+                .catch((error) => {
                 dslog("execution.runtime_detection_failed", "runtime 探测失败", {
                     level: "ERROR", error_message: error.message,
                 });
@@ -552,7 +572,9 @@ export function serve(config, opts = {}) {
                     let availableRuntimes;
                     try {
                         availableRuntimes = opts.execution?.availableRuntimes?.()
-                            ?? await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes));
+                            ?? (detectedExecutionRuntimes.includes(spec.runtime.name)
+                                ? detectedExecutionRuntimes
+                                : await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes)));
                     }
                     catch (error) {
                         cleanupExecutionReservation();
@@ -1111,6 +1133,7 @@ export function serve(config, opts = {}) {
             return stopPromise;
         stopPromise = (async () => {
             stopped = true;
+            runtimeProbe.stop();
             completionRetransmitter.stop();
             const deadline = createShutdownDeadline(shutdownTimeoutMs);
             if (reconnectTimer !== null) {

package/dist/slog.js

@@ -12,7 +12,8 @@
  */
 import { hostname } from "node:os";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 const FLUSH_INTERVAL_MS = 1500;
 const BATCH_SIZE = 50;
@@ -30,11 +31,28 @@ function spoolDir() {
     return process.env.CREW_SLS_SPOOL_DIR ?? join(homedir(), ".crew", "logs", "sls-spool");
 }
 /** serve/run 启动时调用一次;disabled(CREW_SLS_LOG=off)则保持 no-op。 */
-export function initSlog(serverUrl, machineToken) {
+export function initSlog(serverUrl, machineToken, identity = {}) {
     if (process.env.CREW_SLS_LOG === "off" || process.env.CREW_SLS_LOG === "0")
         return;
     cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
-    defaults = { host: hostname(), pid: process.pid };
+    let serverHost;
+    try {
+        serverHost = new URL(serverUrl).hostname || undefined;
+    }
+    catch {
+        serverHost = undefined;
+    }
+    defaults = {
+        host: hostname(),
+        pid: process.pid,
+        daemon_version: identity.daemonVersion,
+        cli_version: identity.cliVersion,
+        daemon_profile: identity.profileName,
+        server_host: serverHost,
+        agents_root_fingerprint: identity.agentsRoot === undefined
+            ? undefined
+            : createHash("sha256").update(resolve(identity.agentsRoot), "utf8").digest("hex"),
+    };
     // 退出兜底:残余队列同步落 spool(exit 回调只能做同步工作,append 正合适)
     if (!exitHookInstalled) {
         exitHookInstalled = true;

package/dist/supervised-runtime.js

@@ -56,15 +56,36 @@ export function supervisorLaunch(request) {
             }),
         };
     }
+    if (request.runtime === "opencode") {
+        if (request.effectivePermission !== "full_access") {
+            throw new Error(`OpenCode cannot enforce ${request.effectivePermission} permission`);
+        }
+        return {
+            command: process.execPath,
+            args: [
+                fileURLToPath(new URL("./runtimes/opencode-runner.js", import.meta.url)),
+                "--bin", request.bin,
+                ...(request.model === undefined ? [] : ["--model", request.model]),
+                ...(request.reasoning === undefined ? [] : ["--reasoning", request.reasoning]),
+                ...(request.sessionId === undefined ? [] : ["--session", request.sessionId]),
+            ],
+            cwd: request.cwd,
+            env: { ...request.env, PWD: request.cwd },
+            stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+        };
+    }
     if (request.effectivePermission !== "full_access") {
-        throw new Error(`Kimi ACP cannot enforce ${request.effectivePermission} permission`);
+        const displayName = request.runtime === "hermes" ? "Hermes" : "Kimi";
+        throw new Error(`${displayName} ACP cannot enforce ${request.effectivePermission} permission`);
     }
     return {
         command: process.execPath,
         args: [
             fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
+            "--provider", request.runtime,
             "--bin", request.bin,
             ...(request.model === undefined ? [] : ["--model", request.model]),
+            ...(request.reasoning === undefined ? [] : ["--reasoning", request.reasoning]),
             ...(request.sessionId === undefined ? [] : ["--session", request.sessionId]),
             ...(request.resume ? ["--resume"] : []),
         ],

package/dist/workspace.js

@@ -10,6 +10,7 @@
 import { mkdir, writeFile, readFile, chmod, access } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
+import { dslog } from "./slog.js";
 /** 文件系统安全的 taskKey:仅留 [\w.-],其余转 _,截断,避免路径穿越/超长。 */
 export function safeKey(key) {
     return key.replace(/[^\w.-]+/g, "_").replace(/^[-.]+/, "").slice(0, 80) || "default";
@@ -38,10 +39,24 @@ export async function prepareWorkspace(input) {
     await mkdir(crewDir, { recursive: true });
     // MEMORY.md:首次创建"索引 + Active Context"骨架,之后由 agent 自己维护
     const memoryPath = join(dir, "MEMORY.md");
-    if (!(await exists(memoryPath))) {
-        await writeFile(memoryPath, memorySeed(input.handle, input.description), "utf8");
+    const memorySeedCreated = !(await exists(memoryPath));
+    if (memorySeedCreated) {
+        try {
+            await writeFile(memoryPath, memorySeed(input.handle, input.description), "utf8");
+        }
+        catch (error) {
+            logMemoryPrepareFailure(input, "memory_seed_write", error);
+            throw error;
+        }
+    }
+    let memory;
+    try {
+        memory = await readFile(memoryPath, "utf8");
+    }
+    catch (error) {
+        logMemoryPrepareFailure(input, "memory_read", error);
+        throw error;
     }
-    const memory = await readFile(memoryPath, "utf8");
     // 系统提示词按 execution 隔离;省略 identity 的兼容调用每次使用随机路径。
     const promptDir = join(crewDir, "prompts");
     await mkdir(promptDir, { recursive: true });
@@ -93,6 +108,7 @@ export async function prepareWorkspace(input) {
         crewDir,
         systemPromptPath,
         memory,
+        memorySeedCreated,
         homeDir,
         runDir,
         workLogPath,
@@ -102,6 +118,21 @@ export async function prepareWorkspace(input) {
         sessionDir,
     };
 }
+function logMemoryPrepareFailure(input, phase, error) {
+    try {
+        dslog("local_memory.context_prepare_failed", "本地记忆上下文准备失败", {
+            level: "WARN",
+            execution_id: input.executionId,
+            agent_handle: input.handle,
+            failure_phase: phase,
+            error_name: error instanceof Error ? error.name : "unknown",
+            error_code: error?.code,
+        });
+    }
+    catch {
+        // Diagnostics cannot replace the original workspace error.
+    }
+}
 /**
  * 冷启动时轮换会话 id:写入新 uuid 到 <runDir>/.session 并返回。
  * 已有会话但本轮决定不续用(warm 窗口过期 / CREW_RESUME=off)时调用——起一个全新会话,

package/package.json

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