@nowcrew/daemon 0.5.28 → 0.5.29

package/dist/computer-service.js

@@ -0,0 +1,358 @@
+import { access, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+import { dirname, resolve } from "node:path";
+const execFileAsync = promisify(execFile);
+const WINDOWS_STOP_TIMEOUT_MS = 5_000;
+const WINDOWS_STOP_POLL_MS = 100;
+export const systemCommandRunner = async (command, args) => {
+    try {
+        const result = await execFileAsync(command, [...args], { encoding: "utf8" });
+        return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            exitCode: typeof failure.code === "number" ? failure.code : 127,
+            stdout: failure.stdout ?? "",
+            stderr: failure.stderr ?? failure.message,
+        };
+    }
+};
+function assertSingleLine(value, field) {
+    if (value.includes("\n") || value.includes("\r") || value.includes("\0")) {
+        throw new Error(`${field} must not contain control characters`);
+    }
+    return value;
+}
+function xml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdArg(value) {
+    return `"${assertSingleLine(value, "service argument").replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
+}
+export function windowsCommandArg(value) {
+    const input = assertSingleLine(value, "service argument");
+    return `"${input.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\*)$/g, "$1$1")}"`;
+}
+export function buildServiceSpec(input) {
+    const { platform, profile, userHome } = input;
+    if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
+        throw new Error(`Computer services are not supported on platform '${platform}'`);
+    }
+    const daemonCommand = [
+        assertSingleLine(input.nodePath, "node path"),
+        assertSingleLine(input.entryPath, "daemon entry path"),
+        "serve",
+        "--profile",
+        assertSingleLine(profile, "profile"),
+        ...(input.profileHome ? ["--daemon-home", assertSingleLine(input.profileHome, "daemon home")] : []),
+    ];
+    if (platform === "darwin") {
+        if (input.uid === undefined)
+            throw new Error("Cannot install launchd service without a numeric uid");
+        const id = `com.nowcrew.daemon.${profile}`;
+        const args = daemonCommand.map((arg) => `      <string>${xml(arg)}</string>`).join("\n");
+        return {
+            platform,
+            profile,
+            id,
+            descriptorPath: resolve(userHome, "Library", "LaunchAgents", `${id}.plist`),
+            daemonCommand,
+            managerDomain: `gui/${input.uid}`,
+            descriptor: `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key><string>${xml(id)}</string>\n  <key>ProgramArguments</key>\n  <array>\n${args}\n  </array>\n  <key>KeepAlive</key><true/>\n  <key>ProcessType</key><string>Background</string>\n</dict>\n</plist>\n`,
+        };
+    }
+    if (platform === "linux") {
+        const id = `nowcrew-daemon-${profile}.service`;
+        return {
+            platform,
+            profile,
+            id,
+            descriptorPath: resolve(userHome, ".config", "systemd", "user", id),
+            daemonCommand,
+            managerDomain: null,
+            descriptor: `[Unit]\nDescription=NowCrew daemon (${profile})\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${daemonCommand.map(systemdArg).join(" ")}\nRestart=on-failure\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n`,
+        };
+    }
+    const id = `NowCrew Daemon (${profile})`;
+    return { platform, profile, id, descriptorPath: null, descriptor: null, daemonCommand, managerDomain: null };
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function writePrivateAtomic(path, content) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await chmod(dirname(path), 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+async function checked(runner, command, args, action) {
+    const result = await runner(command, args);
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`;
+        throw new Error(`${action} failed: ${detail}`);
+    }
+    return result;
+}
+async function windowsTaskState(spec, runner) {
+    const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+    const script = [
+        "$ErrorActionPreference='Stop';",
+        "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+        "$tasks=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});",
+        "if($tasks.Count -eq 0){'missing'}elseif($tasks.Count -eq 1){'state:'+([int]$tasks[0].State)}else{throw 'duplicate scheduled tasks'}",
+    ].join("");
+    const result = await runner("powershell.exe", [
+        "-NoProfile", "-NonInteractive", "-Command", script, encodedName,
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Unable to query scheduled task: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+    }
+    const value = result.stdout.trim();
+    if (value === "missing")
+        return { installed: false, state: null, result };
+    const match = /^state:([0-4])$/.exec(value);
+    if (!match)
+        throw new Error(`Scheduled task returned an unknown state '${value}'`);
+    return { installed: true, state: Number(match[1]), result };
+}
+async function windowsTaskExists(spec, runner) {
+    return (await windowsTaskState(spec, runner)).installed;
+}
+async function stopWindowsTask(spec, initial, runner) {
+    if (initial.state !== 2 && initial.state !== 4)
+        return initial.installed;
+    await checked(runner, "schtasks.exe", ["/End", "/TN", spec.id], "Scheduled task stop");
+    const deadline = Date.now() + WINDOWS_STOP_TIMEOUT_MS;
+    while (true) {
+        const current = await windowsTaskState(spec, runner);
+        if (!current.installed)
+            return false;
+        if (current.state !== 2 && current.state !== 4)
+            return true;
+        if (Date.now() >= deadline) {
+            throw new Error(`Scheduled task '${spec.id}' did not stop within ${WINDOWS_STOP_TIMEOUT_MS}ms`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, WINDOWS_STOP_POLL_MS));
+    }
+}
+export async function installService(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        if (await windowsTaskExists(spec, runner))
+            throw new Error(`Service '${spec.id}' is already installed`);
+        const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+        const encodedExecutable = Buffer.from(spec.daemonCommand[0], "utf16le").toString("base64");
+        const encodedArguments = Buffer.from(spec.daemonCommand.slice(1).map(windowsCommandArg).join(" "), "utf16le").toString("base64");
+        const script = [
+            "$ErrorActionPreference='Stop';",
+            "$name=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+            "$exe=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[1]));",
+            "$argv=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[2]));",
+            "$identity=[Security.Principal.WindowsIdentity]::GetCurrent().Name;",
+            "$action=New-ScheduledTaskAction -Execute $exe -Argument $argv;",
+            "$trigger=New-ScheduledTaskTrigger -AtLogOn -User $identity;",
+            "$settings=New-ScheduledTaskSettingsSet -ExecutionTimeLimit ([TimeSpan]::Zero) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1);",
+            "$principal=New-ScheduledTaskPrincipal -UserId $identity -LogonType Interactive -RunLevel Limited;",
+            "Register-ScheduledTask -TaskName $name -TaskPath '\\' -Action $action -Trigger $trigger -Settings $settings -Principal $principal -ErrorAction Stop|Out-Null;",
+        ].join("");
+        await checked(runner, "powershell.exe", [
+            "-NoProfile", "-NonInteractive", "-Command", script,
+            encodedName, encodedExecutable, encodedArguments,
+        ], "Scheduled task installation");
+        return;
+    }
+    if (spec.descriptorPath === null || spec.descriptor === null)
+        throw new Error("Missing service descriptor");
+    if (await pathExists(spec.descriptorPath))
+        throw new Error(`Service '${spec.id}' is already installed`);
+    await writePrivateAtomic(spec.descriptorPath, spec.descriptor);
+    try {
+        if (spec.platform === "linux") {
+            await checked(runner, "systemctl", ["--user", "daemon-reload"], "systemd reload");
+            await checked(runner, "systemctl", ["--user", "enable", spec.id], "systemd enable");
+        }
+    }
+    catch (error) {
+        await rm(spec.descriptorPath, { force: true });
+        if (spec.platform === "linux") {
+            await runner("systemctl", ["--user", "disable", spec.id]);
+            await runner("systemctl", ["--user", "daemon-reload"]);
+        }
+        throw error;
+    }
+}
+export async function uninstallService(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        const task = await windowsTaskState(spec, runner);
+        if (!task.installed)
+            throw new Error(`Service '${spec.id}' is not installed`);
+        if (!await stopWindowsTask(spec, task, runner))
+            return;
+        await checked(runner, "schtasks.exe", ["/Delete", "/TN", spec.id, "/F"], "Scheduled task removal");
+        return;
+    }
+    if (spec.descriptorPath === null || !await pathExists(spec.descriptorPath)) {
+        throw new Error(`Service '${spec.id}' is not installed`);
+    }
+    if (spec.platform === "darwin") {
+        const status = await serviceStatus(spec, runner);
+        if (status.loaded) {
+            await checked(runner, "launchctl", ["bootout", `${spec.managerDomain}/${spec.id}`], "launchd bootout");
+        }
+    }
+    else {
+        const disable = await runner("systemctl", ["--user", "disable", "--now", spec.id]);
+        if (disable.exitCode !== 0 && !/not loaded|does not exist|not found/i.test(`${disable.stdout}\n${disable.stderr}`)) {
+            throw new Error(`systemd disable failed: ${disable.stderr.trim() || disable.stdout.trim()}`);
+        }
+    }
+    await rm(spec.descriptorPath);
+    if (spec.platform === "linux") {
+        await checked(runner, "systemctl", ["--user", "daemon-reload"], "systemd reload");
+    }
+}
+export async function serviceAction(spec, action, runner = systemCommandRunner) {
+    if (spec.platform !== "win32" && (spec.descriptorPath === null || !await pathExists(spec.descriptorPath))) {
+        throw new Error(`Service '${spec.id}' is not installed`);
+    }
+    if (spec.platform === "darwin") {
+        const target = `${spec.managerDomain}/${spec.id}`;
+        const status = await serviceStatus(spec, runner);
+        if (action === "start") {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["kickstart", "-k", target], "launchd start");
+            else
+                await checked(runner, "launchctl", ["bootstrap", spec.managerDomain, spec.descriptorPath], "launchd start");
+        }
+        else if (action === "stop") {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["bootout", target], "launchd stop");
+        }
+        else {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["bootout", target], "launchd stop");
+            await checked(runner, "launchctl", ["bootstrap", spec.managerDomain, spec.descriptorPath], "launchd start");
+        }
+    }
+    else if (spec.platform === "linux") {
+        await checked(runner, "systemctl", ["--user", action, spec.id], `systemd ${action}`);
+    }
+    else {
+        const task = await windowsTaskState(spec, runner);
+        if (!task.installed)
+            throw new Error(`Service '${spec.id}' is not installed`);
+        if (action === "start")
+            await checked(runner, "schtasks.exe", ["/Run", "/TN", spec.id], "Scheduled task start");
+        else if (action === "stop") {
+            await stopWindowsTask(spec, task, runner);
+        }
+        else {
+            if (!await stopWindowsTask(spec, task, runner)) {
+                throw new Error(`Service '${spec.id}' disappeared while restarting`);
+            }
+            await checked(runner, "schtasks.exe", ["/Run", "/TN", spec.id], "Scheduled task start");
+        }
+    }
+}
+export async function serviceStatus(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        const task = await windowsTaskState(spec, runner);
+        return {
+            ...task.result,
+            installed: task.installed,
+            loaded: task.installed,
+            running: task.state === 4,
+        };
+    }
+    if (spec.descriptorPath === null || !await pathExists(spec.descriptorPath)) {
+        return { exitCode: 3, stdout: "", stderr: "service descriptor not found", installed: false, loaded: false, running: false };
+    }
+    const result = spec.platform === "darwin"
+        ? await runner("launchctl", ["print", `${spec.managerDomain}/${spec.id}`])
+        : await runner("systemctl", ["--user", "is-active", spec.id]);
+    const running = spec.platform === "darwin"
+        ? result.exitCode === 0 && /\bstate\s*=\s*running\b/.test(result.stdout)
+        : result.exitCode === 0;
+    return { ...result, installed: true, loaded: spec.platform === "darwin" ? result.exitCode === 0 : true, running };
+}
+export async function doctorService(spec, profilePrivate, runner = systemCommandRunner) {
+    const nodeMajor = Number(process.versions.node.split(".")[0]);
+    const tool = spec.platform === "darwin" ? "launchctl" : spec.platform === "linux" ? "systemctl" : "schtasks.exe";
+    const probeArgs = spec.platform === "linux" ? ["--user", "--version"] : spec.platform === "darwin" ? ["help"] : ["/Query", "/?"];
+    const probe = await runner(tool, probeArgs);
+    const status = await serviceStatus(spec, runner);
+    return [
+        { name: "node", ok: nodeMajor >= 22, detail: `Node ${process.versions.node} (requires >=22)` },
+        { name: "profile-permissions", ok: profilePrivate, detail: profilePrivate ? "private" : "readable by other users" },
+        { name: "service-manager", ok: probe.exitCode === 0, detail: probe.exitCode === 0 ? tool : (probe.stderr.trim() || `${tool} unavailable`) },
+        { name: "service-installed", ok: status.installed, detail: status.installed ? spec.id : "not installed" },
+        { name: "service-running", ok: status.running === true, detail: status.running ? "running" : "not running" },
+    ];
+}
+export function buildUpgradeCommand(platform) {
+    return [platform === "win32" ? "npm.cmd" : "npm", ["install", "--global", "@nowcrew/daemon@latest"]];
+}
+export async function upgradeDaemon(platform, runner = systemCommandRunner) {
+    const [command, args] = buildUpgradeCommand(platform);
+    await checked(runner, command, args, "Daemon upgrade");
+}
+const WINDOWS_SID_SCRIPT = "[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value";
+export async function hardenWindowsProfile(path, runner = systemCommandRunner) {
+    const identity = await checked(runner, "powershell.exe", [
+        "-NoProfile", "-NonInteractive", "-Command", WINDOWS_SID_SCRIPT,
+    ], "Windows identity lookup");
+    const sid = identity.stdout.trim();
+    if (!/^S-1-(?:\d+-)+\d+$/.test(sid))
+        throw new Error("Windows identity lookup returned an invalid SID");
+    await checked(runner, "icacls.exe", [path, "/inheritance:r", "/grant:r", `*${sid}:(F)`], "Profile ACL hardening");
+}
+export async function windowsProfileIsPrivate(path, runner = systemCommandRunner) {
+    const encodedPath = Buffer.from(path, "utf16le").toString("base64");
+    const script = [
+        "$p=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+        "$me=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value;",
+        "$safe=@($me,'S-1-5-18','S-1-5-32-544');",
+        "$rules=(Get-Acl -LiteralPath $p).Access;",
+        "$unsafe=$rules|Where-Object { $_.AccessControlType -eq 'Allow' -and $safe -notcontains $_.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value };",
+        "if($unsafe){'false'}else{'true'}",
+    ].join("");
+    const result = await runner("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, encodedPath]);
+    if (result.exitCode !== 0)
+        throw new Error(`Profile ACL inspection failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+    if (result.stdout.trim() === "true")
+        return true;
+    if (result.stdout.trim() === "false")
+        return false;
+    throw new Error("Profile ACL inspection returned an invalid result");
+}
+export async function readServiceDescriptor(spec) {
+    if (spec.descriptorPath === null)
+        return null;
+    try {
+        return await readFile(spec.descriptorPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}

package/dist/config.js

@@ -0,0 +1,82 @@
+/** daemon 配置:从 env 读取,解析 crew CLI 路径 (注入给 agent 的 wrapper 用)。 */
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createRequire } from "node:module";
+import { detectDaemonLang, translateDaemon } from "./i18n.js";
+import { resolveAgentsRoot } from "./computer-profile.js";
+export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
+    maxPromptBytes: 256_000,
+    maxTimeoutMs: 3_600_000,
+    maxEventBytes: 64_000,
+    maxParallelPerAgent: 4,
+    maxQueuedPerAgent: 32,
+});
+// Fits the largest mandatory v1 lifecycle envelope (UUID + timestamps + outcome facts) with margin.
+export const MIN_EXECUTION_EVENT_BYTES = 512;
+export const MAX_EXECUTION_TIMEOUT_MS = 2_147_483_647;
+export class ConfigError extends Error {
+}
+function positiveIntegerEnv(env, field, fallback) {
+    const raw = env[field];
+    const value = raw === undefined ? fallback : Number(raw);
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new ConfigError(`${field} must be a finite positive integer`);
+    }
+    return value;
+}
+function integerEnvAtLeast(env, field, fallback, minimum) {
+    const value = positiveIntegerEnv(env, field, fallback);
+    if (value < minimum)
+        throw new ConfigError(`${field} must be at least ${minimum}`);
+    return value;
+}
+function integerEnvAtMost(env, field, fallback, maximum) {
+    const value = positiveIntegerEnv(env, field, fallback);
+    if (value > maximum)
+        throw new ConfigError(`${field} must be at most ${maximum}`);
+    return value;
+}
+function defaultCliPath() {
+    // 已发布场景(npx):crew CLI 是 daemon 的依赖,从 node_modules 解析 @nowcrew/cli。
+    try {
+        return createRequire(import.meta.url).resolve("@nowcrew/cli/dist/main.js");
+    }
+    catch {
+        // 开发场景(monorepo):daemon/src → 上两级到 crew/,再进 cli/dist/main.js
+        const here = dirname(fileURLToPath(import.meta.url));
+        return resolve(here, "../../cli/dist/main.js");
+    }
+}
+export const DEFAULT_SERVER_URL = "http://127.0.0.1:3001";
+export function loadConfig(env = process.env) {
+    const serverUrl = (env.CREW_SERVER_URL ?? DEFAULT_SERVER_URL).replace(/\/+$/, "");
+    const machineToken = env.CREW_MACHINE_TOKEN ?? "";
+    if (!machineToken) {
+        const lang = detectDaemonLang(env);
+        throw new ConfigError(translateDaemon(lang, "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)"));
+    }
+    const executionLimits = Object.freeze({
+        maxPromptBytes: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_PROMPT_BYTES", DEFAULT_EXECUTION_LIMITS.maxPromptBytes),
+        maxTimeoutMs: integerEnvAtMost(env, "CREW_EXECUTION_MAX_TIMEOUT_MS", DEFAULT_EXECUTION_LIMITS.maxTimeoutMs, MAX_EXECUTION_TIMEOUT_MS),
+        maxEventBytes: integerEnvAtLeast(env, "CREW_EXECUTION_MAX_EVENT_BYTES", DEFAULT_EXECUTION_LIMITS.maxEventBytes, MIN_EXECUTION_EVENT_BYTES),
+        maxParallelPerAgent: positiveIntegerEnv(env, "CREW_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelPerAgent),
+        maxQueuedPerAgent: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_PER_AGENT", DEFAULT_EXECUTION_LIMITS.maxQueuedPerAgent),
+    });
+    return {
+        serverUrl,
+        machineToken,
+        agentsRoot: resolveAgentsRoot(env.CREW_AGENTS_ROOT, homedir()),
+        cliPath: env.CREW_CLI_PATH ?? defaultCliPath(),
+        runtimeBin: env.CREW_RUNTIME ?? "claude",
+        dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)
+        resume: env.CREW_RESUME !== "off" && env.CREW_RESUME !== "0", // 默认开启;一键回退现状用 CREW_RESUME=off
+        resumeWarmMs: env.CREW_RESUME_WARM_MS != null ? Number(env.CREW_RESUME_WARM_MS) : 3_600_000, // 默认 1h
+        // 会话预算轮换:hard 120k 触发冷启动轮换;soft 90k 先提醒蒸馏 work-log;30 轮为 usage 缺失的兜底
+        sessionBudgetTokens: env.CREW_SESSION_BUDGET_TOKENS != null ? Number(env.CREW_SESSION_BUDGET_TOKENS) : 120_000,
+        sessionSoftTokens: env.CREW_SESSION_SOFT_TOKENS != null ? Number(env.CREW_SESSION_SOFT_TOKENS) : 90_000,
+        sessionMaxTurns: env.CREW_SESSION_MAX_TURNS != null ? Number(env.CREW_SESSION_MAX_TURNS) : 30,
+        productName: env.CREW_PRODUCT_NAME ?? "nowwork",
+        executionLimits,
+    };
+}

package/dist/console-collapse.js

@@ -0,0 +1,13 @@
+const MESSAGE_READ = /\bcrew\s+(?:message|thread)\s+read\b/i;
+const TASK_LIST = /\bcrew\s+task\s+list\b/i;
+export function buildCollapsedResult(command, output) {
+    if (MESSAGE_READ.test(command)) {
+        const count = output.split("\n").filter((line) => /^#\d+\s+\(msg=/.test(line.trim())).length;
+        return { kind: "collapsed_result", label: "CHANNEL HISTORY", count };
+    }
+    if (TASK_LIST.test(command)) {
+        const count = output.split("\n").filter((line) => /^#\d+\s+\[/.test(line.trim())).length;
+        return { kind: "collapsed_result", label: "TASK LIST", count };
+    }
+    return null;
+}

package/dist/console-formatter.js

@@ -0,0 +1,77 @@
+/**
+ * 单次 runtime execution 的 console 格式化器。
+ * 用 tool_use id 关联 Read 结果,避免将整文件作为普通 tool_result 倾泻到终端。
+ */
+import { buildFilePreview } from "./console-payload.js";
+import { buildScriptResult, toConsoleLines, TOOL_RESULT_CAP } from "./console.js";
+import { parseUnifiedDiff } from "./unified-diff.js";
+import { buildJsonResult } from "./json-result.js";
+import { buildCollapsedResult } from "./console-collapse.js";
+import { buildSkillPreview } from "./skill-preview.js";
+const extract = (content) => {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((item) => item && typeof item === "object" && typeof item.text === "string"
+        ? item.text : "").filter(Boolean).join("\n");
+};
+const clip = (text) => text.length > TOOL_RESULT_CAP
+    ? `${text.slice(0, TOOL_RESULT_CAP)}… (+${text.length - TOOL_RESULT_CAP})`
+    : text;
+const SCRIPT_TOOLS = new Set(["Bash", "PowerShell", "Shell"]);
+export function createConsoleFormatter() {
+    const pending = new Map();
+    return {
+        format(event) {
+            const rec = event && typeof event === "object" ? event : {};
+            const message = rec.message && typeof rec.message === "object" ? rec.message : undefined;
+            if (rec.type === "assistant" && Array.isArray(message?.content)) {
+                for (const block of message.content) {
+                    if (block.type === "tool_use" && block.id && block.name) {
+                        pending.set(block.id, { name: block.name, ...(block.input ? { input: block.input } : {}) });
+                    }
+                }
+            }
+            if (rec.type === "user" && Array.isArray(message?.content)) {
+                const out = [];
+                for (const block of message.content) {
+                    if (block.type !== "tool_result")
+                        continue;
+                    const text = extract(block.content);
+                    if (!text)
+                        continue;
+                    const tool = block.tool_use_id ? pending.get(block.tool_use_id) : undefined;
+                    if (block.tool_use_id)
+                        pending.delete(block.tool_use_id);
+                    if (!block.is_error && tool?.name === "Read" && typeof tool.input?.file_path === "string") {
+                        const start = typeof tool.input.offset === "number" && Number.isSafeInteger(tool.input.offset)
+                            ? Math.max(1, tool.input.offset) : 1;
+                        const preview = buildFilePreview("read", tool.input.file_path, text, start);
+                        out.push({ stream: "tool_result", text: `Read ${preview.totalLines} line(s) from ${preview.path}`, payload: preview });
+                        continue;
+                    }
+                    const patch = block.is_error ? null : parseUnifiedDiff(text);
+                    const command = tool && SCRIPT_TOOLS.has(tool.name) && typeof tool.input?.command === "string" ? tool.input.command : "";
+                    const skill = block.is_error || tool?.name !== "Skill" ? null : buildSkillPreview(text);
+                    const collapsed = block.is_error || patch || skill || !command ? null : buildCollapsedResult(command, text);
+                    const json = block.is_error || patch || skill || collapsed || !command ? null : buildJsonResult(command, text);
+                    const script = patch || skill || collapsed || json || !command ? null : buildScriptResult(text);
+                    out.push(patch
+                        ? { stream: "tool_result", text: `Changed ${patch.files.length} file(s): +${patch.additions} -${patch.deletions}`, payload: patch }
+                        : skill
+                            ? { stream: "tool_result", text: "READ SKILL", payload: skill }
+                            : collapsed
+                                ? { stream: "tool_result", text: collapsed.label, payload: collapsed }
+                                : json
+                                    ? { stream: "tool_result", text: json.label, payload: json }
+                                    : script
+                                        ? { stream: "tool_result", text: clip(text), payload: script }
+                                        : { stream: "tool_result", text: clip(text) });
+                }
+                return out;
+            }
+            return toConsoleLines(event);
+        },
+    };
+}

package/dist/console-payload.js

@@ -0,0 +1,73 @@
+/**
+ * AgentConsole 的结构化展示协议与有界构造器。
+ * 所有代码/文件预览在 daemon 边界裁剪,避免 server/web 接收整文件。
+ */
+export const CONSOLE_PREVIEW_ROWS = 12;
+export const CONSOLE_PREVIEW_HEAD_ROWS = 8;
+export const CONSOLE_DIFF_ROWS = 40;
+export const CONSOLE_ROW_CHARS = 240;
+const clipRow = (text) => text.length > CONSOLE_ROW_CHARS
+    ? `${text.slice(0, CONSOLE_ROW_CHARS)}…`
+    : text;
+/** 头 8 + 尾 4,中间显式 omitted;小文件全部显示。 */
+export function buildFilePreview(operation, path, content, startLine = 1) {
+    const lines = content ? content.split("\n") : [];
+    const visible = lines.length <= CONSOLE_PREVIEW_ROWS
+        ? lines.map((text, index) => ({ type: "line", line: startLine + index, text: clipRow(text) }))
+        : [
+            ...lines.slice(0, CONSOLE_PREVIEW_HEAD_ROWS).map((text, index) => ({
+                type: "line", line: startLine + index, text: clipRow(text),
+            })),
+            { type: "omitted", count: lines.length - CONSOLE_PREVIEW_ROWS },
+            ...lines.slice(-4).map((text, index) => ({
+                type: "line", line: startLine + lines.length - 4 + index, text: clipRow(text),
+            })),
+        ];
+    return {
+        kind: "file_preview",
+        operation,
+        path,
+        totalLines: lines.length,
+        totalBytes: Buffer.byteLength(content, "utf8"),
+        rows: visible,
+    };
+}
+/** old/new 片段转紧凑带双行号 diff;变更中段超过预算时裁剪。 */
+export function buildSnippetDiff(path, oldText, newText) {
+    const oldLines = oldText ? oldText.split("\n") : [];
+    const newLines = newText ? newText.split("\n") : [];
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix++;
+    let oldEnd = oldLines.length;
+    let newEnd = newLines.length;
+    while (oldEnd > prefix && newEnd > prefix && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    const rows = [];
+    const contextStart = Math.max(0, prefix - 2);
+    for (let index = contextStart; index < prefix; index++) {
+        rows.push({ type: "context", oldLine: index + 1, newLine: index + 1, text: clipRow(oldLines[index]) });
+    }
+    for (let index = prefix; index < oldEnd; index++) {
+        rows.push({ type: "delete", oldLine: index + 1, newLine: null, text: clipRow(oldLines[index]) });
+    }
+    for (let index = prefix; index < newEnd; index++) {
+        rows.push({ type: "add", oldLine: null, newLine: index + 1, text: clipRow(newLines[index]) });
+    }
+    for (let offset = 0; offset < Math.min(2, oldLines.length - oldEnd); offset++) {
+        rows.push({ type: "context", oldLine: oldEnd + offset + 1, newLine: newEnd + offset + 1, text: clipRow(oldLines[oldEnd + offset]) });
+    }
+    const additions = Math.max(0, newEnd - prefix);
+    const deletions = Math.max(0, oldEnd - prefix);
+    if (rows.length <= CONSOLE_DIFF_ROWS)
+        return { kind: "diff_rows", files: [{ path, rows }], additions, deletions };
+    const head = rows.slice(0, 28);
+    const tail = rows.slice(-11);
+    return {
+        kind: "diff_rows",
+        files: [{ path, rows: [...head, { type: "omitted", oldCount: rows.length - 39, newCount: rows.length - 39 }, ...tail] }],
+        additions, deletions, truncated: true,
+    };
+}