@nowcrew/daemon 0.5.19 → 0.5.20

package/dist/main.js

@@ -6,15 +6,17 @@
  * 后续 (M3c):常驻 + 连 server 控制面 WS,由 agent:start 自动唤醒。
  */
 import { parseArgs } from "node:util";
+import { homedir } from "node:os";
 import { loadConfig, ConfigError } from "./config.js";
-import { detectDaemonLang, translateDaemon } from "./i18n.js";
+import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
 import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
 import { initSlog, flushSlog } from "./slog.js";
 import { formatDaemonLogLine } from "./log-format.js";
-import { loadProfile, applyProfileToEnv } from "./computer-profile.js";
+import { applyProfileToEnv, assertProfileAgentsRootUnique, daemonHome, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, } from "./computer-profile.js";
 import { runComputerCommand } from "./computer-cli.js";
+import { runServeLifecycle } from "./serve-lifecycle.js";
 async function main() {
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
@@ -51,8 +53,13 @@ async function main() {
     // 不把 machine token 放进 argv / plist / systemd unit / scheduled task。
     if (values["daemon-home"])
         process.env.CREW_DAEMON_HOME = values["daemon-home"];
-    if (values.profile)
-        applyProfileToEnv(await loadProfile(values.profile), process.env);
+    if (values.profile) {
+        const home = daemonHome();
+        const profile = await loadProfile(values.profile, home);
+        if (cmd === "serve")
+            await assertProfileAgentsRootUnique(profile, home, homedir());
+        applyProfileToEnv(profile, process.env);
+    }
     // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
     if (values["server-url"])
         process.env.CREW_SERVER_URL = values["server-url"];
@@ -72,8 +79,8 @@ async function main() {
     }
     if (cmd === "serve") {
         process.stdout.write(formatDaemonLogLine(`🛰️  crew-daemon v${daemonVersion()} (cli v${cliVersion()}) ${td("resident, connecting to")} ${config.serverUrl} ${td("control plane")}...`) + "\n");
-        serve(config);
-        await new Promise(() => { }); // 常驻,直到被 kill
+        const service = serve(config);
+        await runServeLifecycle(service);
         return;
     }
     if (!values.agent || !values.channel) {
@@ -93,6 +100,14 @@ async function main() {
     process.exit(result.exitCode);
 }
 main().catch((e) => {
-    process.stderr.write(`crew-daemon: ${e.message}\n`);
-    process.exit(1);
+    const message = e instanceof ProfileAgentsRootConflictError
+        ? formatDaemonText(detectDaemonLang(), PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
+            profile: e.profile,
+            conflict: e.conflict,
+            agentsRoot: e.agentsRoot,
+            command: e.command,
+        })
+        : e.message;
+    process.stderr.write(`crew-daemon: ${message}\n`);
+    process.exitCode = 1;
 });

package/dist/runner.js

@@ -4,10 +4,12 @@ import { join } from "node:path";
 import { mintAgentToken } from "./token.js";
 import { buildSystemPrompt, buildWakePrompt, capMemoryForInject, capWorkLogForInject } from "./prompt.js";
 import { deliverScheduledReport, } from "./scheduled-report.js";
-import { executeLocal } from "./local-executor.js";
+import { executeLocal, } from "./local-executor.js";
 import { ReasoningSchema } from "./execution-protocol.js";
 import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decision.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
+import { launchSupervisedRuntime } from "./supervised-runtime.js";
+import { awaitWithCancellation, } from "./runtime-cancellation.js";
 export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
@@ -18,12 +20,12 @@ function runtimeName(value) {
         return value;
     throw new Error(`unsupported runtime: ${value}`);
 }
-export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }) {
-    const credential = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, {
+export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
+    const credential = await awaitWithCancellation((dependencies.mintAgentToken ?? mintAgentToken)(config.serverUrl, config.machineToken, input.handle, input.displayName, {
         ...(input.wakeMessageId ? { wakeThreadRoot: input.wakeMessageId } : {}),
         ...(input.wakeContextUpToSeq === undefined ? {} : { wakeContextUpToSeq: input.wakeContextUpToSeq }),
         ...(input.runId ? { agentRunId: input.runId } : {}),
-    });
+    }), dependencies.cancellation);
     const providerConfig = credential.config ?? {};
     const runtime = runtimeName(providerConfig.runtime ?? config.runtimeBin);
     const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
@@ -35,7 +37,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     const boundImDecisionFileName = input.scheduled?.externalNotificationPolicy === "agent_decides"
         ? `.bound-im-decision-${executionId}.json`
         : null;
-    const local = await executeLocal({
+    const local = await (dependencies.executeLocal ?? executeLocal)({
         executionId,
         handle: input.handle,
         channelId: input.channelId,
@@ -101,7 +103,10 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             softTokens: config.sessionSoftTokens,
             maxTurns: config.sessionMaxTurns,
         },
-    }, { onActivity, onConsole });
+    }, { onActivity, onConsole }, {
+        launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
+        ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+    });
     const activities = [...local.activities];
     if (!input.scheduled && (runtime === "codex" || runtime === "kimi")
         && local.exitCode === 0 && !local.sentViaCrew && local.finalText) {

package/dist/runtime-cancellation.js

@@ -0,0 +1,74 @@
+export class RuntimeCancelledError extends Error {
+    constructor(message = "Runtime launch cancelled") {
+        super(message);
+        this.name = "RuntimeCancelledError";
+    }
+}
+export async function awaitWithCancellation(promise, cancellation) {
+    if (cancellation === undefined)
+        return promise;
+    if (cancellation.isRequested())
+        throw new RuntimeCancelledError();
+    const result = await Promise.race([
+        promise,
+        cancellation.requested.then(() => { throw new RuntimeCancelledError(); }),
+    ]);
+    if (cancellation.isRequested())
+        throw new RuntimeCancelledError();
+    return result;
+}
+export function createRuntimeCancellation() {
+    let requested = false;
+    let resolveRequested;
+    const requestedPromise = new Promise((resolve) => { resolveRequested = resolve; });
+    const registrations = new Map();
+    const startRegisteredStops = () => {
+        if (!requested)
+            return;
+        for (const [cancel, stopPromise] of registrations) {
+            if (stopPromise !== null)
+                continue;
+            const started = Promise.resolve().then(cancel);
+            registrations.set(cancel, started);
+            void started.catch(() => undefined);
+        }
+    };
+    const waitForStop = async () => {
+        if (!requested)
+            return;
+        while (true) {
+            startRegisteredStops();
+            const registrationCount = registrations.size;
+            const results = await Promise.allSettled([...registrations.values()].filter((value) => value !== null));
+            if (registrations.size !== registrationCount)
+                continue;
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, "Runtime cancellation failed");
+            return;
+        }
+    };
+    const cancellation = {
+        isRequested: () => requested,
+        requested: requestedPromise,
+        register: (next) => {
+            if (registrations.has(next))
+                return;
+            registrations.set(next, null);
+            startRegisteredStops();
+        },
+        waitForStop,
+    };
+    return {
+        cancellation,
+        request: () => {
+            if (requested)
+                return;
+            requested = true;
+            resolveRequested();
+            startRegisteredStops();
+        },
+    };
+}

package/dist/runtime-path.js

@@ -1,7 +1,8 @@
 /**
  * daemon 被非登录/非交互进程(sh -c / pnpm script / tmux / 后台转发)拉起时,继承的 PATH 常退化为系统
  * 默认,缺用户级 CLI 目录——尤其 Claude 官方原生安装器默认的 `~/.local/bin`。结果 `which claude` 探测
- * 落空、真正 spawn 也 ENOENT。这里在探测与启动前把常见安装目录补进 PATH,保证「扫得到 = 起得来」。
+ * 落空、真正 spawn 也 ENOENT。Kimi 官方安装器同样只把 `~/.kimi-code/bin` 写入 shell rc。
+ * 这里在探测与启动前把常见安装目录补进 PATH,保证「扫得到 = 起得来」。
  *
  * codex 装在 `/usr/local/bin`(系统默认 PATH 本就含之)所以不受影响;本模块对已在 PATH 中的目录是无操作。
  */
@@ -13,8 +14,10 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
     const p = pathApi(platform);
     if (platform === "win32") {
         const dirs = [];
-        if (env.USERPROFILE)
-            dirs.push(p.join(env.USERPROFILE, ".local", "bin"));
+        if (env.USERPROFILE) {
+            dirs.push(p.join(env.USERPROFILE, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+            p.join(env.USERPROFILE, ".local", "bin"));
+        }
         if (env.APPDATA)
             dirs.push(p.join(env.APPDATA, "npm"));
         if (env.LOCALAPPDATA)
@@ -24,7 +27,8 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
     const dirs = [];
     const home = env.HOME;
     if (home) {
-        dirs.push(p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
+        dirs.push(p.join(home, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+        p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
         p.join(home, ".claude", "local"));
     }
     dirs.push("/opt/homebrew/bin", "/usr/local/bin"); // Apple Silicon brew / Intel brew & npm 全局

package/dist/runtimes/claude.js

@@ -4,8 +4,11 @@
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
 // Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
-// 白名单外的值(含 "default" 与 codex 专属档)不传参 → 用 claude 自身默认,脏数据不影响启动。
+// 白名单外的值(含 "default" 与 codex 专属档)回落 CLAUDE_DEFAULT_EFFORT,脏数据不影响启动。
 export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+// 未配置/非法档位时的默认思考强度:medium 开启原生 thinking(终端透传要展示思考过程),
+// 又不至于 high/max 的 token 开销;agent 配置白名单档位可覆盖。
+export const CLAUDE_DEFAULT_EFFORT = "medium";
 export function buildClaudeArgs(input) {
     const args = [
         "--print",
@@ -18,9 +21,10 @@ export function buildClaudeArgs(input) {
     ];
     if (input.model)
         args.push("--model", input.model);
-    if (input.reasoning && CLAUDE_EFFORT_LEVELS.includes(input.reasoning)) {
-        args.push("--effort", input.reasoning);
-    }
+    const effort = input.reasoning && CLAUDE_EFFORT_LEVELS.includes(input.reasoning)
+        ? input.reasoning
+        : CLAUDE_DEFAULT_EFFORT;
+    args.push("--effort", effort);
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }

package/dist/runtimes/codex.js

@@ -5,17 +5,21 @@
 import spawn from "cross-spawn";
 // Codex CLI 原生 model_reasoning_effort 档位(codex 0.135.0 实测:非法值时 config 解析报错枚举这六档)。
 // 注意:codex 对非法值是硬失败(进程直接退出),所以必须白名单过滤;白名单外(含 "default"、
-// claude 专属的 "max")不传 → 用 codex 自身默认。
+// claude 专属的 "max")回落 CODEX_DEFAULT_EFFORT。
 export const CODEX_EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
+// 未配置/非法档位时的默认思考强度:medium 开启 reasoning(终端透传要展示思考过程);
+// 配置白名单档位(含显式 none 关思考)可覆盖。
+export const CODEX_DEFAULT_EFFORT = "medium";
 export function buildCodexArgs(input) {
     // agent 运行目录由 daemon 管理,不是 git 仓库;不带 --skip-git-repo-check 时 codex exec
     // 会以 "Not inside a trusted directory" 秒退(且只报在本地 stderr),表现为 agent 静默不回复。
     const args = ["exec", "--json", "--skip-git-repo-check"];
     if (input.model)
         args.push("--model", input.model);
-    if (input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)) {
-        args.push("-c", `model_reasoning_effort=${input.reasoning}`);
-    }
+    const effort = input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)
+        ? input.reasoning
+        : CODEX_DEFAULT_EFFORT;
+    args.push("-c", `model_reasoning_effort=${effort}`);
     if (input.effectivePermission === "sandboxed")
         args.push("--sandbox", "read-only");
     else if (input.effectivePermission === "workspace_write")

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);
+    }
+}