@nowcrew/daemon 0.5.13 → 0.5.15

package/dist/i18n.js

@@ -29,9 +29,34 @@ const zh = {
     "for channel": "处理频道",
     "agent exited": "agent 退出",
     "activities": "活动数",
+    "Computer lifecycle:": "电脑生命周期：",
+    "profile save reads the machine token from CREW_MACHINE_TOKEN, or stdin with --token-stdin.": "profile save 从 CREW_MACHINE_TOKEN 或 --token-stdin 的标准输入读取机器令牌。",
+    "Missing {{name}}": "缺少 {{name}}",
+    "Service '{{id}}' is still installed; uninstall it before removing the profile": "服务 '{{id}}' 仍已安装；请先卸载服务再删除配置",
+    "Removed profile '{{name}}'.": "已删除配置 '{{name}}'。",
+    "Expected profile save, list, show, or remove": "profile 子命令应为 save、list、show 或 remove",
+    "Choose one token source: CREW_MACHINE_TOKEN or --token-stdin": "CREW_MACHINE_TOKEN 与 --token-stdin 只能选择一种令牌来源",
+    "Missing machine token; use CREW_MACHINE_TOKEN or --token-stdin": "缺少机器令牌；请使用 CREW_MACHINE_TOKEN 或 --token-stdin",
+    "Saved profile '{{name}}' with private credentials.": "已保存配置 '{{name}}'，凭证仅私有可读。",
+    "Service '{{id}}' is not installed": "服务 '{{id}}' 尚未安装",
+    "Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.": "daemon 已升级，并已请求重启 '{{name}}'；请用 status 确认。",
+    "Upgraded daemon. Installed services were not restarted; pass --profile to restart one.": "daemon 已升级；已安装服务尚未重启，可传入 --profile 重启指定服务。",
+    "Service lifecycle requires the built daemon entry (.js), not a TypeScript development entry": "服务生命周期必须使用已构建的 daemon 入口（.js），不能使用 TypeScript 开发入口",
+    "Installed '{{id}}'. Use status to confirm runtime state.": "已安装 '{{id}}'；请用 status 确认运行状态。",
+    "Uninstalled '{{id}}'.": "已卸载 '{{id}}'。",
+    "{{action}} request accepted for '{{id}}'. Verify with status.": "已接受对 '{{id}}' 的 {{action}} 请求；请用 status 确认。",
+    "--token-stdin requires a token on standard input": "--token-stdin 需要从标准输入读取令牌",
+    "Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest": "服务生命周期需要全局安装 @nowcrew/daemon；请运行 npm install --global @nowcrew/daemon@latest",
 };
 export function translateDaemon(lang, message) {
     if (lang === "zh")
         return zh[message] ?? message;
     return message;
 }
+export function formatDaemonText(lang, message, values = {}) {
+    let rendered = translateDaemon(lang, message);
+    for (const [key, value] of Object.entries(values)) {
+        rendered = rendered.replaceAll(`{{${key}}}`, String(value));
+    }
+    return rendered;
+}

package/dist/local-executor.js

@@ -261,8 +261,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 callbacks.onActivity?.(activity);
             }
             const extracted = extractFinalText(event);
-            if (extracted)
-                finalText = extracted;
+            if (extracted) {
+                const incremental = typeof event === "object" && event !== null
+                    && "type" in event && event.type === "kimi.acp.text_delta";
+                finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
+            }
             for (const chunk of toConsoleLines(event))
                 callbacks.onConsole?.(chunk);
         });

package/dist/machine-info.js

@@ -11,11 +11,16 @@ import { readdir } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
+import { executableRuntimes } from "./runtime-capabilities.js";
+import { executionBackendCapability } from "./execution-backend.js";
+import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const DAEMON_CAPABILITIES = [
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
+    "execution_telemetry_ack_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -43,6 +48,17 @@ export async function detectRuntimes() {
     const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
     return checks.filter((x) => x !== null);
 }
+async function supportsKimiAcp() {
+    return probeKimiAcp({ bin: "kimi" });
+}
+/** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp) {
+    const present = await installed;
+    const supported = executableRuntimes(present).filter((runtime) => runtime !== "kimi");
+    if (present.includes("kimi") && await kimiAcpProbe())
+        supported.push("kimi");
+    return supported;
+}
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -77,22 +93,27 @@ async function listAgentHandles(agentsRoot) {
         return [];
     }
 }
-export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform) {
+export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform, dependencies = {}) {
     const [runtimes, agentHandles] = await Promise.all([
-        detectRuntimes(),
+        (dependencies.detectInstalled ?? detectRuntimes)(),
         listAgentHandles(agentsRoot),
     ]);
+    const backend = executionBackendCapability(runtimePlatform);
+    const executionRuntimes = backend.supported
+        ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
+        : [];
     return {
         type: "machine:hello",
         hostname: hostname(),
         os: `${osPlatform()} ${arch()}`,
         daemonVersion: daemonVersion(),
         runtimes,
+        executionRuntimes,
         capabilities: DAEMON_CAPABILITIES,
-        ...(runtimePlatform === "win32" ? {} : {
+        ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({ ...executionLimits }),
-        }),
+        } : {}),
         agentHandles,
     };
 }

package/dist/main.js

@@ -13,7 +13,14 @@ 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 { runComputerCommand } from "./computer-cli.js";
 async function main() {
+    const computerResult = await runComputerCommand(process.argv.slice(2));
+    if (computerResult !== null) {
+        process.exitCode = computerResult;
+        return;
+    }
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
     const { values, positionals } = parseArgs({
@@ -28,6 +35,8 @@ async function main() {
             "server-url": { type: "string" },
             "api-key": { type: "string" },
             token: { type: "string" }, // --api-key 的别名
+            profile: { type: "string" },
+            "daemon-home": { type: "string" },
         },
     });
     // 无子命令时默认 serve(对齐 `npx @nowcrew/daemon@latest --server-url ... --api-key ...`)
@@ -38,6 +47,12 @@ async function main() {
             "  crew-daemon run --agent <h> --channel <id> [--wake ...]                  # " + td("run once manually") + "\n");
         process.exit(2);
     }
+    // profile 先加载,显式命令行参数仍具有最高优先级。服务描述只保留 profile 名,
+    // 不把 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);
     // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
     if (values["server-url"])
         process.env.CREW_SERVER_URL = values["server-url"];

package/dist/normalize.js

@@ -34,6 +34,8 @@ export function classifyCommand(command) {
 /** 从各 runtime 的最终事件提取可交付文本。调用方按事件顺序保留最后一个非空值。 */
 export function extractFinalText(event) {
     const e = (event ?? {});
+    if (e.type === "kimi.acp.text_delta" && e.text)
+        return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
         return e.result.trim();
     if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
@@ -59,6 +61,15 @@ function parseKimiBashCommand(args) {
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
+    if (e.type === "kimi.acp.text_delta" && e.text?.trim()) {
+        return [{ kind: "text", label: "思考/说明", detail: e.text }];
+    }
+    if (e.type === "kimi.acp.tool_call") {
+        return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
+    }
+    if (e.type === "kimi.acp.tool_result") {
+        return [{ kind: "tool_result", label: "工具返回" }];
+    }
     if (e.type === "system" && e.subtype === "init") {
         return [{ kind: "init", label: "agent 启动" }];
     }

package/dist/prompt.js

@@ -29,8 +29,25 @@ export function buildSystemPrompt(ctx) {
         ?? (ctx.scheduled ? "silent_unless_report" : null);
     const scheduled = scheduledPolicy !== null;
     const alwaysReport = scheduledPolicy === "always_report";
-    // 启动序列:非 scheduled 保持原文(含"先确认接手"/"收到消息就处理并回复"——这两条是
-    // 协作场景的核心礼仪);scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
+    const messageBodyInput = ctx.platform === "win32"
+        ? `PowerShell 5.1 向 native 进程传管道时默认可能使用 US-ASCII。发送中文等非 ASCII 正文时，**必须在同一条 shell 命令内**先设置无 BOM UTF-8:
+   \`\`\`powershell
+   $utf8 = New-Object System.Text.UTF8Encoding($false)
+   $OutputEncoding = $utf8
+   [Console]::OutputEncoding = $utf8
+   @'
+   你的消息正文
+   '@ | crew message send --channel <id> --thread <完整线程根消息 id>
+   \`\`\`
+   不得在未设置 \`$OutputEncoding\` 时把非 ASCII 正文通过 PowerShell 管道传给 \`crew\`。`
+        : `正文从 stdin 读，用 heredoc 避免 shell 解释引号/反引号/代码块:
+   \`\`\`bash
+   crew message send --channel <id> <<'CREWMSG'
+   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
+   CREWMSG
+   \`\`\``;
+    // 启动序列:普通交互对可直答来信只发一条完整回复，多步工作仍可发有信息量的进度；
+    // scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
     const startupSequence = alwaysReport
         ? `## 启动序列(每轮汇报定时任务)
 1. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
@@ -47,7 +64,7 @@ export function buildSystemPrompt(ctx) {
 4. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。
 5. 无异常时直接结束,不需要任何输出,不必读频道历史(除非指令要求)。`
             : `## 启动序列
-1. 若本轮已带具体来信,先判断是否需要立即确认/提问/声明接手;需要就先用 \`crew message send\` 发出,再去深挖上下文。确认消息的内容标准见下面「沟通风格」。
+1. 若本轮来信可以直接回答,不要先发确认消息;处理完后只发一条完整回复。只有需要澄清、调用工具、协调他人或较长时间处理时,才先发有信息量的确认/进度消息。
 2. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
 4. 收到消息就处理,并用 \`crew message send\` 回复。
@@ -114,12 +131,7 @@ ${taskAndScheduleCommands}`
 1. **\`crew whoami\`** —— 查看你自己的身份。
 2. **\`crew message read --channel <id>\`** —— 读频道历史(读取即自动推进你的已读/新鲜度游标)。支持 \`--after <seq>\` / \`--limit <n>\`。
 3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。工作中可在自然断点随时用。
-4. **\`crew message send --channel <id>\`** —— 发消息。正文从 stdin 读,用 heredoc 避免 shell 解释引号/反引号/代码块:
-   \`\`\`bash
-   crew message send --channel <id> <<'CREWMSG'
-   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
-   CREWMSG
-   \`\`\`
+4. **\`crew message send --channel <id>\`** —— 发消息。${messageBodyInput}
    也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <完整线程根消息 id>\`。被唤醒时优先使用环境变量 \`$CREW_WAKE_MESSAGE_ID\` 或唤醒提示里的完整 id,不要手动截短。
 ${taskAndScheduleCommands}`;
     const freshnessRule = alwaysReport

package/dist/runner.js

@@ -43,6 +43,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             agentId: credential.agentId,
             homeDir: workspace.dir,
             productName: config.productName,
+            platform: process.platform,
             ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
             ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
             memory: capMemoryForInject(workspace.memory),

package/dist/runtime-capabilities.js

@@ -0,0 +1,5 @@
+export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi"];
+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));
+}

package/dist/runtimes/kimi-acp-runner.js

@@ -0,0 +1,264 @@
+import { once } from "node:events";
+import { parseArgs } from "node:util";
+import { Readable, Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
+import spawn from "cross-spawn";
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
+const ERROR_MESSAGE_CAP = 2_000;
+const PROBE_TIMEOUT_MS = 5_000;
+function jsonLine(event) {
+    if (process.stdout.write(`${JSON.stringify(event)}\n`))
+        return Promise.resolve();
+    return once(process.stdout, "drain").then(() => undefined);
+}
+function textContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return [part.text];
+        }
+        if (part && typeof part === "object" && "content" in part
+            && part.content && typeof part.content === "object"
+            && "type" in part.content && part.content.type === "text"
+            && "text" in part.content && typeof part.content.text === "string") {
+            return [part.content.text];
+        }
+        return [];
+    }).join("\n");
+}
+/** Translate stable ACP updates into daemon-owned NDJSON, without exposing thought chunks. */
+export function mapKimiAcpUpdate(update) {
+    if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+        return [{ type: "kimi.acp.text_delta", text: update.content.text }];
+    }
+    if (update.sessionUpdate === "tool_call") {
+        return [{
+                type: "kimi.acp.tool_call",
+                id: update.toolCallId,
+                title: update.title,
+                ...(update.kind === undefined ? {} : { kind: update.kind }),
+                ...(update.status === undefined ? {} : { status: update.status }),
+                ...(update.rawInput === undefined ? {} : { input: update.rawInput }),
+            }];
+    }
+    if (update.sessionUpdate === "tool_call_update") {
+        const output = textContent(update.content);
+        return [{
+                type: "kimi.acp.tool_result",
+                id: update.toolCallId,
+                ...(update.status === undefined ? {} : { status: update.status }),
+                ...(output ? { content: output } : {}),
+            }];
+    }
+    return [];
+}
+function safeErrorMessage(error, prompt) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
+    return redacted.slice(0, ERROR_MESSAGE_CAP);
+}
+/** Full access may approve an operation, but it must never fabricate an answer to an agent question. */
+export function selectKimiPermission(params) {
+    const allowOnce = params.options.filter((option) => option.kind === "allow_once");
+    if (params.toolCall.title === "AskUserQuestion" || allowOnce.length > 1) {
+        return { outcome: { outcome: "cancelled" } };
+    }
+    const allowed = allowOnce[0]
+        ?? (params.options.filter((option) => option.kind === "allow_always").length === 1
+            ? params.options.find((option) => option.kind === "allow_always")
+            : undefined);
+    return allowed === undefined
+        ? { outcome: { outcome: "cancelled" } }
+        : { outcome: { outcome: "selected", optionId: allowed.optionId } };
+}
+async function readPrompt() {
+    process.stdin.setEncoding("utf8");
+    let prompt = "";
+    for await (const chunk of process.stdin)
+        prompt += String(chunk);
+    if (!prompt)
+        throw new Error("Kimi ACP prompt is empty");
+    return prompt;
+}
+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;
+    }
+}
+/** A help banner is insufficient: Kimi's authenticate RPC re-checks its token without creating a session. */
+export async function probeKimiAcp(options, spawnProcess = spawn) {
+    const child = spawnProcess(options.bin, ["acp"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null)
+        return false;
+    child.stderr.resume();
+    const app = client({ name: "nowcrew-daemon-kimi-probe" })
+        .onRequest(methods.client.session.requestPermission, () => ({
+        outcome: { outcome: "cancelled" },
+    }))
+        .onNotification(methods.client.session.update, () => undefined);
+    let timeout;
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connected = app.connectWith(stream, async (context) => {
+            const initialized = await context.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            const authMethod = initialized.authMethods?.[0];
+            if (authMethod !== undefined) {
+                await context.request(methods.agent.authenticate, { methodId: authMethod.id });
+            }
+            return true;
+        });
+        const result = await Promise.race([
+            connected,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => {
+                    void stopChild(child);
+                    resolve(false);
+                }, PROBE_TIMEOUT_MS);
+            }),
+        ]);
+        return result;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        await stopChild(child);
+    }
+}
+export async function runKimiAcp(options) {
+    const prompt = await readPrompt();
+    const child = spawn(options.bin, ["acp"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (child.stdin === null || child.stdout === null || child.stderr === null) {
+        throw new Error("Kimi ACP process did not expose stdio");
+    }
+    child.stderr.pipe(process.stderr, { end: false });
+    let context = null;
+    let sessionId = null;
+    let cancelling = false;
+    const cancel = async () => {
+        if (cancelling)
+            return;
+        cancelling = true;
+        if (context !== null && sessionId !== null) {
+            await context.notify(methods.agent.session.cancel, { sessionId }).catch(() => undefined);
+        }
+        await stopChild(child);
+    };
+    const onSignal = () => {
+        void cancel().finally(() => process.exit(130));
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+    const app = client({ name: "nowcrew-daemon-kimi" })
+        .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
+        .onNotification(methods.client.session.update, async ({ params }) => {
+        for (const event of mapKimiAcpUpdate(params.update))
+            await jsonLine(event);
+    });
+    try {
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const result = await app.connectWith(stream, async (nextContext) => {
+            context = nextContext;
+            const initialized = await nextContext.request(methods.agent.initialize, {
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: {},
+                clientInfo: { name: "nowcrew-daemon", version: "1" },
+            });
+            if (process.env.CREW_KIMI_ACP_DEBUG === "1") {
+                process.stderr.write(`Kimi ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
+            }
+            const authMethod = initialized.authMethods?.[0];
+            if (authMethod !== undefined) {
+                await nextContext.request(methods.agent.authenticate, { methodId: authMethod.id });
+            }
+            const session = await nextContext.request(methods.agent.session.new, {
+                cwd: process.cwd(),
+                mcpServers: [],
+            });
+            sessionId = session.sessionId;
+            if (options.model) {
+                await nextContext.request(methods.agent.session.setConfigOption, {
+                    sessionId,
+                    configId: "model",
+                    value: options.model,
+                });
+            }
+            return nextContext.request(methods.agent.session.prompt, {
+                sessionId,
+                prompt: [{ type: "text", text: prompt }],
+            });
+        });
+        const usage = result.usage;
+        await jsonLine({
+            type: "turn.completed",
+            stop_reason: result.stopReason,
+            ...(usage === undefined || usage === null ? {} : {
+                usage: {
+                    input_tokens: usage.inputTokens,
+                    output_tokens: usage.outputTokens,
+                    cache_read_input_tokens: usage.cachedReadTokens ?? 0,
+                    cache_creation_input_tokens: usage.cachedWriteTokens ?? 0,
+                },
+            }),
+        });
+        return result.stopReason === "end_turn" ? 0 : result.stopReason === "cancelled" ? 130 : 1;
+    }
+    catch (error) {
+        process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
+        return 1;
+    }
+    finally {
+        process.off("SIGTERM", onSignal);
+        process.off("SIGINT", onSignal);
+        await stopChild(child);
+    }
+}
+function optionsFromArgv(argv) {
+    const { values } = parseArgs({
+        args: [...argv],
+        options: {
+            bin: { type: "string" },
+            model: { type: "string" },
+        },
+    });
+    if (!values.bin)
+        throw new Error("--bin is required");
+    return { bin: values.bin, ...(values.model ? { model: values.model } : {}) };
+}
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runKimiAcp(optionsFromArgv(process.argv.slice(2)))
+        .then((code) => { process.exitCode = code; })
+        .catch((error) => {
+        process.stderr.write(`Kimi ACP runner failed: ${safeErrorMessage(error, "")}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/runtimes/kimi.js

@@ -10,6 +10,15 @@
  */
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
+// Windows CreateProcess receives one UTF-16 command line. Reserve room for the executable, flags,
+// model and cmd shim quoting instead of relying on the theoretical 32767-character ceiling.
+export const KIMI_LEGACY_PROMPT_MAX_UTF16 = 28_000;
+export function assertKimiLegacyPromptFits(prompt, platform = process.platform) {
+    if (platform !== "win32" || prompt.length <= KIMI_LEGACY_PROMPT_MAX_UTF16)
+        return;
+    throw new Error(`Kimi legacy prompt exceeds the Windows argv limit (${prompt.length}/${KIMI_LEGACY_PROMPT_MAX_UTF16}); `
+        + "shorten the prompt (protocol-v1 remains disabled on Windows until Job Object ownership is available)");
+}
 // Kimi Code 思考强度档位(kimi-code 0.23.0 实测+源码):无 CLI 参数,
 // 由 runner 经 KIMI_MODEL_THINKING_EFFORT env 注入;白名单外的值不注。
 export const KIMI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -24,6 +33,7 @@ export function buildKimiArgs(input) {
     return args;
 }
 export function spawnKimi(input) {
+    assertKimiLegacyPromptFits(input.wakePrompt);
     // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
     return spawn(input.bin, buildKimiArgs(input), {
         cwd: input.cwd,