@nowcrew/daemon 0.5.18 → 0.5.19

package/dist/prompt.js

@@ -147,7 +147,10 @@ ${taskAndScheduleCommands}`;
         : ctx.wakeOrigin === "wecom"
             ? `
 - **本轮来自企微，结束本轮前必须给出一条完整回复**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。最终只用一次 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）发送有实质内容的完整结果；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定，并在本轮未形成可交付内容时发送统一兜底回复。`
-            : `
+            : ctx.wakeOrigin
+                ? `
+- **本轮来自${ctx.wakeOrigin === "feishu" ? "飞书" : ctx.wakeOrigin}，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复外部会话时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。`
+                : `
 - **本轮是 NowWork 内部唤醒**:普通 \`crew message send\` 只写入 NowWork。内部唤醒不得使用 \`--reply-origin\`，该参数只回答直接触发本轮的企微原消息。
 - **绑定会话主动通知**:用户明确要求同步，或最终结果有实质结论、变更或需群用户行动的阻塞时，才用一次 \`crew message send --notify-bound-im\`（同时带当前 channel/thread/content 参数）请求通知当前频道绑定的外部会话。Server 会校验绑定 owner 授权、绑定 Agent 和单轮边界；不能指定收件人。确认、进度、中间结果、无变化和重复内容一律留在 NowWork。`;
     const interactiveTaskRules = scheduled ? "" : `

package/dist/runner.js

@@ -29,7 +29,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
     const baseWake = input.wake ?? buildWakePrompt(input.channelId);
     const executionId = input.runId ?? `legacy-${randomUUID()}`;
-    const originDecisionFileName = input.wakeOrigin === "wecom"
+    const originDecisionFileName = input.wakeOrigin
         ? `.origin-decision-${executionId}.json`
         : null;
     const boundImDecisionFileName = input.scheduled?.externalNotificationPolicy === "agent_decides"
@@ -86,7 +86,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
                 ...(providerConfig.fastMode ? { CREW_FAST_MODE: "1" } : {}),
                 ...(input.scheduled ? { CREW_SCHEDULE_OUTPUT_POLICY: input.scheduled.outputPolicy } : {}),
                 ...(originDecisionFileName ? {
-                    CREW_WAKE_ORIGIN: "wecom",
+                    CREW_WAKE_ORIGIN: input.wakeOrigin,
                     CREW_ORIGIN_DECISION_FILE: originDecisionFileName,
                 } : {}),
                 ...(boundImDecisionFileName ? {
@@ -169,7 +169,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         ...(local.usage ? { usage: local.usage } : {}),
         ...(report ? { report } : {}),
         ...(boundImDecision ? { boundImDecision } : {}),
-        ...(input.wakeOrigin === "wecom" ? {
+        ...(input.wakeOrigin ? {
             originDecision: originDecision?.decision ?? "missing",
             ...(originDecision?.decision === "silent" && originDecision.reason
                 ? { originDecisionReason: originDecision.reason }

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,56 @@
+/**
+ * daemon 被非登录/非交互进程(sh -c / pnpm script / tmux / 后台转发)拉起时,继承的 PATH 常退化为系统
+ * 默认,缺用户级 CLI 目录——尤其 Claude 官方原生安装器默认的 `~/.local/bin`。结果 `which claude` 探测
+ * 落空、真正 spawn 也 ENOENT。这里在探测与启动前把常见安装目录补进 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, ".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, ".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

@@ -12,6 +12,7 @@ export function buildClaudeArgs(input) {
         "--verbose",
         "--output-format",
         "stream-json",
+        "--include-partial-messages",
         "--append-system-prompt-file",
         input.systemPromptPath,
     ];

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

@@ -23,6 +23,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("-");