@nowcrew/daemon 0.5.11 → 0.5.13

package/dist/local-executor.js

@@ -0,0 +1,326 @@
+import { createInterface } from "node:readline";
+import { rm, writeFile } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { prepareWorkspace, rotateAgentSession, } from "./workspace.js";
+import { spawnClaude } from "./runtimes/claude.js";
+import { spawnCodex } from "./runtimes/codex.js";
+import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { applyProviderEnv, providerFingerprint } from "./provider-env.js";
+import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
+import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
+import { toConsoleLines } from "./console.js";
+import { capMemoryForInject, capWorkLogForInject } from "./prompt.js";
+function truncateUtf8(value, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    let bytes = 0;
+    let end = 0;
+    for (const character of value) {
+        const size = Buffer.byteLength(character, "utf8");
+        if (bytes + size > maxBytes)
+            break;
+        bytes += size;
+        end += character.length;
+    }
+    return value.slice(0, end);
+}
+/** v1 server instructions opt in to daemon-owned paths and bounded local workspace context. */
+export function withLocalExecutionFacts(serverPrompt, maxBytes) {
+    return ({ workspace, resuming }) => {
+        const memory = capMemoryForInject(workspace.memory);
+        const workLog = resuming ? "" : capWorkLogForInject(workspace.workLog);
+        const localFacts = `\n\n## Local execution facts
+- $CREW_HOME: ${workspace.dir}
+- $CREW_TASK_LOG: ${workspace.workLogPath}${memory
+            ? `\n\n## Injected MEMORY.md (bounded local context)\n${memory}`
+            : ""}${workLog
+            ? `\n\n## Injected work-log (bounded local context)\n${workLog}`
+            : ""}`;
+        const remaining = maxBytes - Buffer.byteLength(serverPrompt, "utf8");
+        return `${serverPrompt}${truncateUtf8(localFacts, remaining)}`;
+    };
+}
+const STDERR_TAIL_CAP = 2_000;
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_ENV = new Set([
+    "PATH",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+    "GH_CONFIG_DIR",
+    "CLOUDSDK_CONFIG",
+]);
+export function sanitizeEnvVars(raw) {
+    if (!raw)
+        return {};
+    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
+        && ENV_KEY_RE.test(key)
+        && !key.toUpperCase().startsWith("CREW_")
+        && !RESERVED_ENV.has(key.toUpperCase())));
+}
+export function awaitExit(child) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        child.on("error", (error) => settle({ exitCode: -1, spawnError: error.message }));
+        child.on("close", (code, signal) => settle(code === null
+            ? { exitCode: 128, terminationSignal: signal ?? "unknown" }
+            : { exitCode: code }));
+    });
+}
+export function exitActivity(runtime, exitCode, stderrTail) {
+    if ((runtime === "codex" || runtime === "kimi" || exitCode === -1) && exitCode !== 0) {
+        return {
+            kind: "error",
+            label: "运行出错",
+            detail: `${runtime} exited with code ${exitCode}${stderrTail ? `: ${stderrTail}` : ""}`,
+        };
+    }
+    if (runtime === "kimi" && exitCode === 0)
+        return { kind: "done", label: "本轮结束" };
+    return null;
+}
+function wrapChild(child) {
+    return {
+        ...(child.pid === undefined ? {} : { pid: child.pid }),
+        stdout: child.stdout,
+        stderr: child.stderr,
+        exit: awaitExit(child),
+    };
+}
+async function launchLegacyRuntime(request) {
+    const common = {
+        bin: request.bin,
+        cwd: request.cwd,
+        env: request.env,
+        dangerous: request.effectivePermission === "full_access",
+        effectivePermission: request.effectivePermission,
+        ...(request.model === undefined ? {} : { model: request.model }),
+        ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
+    };
+    if (request.runtime === "claude") {
+        return wrapChild(spawnClaude({
+            ...common,
+            systemPromptPath: request.systemPromptPath,
+            wakePrompt: request.wakePrompt,
+            ...(request.sessionId === undefined ? {} : {
+                sessionId: request.sessionId,
+                resume: request.resume,
+            }),
+        }));
+    }
+    if (request.runtime === "codex") {
+        return wrapChild(spawnCodex({
+            ...common,
+            wakePrompt: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+        }));
+    }
+    return wrapChild(spawnKimi({
+        bin: request.bin,
+        cwd: request.cwd,
+        env: request.env,
+        effectivePermission: request.effectivePermission,
+        wakePrompt: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+        ...(request.model === undefined ? {} : { model: request.model }),
+    }));
+}
+function resolvePrompt(prompt, context) {
+    return typeof prompt === "string" ? prompt : prompt(context);
+}
+const nativeSessionLeaseTails = new Map();
+async function withKeyedLease(key, operation) {
+    const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => { release = resolve; });
+    const tail = predecessor.then(() => current);
+    nativeSessionLeaseTails.set(key, tail);
+    await predecessor;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (nativeSessionLeaseTails.get(key) === tail)
+            nativeSessionLeaseTails.delete(key);
+    }
+}
+export async function executeLocal(input, callbacks = {}, dependencies = {}) {
+    if (input.runtime.name !== "claude" || !input.session.enabled) {
+        return executeLocalUnlocked(input, callbacks, dependencies);
+    }
+    const leaseKey = JSON.stringify([
+        input.launch.agentsRoot,
+        input.handle,
+        input.keyMode ?? "legacy",
+        input.resumeKey ?? input.taskKey ?? "",
+    ]);
+    return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies));
+}
+async function executeLocalUnlocked(input, callbacks, dependencies) {
+    const providerConfig = input.launch.providerConfig ?? {};
+    const { runtime } = input;
+    const currentModel = runtime.model ?? null;
+    const providerFp = providerFingerprint(runtime.name, providerConfig);
+    const workspace = await prepareWorkspace({
+        agentsRoot: input.launch.agentsRoot,
+        handle: input.handle,
+        cliPath: input.launch.cliPath,
+        executionId: input.executionId,
+        ...(input.keyMode === undefined ? {} : { keyMode: input.keyMode }),
+        ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+        ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
+        ...(input.launch.description ? { description: input.launch.description } : {}),
+    });
+    try {
+        const supportsNativeResume = runtime.name === "claude";
+        const prior = input.session.enabled && supportsNativeResume
+            ? await readSession(workspace.sessionDir)
+            : null;
+        const resuming = supportsNativeResume && workspace.sessionResume
+            && pickResumeId(prior, Date.now(), input.session.warmMs, currentModel, input.session.budgetTokens, input.session.maxTurns, providerFp) !== null;
+        const rotatedForBudget = !resuming && supportsNativeResume && workspace.sessionResume
+            && pickResumeId(prior, Date.now(), input.session.warmMs, currentModel, 0, 0, providerFp) !== null;
+        const nearBudget = resuming && isNearBudget(prior, input.session.softTokens);
+        const rotated = Boolean(workspace.agentSessionId && workspace.sessionResume && !resuming);
+        const launchSessionId = rotated
+            ? await rotateAgentSession(workspace.sessionDir)
+            : workspace.agentSessionId;
+        const promptContext = {
+            workspace,
+            resuming,
+            rotatedForBudget,
+            nearBudget,
+        };
+        const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
+        const wakePrompt = resolvePrompt(input.wakePrompt, promptContext);
+        await writeFile(workspace.systemPromptPath, systemPrompt, "utf8");
+        const baseEnv = {
+            ...process.env,
+            ...sanitizeEnvVars(providerConfig.envVars),
+            ...input.launch.systemEnv,
+            PATH: `${workspace.crewDir}${delimiter}${process.env.PATH ?? ""}`,
+            CREW_SERVER_URL: input.launch.serverUrl,
+            CREW_TOKEN: input.launch.token,
+            CREW_CHANNEL: input.channelId,
+            CREW_HOME: workspace.dir,
+            CREW_TASK_LOG: workspace.workLogPath,
+            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
+            XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
+            XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
+            XDG_CACHE_HOME: join(workspace.homeDir, ".cache"),
+            GH_CONFIG_DIR: join(workspace.homeDir, ".config", "gh"),
+            CLOUDSDK_CONFIG: join(workspace.homeDir, ".config", "gcloud"),
+            ...(runtime.name === "kimi" && runtime.reasoning
+                && KIMI_EFFORT_LEVELS.includes(runtime.reasoning)
+                ? { KIMI_MODEL_THINKING_EFFORT: runtime.reasoning }
+                : {}),
+        };
+        const childEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir);
+        const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
+        const child = await launchRuntime({
+            runtime: runtime.name,
+            bin: runtime.name,
+            cwd: workspace.runDir,
+            systemPromptPath: workspace.systemPromptPath,
+            systemPrompt,
+            wakePrompt,
+            env: childEnv,
+            effectivePermission: input.effectivePermission,
+            ...(runtime.model === undefined ? {} : { model: runtime.model }),
+            ...(runtime.reasoning === undefined ? {} : { reasoning: runtime.reasoning }),
+            ...(launchSessionId === null ? {} : { sessionId: launchSessionId }),
+            resume: resuming,
+        });
+        const activities = [];
+        let sessionId = launchSessionId;
+        let usage;
+        let observedModel = currentModel;
+        let finalText = null;
+        let sentViaCrew = false;
+        const readline = createInterface({ input: child.stdout });
+        readline.on("line", (line) => {
+            const event = parseLine(line);
+            if (!event)
+                return;
+            const meta = extractRunMeta(event);
+            if (meta.sessionId)
+                sessionId = meta.sessionId;
+            if (meta.usage)
+                usage = meta.usage;
+            if (meta.model)
+                observedModel = meta.model;
+            for (const activity of normalizeEvent(event)) {
+                if (activity.kind === "sending")
+                    sentViaCrew = true;
+                activities.push(activity);
+                callbacks.onActivity?.(activity);
+            }
+            const extracted = extractFinalText(event);
+            if (extracted)
+                finalText = extracted;
+            for (const chunk of toConsoleLines(event))
+                callbacks.onConsole?.(chunk);
+        });
+        let stderrTail = "";
+        child.stderr.on("data", (data) => {
+            process.stderr.write(data);
+            stderrTail = (stderrTail + String(data)).slice(-STDERR_TAIL_CAP);
+        });
+        const { exitCode, spawnError, terminationSignal } = await child.exit;
+        const errorTail = [
+            stderrTail.trim(),
+            spawnError,
+            terminationSignal ? `terminated by ${terminationSignal}` : undefined,
+        ].filter(Boolean).join(" ").trim();
+        const finish = exitActivity(runtime.name, exitCode, errorTail);
+        if (finish) {
+            activities.push(finish);
+            callbacks.onActivity?.(finish);
+            if (finish.kind === "error") {
+                callbacks.onConsole?.({ stream: "error", text: `✖ ${finish.detail ?? finish.label}` });
+            }
+        }
+        if (input.session.enabled && supportsNativeResume && sessionId) {
+            const contextTokens = usage
+                ? usage.inputTokens + usage.cacheReadTokens + usage.cacheCreationTokens
+                : (resuming ? prior?.contextTokens : undefined);
+            await writeSession(workspace.sessionDir, {
+                sessionId,
+                lastRunAt: Date.now(),
+                turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
+                model: currentModel,
+                providerFingerprint: providerFp,
+                lastExitOk: exitCode === 0,
+                ...(contextTokens === undefined ? {} : { contextTokens }),
+            });
+        }
+        return {
+            workspaceRunDir: workspace.runDir,
+            exitCode,
+            ...(terminationSignal === undefined ? {} : { terminationSignal }),
+            activities,
+            ...(usage === undefined ? {} : { usage }),
+            model: observedModel,
+            runtime: runtime.name,
+            resumed: resuming,
+            sessionId,
+            errorMessage: errorTail || null,
+            finalText: input.captureFinal ? finalText : null,
+            sentViaCrew,
+        };
+    }
+    finally {
+        try {
+            await rm(workspace.systemPromptPath, { force: true });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[execution] failed to remove prompt ${workspace.systemPromptPath}: ${detail}\n`);
+        }
+    }
+}

package/dist/machine-info.js

@@ -2,7 +2,7 @@
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
  * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
-import { hostname, arch, platform } from "node:os";
+import { hostname, arch, platform as osPlatform } from "node:os";
 import { lookupCmd } from "./platform.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -12,7 +12,12 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 const execFileP = promisify(execFile);
-export const DAEMON_CAPABILITIES = ["scheduled_job_v1"];
+export const DAEMON_CAPABILITIES = [
+    "scheduled_job_v1",
+    "reply_origin_v1",
+    "origin_decision_v1",
+];
+export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
 const RUNTIME_BINS = [
     ["claude", "claude"],
@@ -72,7 +77,7 @@ async function listAgentHandles(agentsRoot) {
         return [];
     }
 }
-export async function collectMachineHello(agentsRoot) {
+export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform) {
     const [runtimes, agentHandles] = await Promise.all([
         detectRuntimes(),
         listAgentHandles(agentsRoot),
@@ -80,10 +85,14 @@ export async function collectMachineHello(agentsRoot) {
     return {
         type: "machine:hello",
         hostname: hostname(),
-        os: `${platform()} ${arch()}`,
+        os: `${osPlatform()} ${arch()}`,
         daemonVersion: daemonVersion(),
         runtimes,
         capabilities: DAEMON_CAPABILITIES,
+        ...(runtimePlatform === "win32" ? {} : {
+            executionProtocol: EXECUTION_PROTOCOL,
+            executionLimits: Object.freeze({ ...executionLimits }),
+        }),
         agentHandles,
     };
 }

package/dist/origin-decision.js

@@ -0,0 +1,42 @@
+import { readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+export function decisionFilePath(runDir) {
+    return join(runDir, ".origin-decision.json");
+}
+export async function resetOriginDecisionFile(path) {
+    await unlink(path).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+export async function readOriginDecisionFile(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const value = parsed;
+        if (value.decision === "reply")
+            return { decision: "reply" };
+        if (value.decision !== "silent")
+            return null;
+        const reason = typeof value.reason === "string" ? value.reason.trim().slice(0, 500) : "";
+        return { decision: "silent", ...(reason ? { reason } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+export function shouldRetryOriginDecision(wakeOrigin, decision, attempt) {
+    return wakeOrigin === "wecom" && decision === null && attempt === 0;
+}
+export async function runWithOriginDecisionGuard(wakeOrigin, runAttempt) {
+    const first = await runAttempt(0);
+    const firstDecision = first.originDecision === "reply"
+        ? { decision: "reply" }
+        : first.originDecision === "silent" ? { decision: "silent" } : null;
+    if (!shouldRetryOriginDecision(wakeOrigin, firstDecision, 0)) {
+        return { results: [first], final: first };
+    }
+    const retry = await runAttempt(1);
+    return { results: [first, retry], final: retry };
+}

package/dist/prompt.js

@@ -8,6 +8,7 @@
 /** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
  *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
 export const WORKLOG_INJECT_CAP = 8000;
+export const MEMORY_INJECT_CAP = 6000;
 const WORKLOG_HEAD = 4800;
 const WORKLOG_TAIL = 3000;
 export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
@@ -17,6 +18,11 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     const tail = workLog.slice(-WORKLOG_TAIL);
     return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
 }
+export function capMemoryForInject(memory, cap = MEMORY_INJECT_CAP) {
+    return memory.length > cap
+        ? `${memory.slice(0, cap)}\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md 或 notes/)`
+        : memory;
+}
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
     const scheduledPolicy = ctx.scheduledOutputPolicy
@@ -120,6 +126,13 @@ ${taskAndScheduleCommands}`;
         ? ""
         : `
 - **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。`;
+    const externalReplyRule = scheduled
+        ? ""
+        : ctx.wakeOrigin === "wecom"
+            ? `
+- **本轮来自企微，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复企微时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复企微时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。`
+            : `
+- **外部来源回复由你决定**:普通 \`crew message send\` 只写入 NowWork。只有当前 thread 明确来自企微等外部 IM、且这条消息确实要回复外部发言人时,才给该次发送加 \`--reply-origin\`;Server 会按当前 thread 的已验证来源路由,你不能指定任意机器人或会话。确认、过程进展、内部协作消息不要使用该参数。若判断无需回外部,只发普通内部消息或保持沉默。`;
     const interactiveTaskRules = scheduled ? "" : `
 - **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
 - 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。
@@ -214,7 +227,7 @@ ${startupSequence}${scheduleIntentRule}
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
 ${actionRule}
-${interactiveTaskRules}${freshnessRule}${collaborationEtiquette}${humanLanguageSection}${communicationStyle}${skillIntentRule}
+${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtiquette}${humanLanguageSection}${communicationStyle}${skillIntentRule}
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:
@@ -260,3 +273,12 @@ export function buildWakePrompt(channelId) {
 - 有:转入主动处理。相关任务先 \`crew task claim <taskId>\` 认领再动手,完成后用 \`crew message send --channel ${channelId}\` 回复。
 - 没有:本轮什么都不要发,读完即停。你存活期间有新消息会自动送来,无需轮询。`;
 }
+export function buildOriginDecisionRetryPrompt(channelId, threadId) {
+    const thread = threadId ? ` --thread ${threadId}` : "";
+    return [
+        "本轮尚未完成企微回复决策。不要重复执行已经完成的工作，只完成下面这个决策后结束：",
+        `- 需要回复企微：用 crew message send --channel ${channelId}${thread} --reply-origin --content "完整最终回复"。`,
+        `- 不需要回复企微：用 crew message skip-origin --channel ${channelId} --reason "简短原因"。`,
+        "普通内部消息不算外部回复决策；--send-draft 也不是外部回复开关。",
+    ].join("\n");
+}