@nowcrew/daemon 0.5.18 → 0.5.20

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

@@ -1,5 +1,43 @@
 export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi"];
+export const LOCAL_RUNTIME_CAPABILITIES = Object.freeze({
+    claude: Object.freeze({
+        transport: "claude-stream-json",
+        nativeResume: true,
+        systemPromptTransport: "file",
+    }),
+    codex: Object.freeze({
+        transport: "codex-app-server",
+        nativeResume: true,
+        systemPromptTransport: "protocol",
+    }),
+    kimi: Object.freeze({
+        transport: "kimi-acp",
+        nativeResume: true,
+        systemPromptTransport: "protocol",
+    }),
+});
+export function runtimeCapability(runtime) {
+    return LOCAL_RUNTIME_CAPABILITIES[runtime];
+}
 const LOCAL_EXECUTION_RUNTIME_SET = new Set(LOCAL_EXECUTION_RUNTIMES);
 export function executableRuntimes(installed) {
     return [...new Set(installed)].filter((runtime) => LOCAL_EXECUTION_RUNTIME_SET.has(runtime));
 }
+export function routeRuntimeAttachments(runtime, attachments) {
+    if (attachments.length === 0)
+        return { nativeImagePaths: [], promptSuffix: "" };
+    const lines = attachments.map((attachment) => `- ${JSON.stringify(attachment.path)} (${attachment.mime}, ${attachment.sizeBytes} bytes)`);
+    return {
+        nativeImagePaths: runtime === "codex"
+            ? attachments.filter((attachment) => attachment.mime.startsWith("image/"))
+                .map((attachment) => attachment.path)
+            : [],
+        promptSuffix: [
+            "",
+            "",
+            "## Files attached to the triggering message",
+            "These files were downloaded into the local execution workspace. Open/read the relevant files before describing their contents; do not infer contents from filenames alone.",
+            ...lines,
+        ].join("\n"),
+    };
+}

package/dist/runtime-path.js

@@ -0,0 +1,60 @@
+/**
+ * daemon 被非登录/非交互进程(sh -c / pnpm script / tmux / 后台转发)拉起时,继承的 PATH 常退化为系统
+ * 默认,缺用户级 CLI 目录——尤其 Claude 官方原生安装器默认的 `~/.local/bin`。结果 `which claude` 探测
+ * 落空、真正 spawn 也 ENOENT。Kimi 官方安装器同样只把 `~/.kimi-code/bin` 写入 shell rc。
+ * 这里在探测与启动前把常见安装目录补进 PATH,保证「扫得到 = 起得来」。
+ *
+ * codex 装在 `/usr/local/bin`(系统默认 PATH 本就含之)所以不受影响;本模块对已在 PATH 中的目录是无操作。
+ */
+import { existsSync } from "node:fs";
+import { win32, posix } from "node:path";
+const pathApi = (platform) => (platform === "win32" ? win32 : posix);
+/** 该平台常见 CLI 安装目录候选(是否真实存在稍后由 augmentedPath 校验)。 */
+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, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+            p.join(env.USERPROFILE, ".local", "bin"));
+        }
+        if (env.APPDATA)
+            dirs.push(p.join(env.APPDATA, "npm"));
+        if (env.LOCALAPPDATA)
+            dirs.push(p.join(env.LOCALAPPDATA, "Microsoft", "WindowsApps"));
+        return dirs;
+    }
+    const dirs = [];
+    const home = env.HOME;
+    if (home) {
+        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 全局
+    if (home) {
+        dirs.push(p.join(home, ".npm-global", "bin"), p.join(home, ".bun", "bin"), p.join(home, ".deno", "bin"));
+    }
+    return dirs;
+}
+/**
+ * 在 `env.PATH` 基础上,把候选目录里「真实存在且尚未在 PATH 中」的去重后 prepend,返回新的 PATH 字符串。
+ * 用户装的目录优先命中(prepend);全部已存在或都不在磁盘上时,原样返回 `env.PATH`。
+ */
+export function augmentedPath(env = process.env, deps = {}, platform = process.platform) {
+    const dirExists = deps.dirExists ?? existsSync;
+    const sep = pathApi(platform).delimiter;
+    const current = env.PATH ?? "";
+    const existing = new Set(current.split(sep).filter((entry) => entry.length > 0));
+    const extra = [];
+    for (const dir of commonBinDirs(env, platform)) {
+        if (existing.has(dir) || extra.includes(dir))
+            continue;
+        if (!dirExists(dir))
+            continue;
+        extra.push(dir);
+    }
+    if (extra.length === 0)
+        return current;
+    return current.length > 0 ? `${extra.join(sep)}${sep}${current}` : extra.join(sep);
+}

package/dist/runtimes/claude.js

@@ -4,22 +4,27 @@
 // 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",
         "--verbose",
         "--output-format",
         "stream-json",
+        "--include-partial-messages",
         "--append-system-prompt-file",
         input.systemPromptPath,
     ];
     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-app-server-runner.js

@@ -0,0 +1,340 @@
+import { once } from "node:events";
+import { createInterface } from "node:readline";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { z } from "zod";
+import { startFirstProgressWatchdog } from "./progress-watchdog.js";
+const RunnerInputSchema = z.object({
+    systemPrompt: z.string().min(1),
+    wakePrompt: z.string().min(1),
+    effectivePermission: z.enum(["sandboxed", "workspace_write", "full_access"]),
+    model: z.string().min(1).optional(),
+    reasoning: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    imagePaths: z.array(z.string().min(1)).optional(),
+    resume: z.boolean(),
+}).strict();
+const RPC_TIMEOUT_MS = 30_000;
+const ERROR_MESSAGE_CAP = 2_000;
+function safeErrorMessage(error, secrets) {
+    let message = error instanceof Error ? error.message : String(error);
+    for (const secret of secrets) {
+        if (secret)
+            message = message.replaceAll(secret, "[prompt redacted]");
+    }
+    return message.slice(0, ERROR_MESSAGE_CAP);
+}
+function jsonLine(event) {
+    if (process.stdout.write(`${JSON.stringify(event)}\n`))
+        return Promise.resolve();
+    return once(process.stdout, "drain").then(() => undefined);
+}
+function sandboxMode(permission) {
+    if (permission === "sandboxed")
+        return "read-only";
+    if (permission === "workspace_write")
+        return "workspace-write";
+    return "danger-full-access";
+}
+/** Unexpected approval requests fail closed; only explicit full access may approve operations. */
+export function codexApprovalResponse(method, permission) {
+    if (method === "item/commandExecution/requestApproval"
+        || method === "item/fileChange/requestApproval") {
+        return { decision: permission === "full_access" ? "accept" : "decline" };
+    }
+    if (method === "item/tool/requestUserInput")
+        return { answers: {} };
+    return null;
+}
+/** Translate app-server v2 notifications into the daemon's existing runtime event contract. */
+export function mapCodexNotification(method, params) {
+    const value = params;
+    if (method === "thread/started" && value.thread?.id) {
+        return [{ type: "thread.started", thread_id: value.thread.id }];
+    }
+    if (method !== "item/completed" || value.item === undefined)
+        return [];
+    if (value.item.type === "agentMessage" && value.item.text) {
+        return [{ type: "item.completed", item: { type: "agent_message", text: value.item.text } }];
+    }
+    if (value.item.type === "commandExecution" && value.item.command) {
+        return [{
+                type: "item.completed",
+                item: {
+                    type: "command_execution",
+                    command: value.item.command,
+                    ...(value.item.status === undefined ? {} : { status: value.item.status }),
+                    ...(value.item.aggregatedOutput == null ? {} : { aggregated_output: value.item.aggregatedOutput }),
+                },
+            }];
+    }
+    return [];
+}
+async function readRunnerInput() {
+    process.stdin.setEncoding("utf8");
+    let raw = "";
+    for await (const chunk of process.stdin)
+        raw += String(chunk);
+    return RunnerInputSchema.parse(JSON.parse(raw));
+}
+class CodexRpcClient {
+    child;
+    permission;
+    onNotification;
+    onFatal;
+    nextId = 1;
+    pending = new Map();
+    closedError = null;
+    constructor(child, permission, onNotification, onFatal) {
+        this.child = child;
+        this.permission = permission;
+        this.onNotification = onNotification;
+        this.onFatal = onFatal;
+        if (child.stdin === null || child.stdout === null) {
+            throw new Error("Codex app-server did not expose stdio");
+        }
+        const lines = createInterface({ input: child.stdout });
+        child.stdin.on("error", (error) => this.close(error));
+        lines.on("line", (line) => {
+            void this.receive(line).catch((error) => {
+                this.close(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+        child.once("error", (error) => this.close(error));
+        child.once("close", (code, signal) => {
+            this.close(new Error(`Codex app-server exited: code=${code} signal=${signal}`));
+        });
+    }
+    request(method, params, timeoutMs = RPC_TIMEOUT_MS) {
+        if (this.closedError !== null)
+            return Promise.reject(this.closedError);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex app-server ${method} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.write({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: "2.0", method, ...(params === undefined ? {} : { params }) });
+    }
+    write(message) {
+        if (this.child.stdin === null || this.child.stdin.destroyed) {
+            throw this.closedError ?? new Error("Codex app-server stdin is closed");
+        }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    async receive(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            process.stderr.write(`Codex app-server emitted invalid JSON: ${line.slice(0, 500)}\n`);
+            return;
+        }
+        if (message.id !== undefined && message.method !== undefined) {
+            const result = codexApprovalResponse(message.method, this.permission);
+            if (result === null) {
+                this.write({
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    error: { code: -32001, message: `NowCrew denied unsupported request ${message.method}` },
+                });
+            }
+            else {
+                this.write({ jsonrpc: "2.0", id: message.id, result });
+            }
+            return;
+        }
+        if (message.id !== undefined) {
+            const pending = this.pending.get(message.id);
+            if (pending === undefined)
+                return;
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error !== undefined) {
+                pending.reject(new Error(`Codex app-server RPC failed: ${message.error.message ?? "unknown error"}`));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (message.method !== undefined)
+            await this.onNotification(message.method, message.params);
+    }
+    close(error) {
+        if (this.closedError !== null)
+            return;
+        this.closedError = error;
+        this.onFatal(error);
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+async function stopChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = once(child, "close").then(() => undefined);
+    child.kill("SIGTERM");
+    let timer;
+    const graceful = await Promise.race([
+        closed.then(() => true),
+        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    if (!graceful && child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+        await closed;
+    }
+}
+export async function runCodexAppServer(bin) {
+    const input = await readRunnerInput();
+    const child = spawn(bin, ["app-server", "--listen", "stdio://"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    child.stderr?.pipe(process.stderr, { end: false });
+    let threadId = null;
+    let announcedThreadId = null;
+    let turnId = null;
+    let lastUsage;
+    let completionResolve;
+    let completionReject;
+    const completion = new Promise((resolve, reject) => {
+        completionResolve = resolve;
+        completionReject = reject;
+    });
+    void completion.catch(() => undefined);
+    let firstProgress = startFirstProgressWatchdog(() => undefined);
+    firstProgress.stop();
+    const rpc = new CodexRpcClient(child, input.effectivePermission, async (method, params) => {
+        if (method === "thread/tokenUsage/updated") {
+            lastUsage = params.tokenUsage;
+        }
+        if (method === "turn/started" || method === "item/started"
+            || method === "item/agentMessage/delta" || method === "item/completed") {
+            firstProgress.observe();
+        }
+        for (const event of mapCodexNotification(method, params)) {
+            const eventThreadId = typeof event.thread_id === "string" ? event.thread_id : null;
+            if (event.type === "thread.started" && eventThreadId === announcedThreadId)
+                continue;
+            if (event.type === "thread.started")
+                announcedThreadId = eventThreadId;
+            await jsonLine(event);
+        }
+        if (method === "turn/completed")
+            completionResolve(params);
+        if (method === "error" && params.willRetry === false) {
+            const detail = params.error?.message;
+            if (detail)
+                process.stderr.write(`Codex turn error: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
+        }
+    }, completionReject);
+    let cancelling = false;
+    const cancel = async () => {
+        if (cancelling)
+            return;
+        cancelling = true;
+        if (threadId !== null && turnId !== null) {
+            await rpc.request("turn/interrupt", { threadId, turnId }, 5_000).catch(() => undefined);
+        }
+        await stopChild(child);
+    };
+    const onSignal = () => { void cancel().finally(() => process.exit(130)); };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+    try {
+        await rpc.request("initialize", {
+            clientInfo: { name: "nowcrew-daemon", version: "1" },
+            capabilities: { experimentalApi: true, requestAttestation: false },
+        });
+        rpc.notify("initialized");
+        const threadParams = {
+            cwd: process.cwd(),
+            approvalPolicy: "never",
+            sandbox: sandboxMode(input.effectivePermission),
+            developerInstructions: input.systemPrompt,
+            ...(input.model === undefined ? {} : { model: input.model }),
+        };
+        const thread = input.resume && input.sessionId !== undefined
+            ? await rpc.request("thread/resume", { threadId: input.sessionId, ...threadParams })
+            : await rpc.request("thread/start", threadParams);
+        threadId = thread.thread.id;
+        if (announcedThreadId !== threadId) {
+            announcedThreadId = threadId;
+            await jsonLine({ type: "thread.started", thread_id: threadId });
+        }
+        firstProgress = startFirstProgressWatchdog(() => {
+            completionReject(new Error("Codex produced no semantic progress within the startup window"));
+            void cancel();
+        });
+        const started = await rpc.request("turn/start", {
+            threadId,
+            input: [
+                { type: "text", text: input.wakePrompt, text_elements: [] },
+                ...(input.imagePaths ?? []).map((path) => ({ type: "localImage", path })),
+            ],
+            ...(input.reasoning === undefined || input.reasoning === "default"
+                ? {}
+                : { effort: input.reasoning }),
+        });
+        turnId = started.turn.id;
+        const completed = await completion;
+        firstProgress.stop();
+        const usage = lastUsage?.last;
+        await jsonLine({
+            type: "turn.completed",
+            ...(usage === undefined ? {} : {
+                usage: {
+                    input_tokens: usage.inputTokens ?? 0,
+                    output_tokens: usage.outputTokens ?? 0,
+                    cached_input_tokens: usage.cachedInputTokens ?? 0,
+                },
+            }),
+        });
+        if (completed.turn?.status === "completed")
+            return 0;
+        const detail = completed.turn?.error?.message ?? `turn status ${completed.turn?.status ?? "unknown"}`;
+        process.stderr.write(`Codex turn failed: ${detail.slice(0, ERROR_MESSAGE_CAP)}\n`);
+        return completed.turn?.status === "interrupted" ? 130 : 1;
+    }
+    catch (error) {
+        process.stderr.write(`Codex app-server execution failed: ${safeErrorMessage(error, [input.systemPrompt, input.wakePrompt])}\n`);
+        return 1;
+    }
+    finally {
+        firstProgress.stop();
+        process.off("SIGTERM", onSignal);
+        process.off("SIGINT", onSignal);
+        await stopChild(child);
+    }
+}
+function binFromArgv(argv) {
+    const { values } = parseArgs({
+        args: [...argv],
+        options: { bin: { type: "string" } },
+    });
+    if (!values.bin)
+        throw new Error("--bin is required");
+    return values.bin;
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runCodexAppServer(binFromArgv(process.argv.slice(2)))
+        .then((code) => { process.exitCode = code; })
+        .catch((error) => {
+        process.stderr.write(`Codex app-server runner failed: ${safeErrorMessage(error, [])}\n`);
+        process.exitCode = 1;
+    });
+}

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")
@@ -23,6 +27,8 @@ export function buildCodexArgs(input) {
     else if (input.effectivePermission === "full_access" || (input.effectivePermission === undefined && input.dangerous)) {
         args.push("--dangerously-bypass-approvals-and-sandbox");
     }
+    for (const imagePath of input.imagePaths ?? [])
+        args.push("--image", imagePath);
     // `-` instructs codex exec to read the prompt from stdin. Keeping the complete prompt out of argv
     // avoids Windows' command-line length limit when a thread carries a large wake context.
     args.push("-");