@nowcrew/daemon 0.5.28 → 0.5.30

package/dist/session.js

@@ -0,0 +1,82 @@
+/**
+ * per-task runtime 会话元数据 —— 让同一任务的重复唤醒复用原生上下文(省 token)。
+ *
+ * 存在本任务隔离运行目录下(<runDir>/.crew-session.json):天然按 taskKey 隔离、落盘防 daemon
+ * 重启丢失。读取一律容错 → 不存在/损坏/字段非法都回退 null(= 当作首轮冷启动),绝不阻断运行。
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const FILE = ".crew-session.json";
+export function sessionPath(runDir) {
+    return join(runDir, FILE);
+}
+/** 读会话元数据;不存在/坏 json/缺 sessionId → null(回退冷启动,绝不抛)。 */
+export async function readSession(runDir) {
+    let raw;
+    try {
+        raw = await readFile(sessionPath(runDir), "utf8");
+    }
+    catch {
+        return null; // 文件不存在 = 首轮
+    }
+    try {
+        const o = JSON.parse(raw);
+        if (typeof o.sessionId !== "string" || !o.sessionId)
+            return null;
+        return {
+            sessionId: o.sessionId,
+            lastRunAt: typeof o.lastRunAt === "number" ? o.lastRunAt : 0,
+            turns: typeof o.turns === "number" ? o.turns : 0,
+            model: typeof o.model === "string" ? o.model : null,
+            providerFingerprint: typeof o.providerFingerprint === "string" ? o.providerFingerprint : null,
+            ...(typeof o.contextTokens === "number" && o.contextTokens >= 0 ? { contextTokens: o.contextTokens } : {}),
+            ...(typeof o.lastExitOk === "boolean" ? { lastExitOk: o.lastExitOk } : {}),
+        };
+    }
+    catch {
+        return null; // 坏 json → 当首轮,不阻断运行
+    }
+}
+export async function writeSession(runDir, meta) {
+    await writeFile(sessionPath(runDir), JSON.stringify(meta, null, 2), "utf8");
+}
+/**
+ * 决定本轮是否 --resume 复用会话:返回 sessionId(resume)或 null(冷启动)。纯函数。
+ *
+ * 防负优化:claude 的 prompt cache 有寿命(默认到 1h),间隔超过 warmMs 后 resume 必然
+ * cache miss——既读不到旧缓存、又要把更大的历史重写进新缓存,反而比冷启动+work-log 更贵。
+ * 故只在缓存窗口内 resume(省),过期则回退冷启动(不亏)。warmMs<=0 关闭阈值(永远 resume)。
+ *
+ * 预算轮换(防上下文无限膨胀):持续活跃的任务会永远命中 warm window,session 历史单调增长
+ * 直到撞模型上限触发被动压缩(慢/贵/质量不可控)。故上轮实测上下文体量(contextTokens)达到
+ * budgetTokens、或续轮数达到 maxTurns(usage 缺失时的兜底)时主动轮换:冷启动 + 注入 work-log
+ * (agent 自己写的结构化现状,比通用摘要保真)。两阈值 <=0 时各自关闭。
+ */
+export function pickResumeId(prior, now, warmMs, currentModel = null, budgetTokens = 0, maxTurns = 0, currentProviderFingerprint = null) {
+    if (!prior)
+        return null;
+    if (prior.model !== currentModel)
+        return null;
+    // provider 配置变了(default↔custom/换端点/换鉴权):旧会话可能存在别的 CLAUDE_CONFIG_DIR
+    // 下,--resume 会直接报错,必须冷启动。
+    if ((prior.providerFingerprint ?? null) !== currentProviderFingerprint)
+        return null;
+    // 上轮崩溃/超窗/被杀:会话大概率已污染(或就是太大),续用几乎必再崩。强制冷启动斩断循环——
+    // 这条不依赖 token 记账是否准确(OOM/SIGKILL 时没有 usage,预算判断会漏,此条兜底)。
+    if (prior.lastExitOk === false)
+        return null;
+    if (warmMs > 0 && now - prior.lastRunAt > warmMs)
+        return null;
+    if (budgetTokens > 0 && (prior.contextTokens ?? 0) >= budgetTokens)
+        return null;
+    if (maxTurns > 0 && prior.turns >= maxTurns)
+        return null;
+    return prior.sessionId;
+}
+/** 上轮上下文是否已接近预算(soft 阈值):是则本轮 wake 附加"蒸馏到 work-log"指令,
+ *  让 agent 在下轮轮换前把现状写全——主动蒸馏替代被动压缩。softTokens<=0 关闭。纯函数。 */
+export function isNearBudget(prior, softTokens) {
+    if (!prior || softTokens <= 0)
+        return false;
+    return (prior.contextTokens ?? 0) >= softTokens;
+}

package/dist/shared-execution-slots.js

@@ -0,0 +1,68 @@
+export function createSharedSlotManager(limits) {
+    const activeByHandle = new Map();
+    const queuesByHandle = new Map();
+    const promoteNext = (handle) => {
+        const queue = queuesByHandle.get(handle) ?? [];
+        while ((activeByHandle.get(handle) ?? 0) < limits.maxParallelPerAgent && queue.length > 0) {
+            const next = queue.shift();
+            if (next.released)
+                continue;
+            next.promoted = true;
+            activeByHandle.set(handle, (activeByHandle.get(handle) ?? 0) + 1);
+            next.resolve();
+        }
+        if (queue.length === 0)
+            queuesByHandle.delete(handle);
+    };
+    return {
+        reserve: (handle, kind) => {
+            const active = activeByHandle.get(handle) ?? 0;
+            const queued = queuesByHandle.get(handle)?.length ?? 0;
+            const facts = { activeForAgent: active, queuedForAgent: queued };
+            if (kind === "execution" && active >= limits.maxParallelPerAgent
+                && queued >= limits.maxQueuedPerAgent) {
+                return { facts, ready: Promise.resolve(), isQueued: () => false, release: () => { } };
+            }
+            let resolveReady;
+            const ready = new Promise((resolve) => { resolveReady = resolve; });
+            const entry = {
+                kind,
+                released: false,
+                promoted: active < limits.maxParallelPerAgent,
+                resolve: resolveReady,
+            };
+            if (entry.promoted) {
+                activeByHandle.set(handle, active + 1);
+                resolveReady();
+            }
+            else {
+                const queue = queuesByHandle.get(handle) ?? [];
+                queue.push(entry);
+                queuesByHandle.set(handle, queue);
+            }
+            return {
+                facts,
+                state: entry.promoted ? "ready" : "queued",
+                ready,
+                isQueued: () => !entry.promoted && !entry.released,
+                release: () => {
+                    if (entry.released)
+                        return;
+                    entry.released = true;
+                    if (entry.promoted) {
+                        activeByHandle.set(handle, Math.max(0, (activeByHandle.get(handle) ?? 1) - 1));
+                    }
+                    else {
+                        const queue = queuesByHandle.get(handle);
+                        const index = queue?.indexOf(entry) ?? -1;
+                        if (queue !== undefined && index >= 0)
+                            queue.splice(index, 1);
+                        if (queue?.length === 0)
+                            queuesByHandle.delete(handle);
+                    }
+                    promoteNext(handle);
+                },
+            };
+        },
+    };
+}

package/dist/shutdown-deadline.js

@@ -0,0 +1,32 @@
+export function readTestShutdownConfiguration(env) {
+    if (env.NODE_ENV !== "test")
+        return { barrier: null };
+    const timeoutMs = env.CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS === undefined
+        ? undefined
+        : Number(env.CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS);
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+        throw new RangeError("CREW_DAEMON_TEST_SHUTDOWN_TIMEOUT_MS must be a positive number");
+    }
+    return {
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        barrier: env.CREW_DAEMON_TEST_SHUTDOWN_BARRIER === "1" ? new Promise(() => { }) : null,
+    };
+}
+export function createShutdownDeadline(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new RangeError("shutdown timeout must be a positive finite number");
+    }
+    const controller = new AbortController();
+    const timeoutError = new Error(`Timed out waiting for daemon shutdown after ${timeoutMs}ms`);
+    let rejectExpired;
+    const expired = new Promise((_resolve, reject) => { rejectExpired = reject; });
+    const timer = setTimeout(() => {
+        controller.abort(timeoutError);
+        rejectExpired(timeoutError);
+    }, timeoutMs);
+    return {
+        signal: controller.signal,
+        waitFor: async (operation) => Promise.race([operation, expired]),
+        dispose: () => clearTimeout(timer),
+    };
+}

package/dist/skill-preview.js

@@ -0,0 +1,21 @@
+const FRONTMATTER = /(?:^|\n)---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+export function buildSkillPreview(output) {
+    const frontmatter = output.match(FRONTMATTER)?.[1];
+    if (!frontmatter)
+        return null;
+    const name = scalar(frontmatter, "name");
+    const description = scalar(frontmatter, "description");
+    if (!name && !description)
+        return null;
+    return {
+        kind: "skill_preview",
+        name: name || "skill",
+        description,
+    };
+}
+function scalar(frontmatter, key) {
+    const match = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    if (!match)
+        return "";
+    return match[1].trim().replace(/^['"]|['"]$/g, "").slice(0, 500);
+}

package/dist/skills.js

@@ -0,0 +1,56 @@
+/**
+ * 枚举某 agent 可用的 skill,供 Profile 的 SKILLS 区展示。两个来源:
+ *  - workspace 私有:<agentsRoot>/<handle>/skills/<name>/SKILL.md
+ *  - 全局共享:    ~/.claude/skills/<name>/SKILL.md (可经 CREW_GLOBAL_SKILLS_DIR 覆盖)
+ *
+ * 每个 skill = 一个目录,内含 SKILL.md;从其 YAML frontmatter 取 name/description,
+ * 缺失则回退到目录名。只读、容错(目录不存在/无 frontmatter 都不报错)。
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const globalSkillsDir = () => process.env.CREW_GLOBAL_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
+/** 从 SKILL.md 顶部 YAML frontmatter 取 name / description (简易解析,够用)。 */
+function parseFrontmatter(md) {
+    const m = md.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!m)
+        return {};
+    const out = {};
+    for (const line of m[1].split("\n")) {
+        const kv = line.match(/^(name|description)\s*:\s*(.+?)\s*$/);
+        if (kv) {
+            const val = kv[2].replace(/^["']|["']$/g, "");
+            if (kv[1] === "name")
+                out.name = val;
+            else
+                out.description = val;
+        }
+    }
+    return out;
+}
+async function readSkillsFrom(dir, scope) {
+    const names = await readdir(dir).catch(() => []);
+    const skills = [];
+    for (const name of names) {
+        if (name.startsWith("."))
+            continue;
+        const skillMd = join(dir, name, "SKILL.md");
+        const s = await stat(skillMd).catch(() => null);
+        if (!s || !s.isFile())
+            continue;
+        const md = await readFile(skillMd, "utf8").catch(() => "");
+        const fm = parseFrontmatter(md);
+        skills.push({ scope, name: fm.name || name, description: fm.description ?? "" });
+    }
+    return skills;
+}
+/** 列出 agent 的 workspace 私有 + 全局 skill,按 name 排序。 */
+export async function listSkills(agentsRoot, handle) {
+    const [ws, global] = await Promise.all([
+        readSkillsFrom(join(agentsRoot, handle, "skills"), "workspace"),
+        readSkillsFrom(globalSkillsDir(), "global"),
+    ]);
+    const all = [...ws, ...global];
+    all.sort((a, b) => (a.scope !== b.scope ? (a.scope === "workspace" ? -1 : 1) : a.name.localeCompare(b.name)));
+    return all;
+}

package/dist/slog.js

@@ -0,0 +1,228 @@
+/**
+ * daemon 侧 SLS 日志客户端 —— 透过 server 的 POST /ingest/logs 上报(daemon 不直连 SLS)。
+ *
+ * 断线补传(关键设计):
+ *   - 每条日志的 ts = 事件**实际发生时间**(epoch ms)。server 把它写成 SLS __time__,
+ *     所以补传的日志仍落在正确时间点,时间线不乱;补传条目带 spooled=true + reported_at 归因。
+ *   - 上报失败(server 不可达/断网)→ 落本地 spool(~/.crew/logs/sls-spool/*.jsonl);
+ *     下次 WS 重连成功(drainSpool)时补传。「daemon 为什么断开」的现场就靠这批日志还原。
+ *   - 进程退出(exit)→ 残余队列同步落 spool,下次启动补传。异步信号由 main.ts 统一收口。
+ *
+ * 永不抛错、永不阻塞业务;未 init 时所有调用是 no-op(兼容单测/一次性 run 模式无凭证场景)。
+ */
+import { hostname } from "node:os";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+const FLUSH_INTERVAL_MS = 1500;
+const BATCH_SIZE = 50;
+const SPOOL_MAX_FILES = 50; // spool 目录文件数上限,超出丢最旧(日志非关键数据,防无限膨胀)
+const SPOOL_DRAIN_CAP = 1000; // 单次补传条数上限
+let cfg = null;
+let defaults = {};
+let queue = [];
+let timer = null;
+let flushPromise = null;
+let inFlightBatch = [];
+let lastErrorAt = 0;
+let exitHookInstalled = false;
+function spoolDir() {
+    return process.env.CREW_SLS_SPOOL_DIR ?? join(homedir(), ".crew", "logs", "sls-spool");
+}
+/** serve/run 启动时调用一次;disabled(CREW_SLS_LOG=off)则保持 no-op。 */
+export function initSlog(serverUrl, machineToken) {
+    if (process.env.CREW_SLS_LOG === "off" || process.env.CREW_SLS_LOG === "0")
+        return;
+    cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
+    defaults = { host: hostname(), pid: process.pid };
+    // 退出兜底:残余队列同步落 spool(exit 回调只能做同步工作,append 正合适)
+    if (!exitHookInstalled) {
+        exitHookInstalled = true;
+        process.once("exit", () => spoolRemainingSync());
+    }
+}
+/** 追加默认关联字段(如 ready 帧下发的 machine_id),之后每条日志自动带上。 */
+export function setSlogDefaults(fields) {
+    defaults = { ...defaults, ...fields };
+}
+/** 记一条结构化日志(异步批量上报;失败自动落 spool)。 */
+export function dslog(eventType, message, fields = {}) {
+    if (!cfg)
+        return;
+    const { level, ...rest } = fields;
+    queue.push({
+        ts: Date.now(),
+        level: level ?? (eventType.includes("error") || eventType.includes("failed") ? "ERROR" : "INFO"),
+        event_type: eventType,
+        message,
+        fields: compact({ ...defaults, ...rest }),
+    });
+    if (queue.length >= BATCH_SIZE) {
+        void flushSlog();
+        return;
+    }
+    if (!timer) {
+        timer = setTimeout(() => void flushSlog(), FLUSH_INTERVAL_MS);
+        timer.unref?.();
+    }
+}
+/** 把内存队列冲到 server;失败整批落 spool(保 ts 不丢现场)。 */
+export async function flushSlog() {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    if (!cfg)
+        return;
+    if (flushPromise !== null)
+        return flushPromise;
+    const current = (async () => {
+        while (queue.length > 0) {
+            const batch = queue;
+            queue = [];
+            inFlightBatch = batch;
+            try {
+                await post(batch);
+            }
+            catch (e) {
+                appendSpool(batch);
+                warnThrottled(`SLS 日志上报失败,已落本地 spool(${batch.length} 条): ${e.message}`);
+            }
+            finally {
+                inFlightBatch = [];
+            }
+        }
+    })();
+    flushPromise = current;
+    try {
+        await current;
+    }
+    finally {
+        if (flushPromise === current)
+            flushPromise = null;
+    }
+}
+/**
+ * 补传本地 spool(WS 重连成功后调用):上次断连/退出前落盘的现场日志,
+ * 此刻才有机会送出。条目加 spooled=true,ts 仍是当时的发生时间。
+ */
+export async function drainSpool() {
+    if (!cfg)
+        return;
+    const dir = spoolDir();
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+    }
+    catch {
+        return; // 目录不存在 = 无积压
+    }
+    if (files.length === 0)
+        return;
+    const entries = [];
+    const consumed = [];
+    for (const f of files) {
+        if (entries.length >= SPOOL_DRAIN_CAP)
+            break;
+        const path = join(dir, f);
+        try {
+            const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const e = JSON.parse(line);
+                    if (typeof e.ts === "number" && typeof e.event_type === "string") {
+                        entries.push({ ...e, fields: { ...(e.fields ?? {}), spooled: true } });
+                    }
+                }
+                catch { /* 坏行跳过 */ }
+            }
+            consumed.push(path);
+        }
+        catch { /* 读失败跳过该文件 */ }
+    }
+    if (entries.length === 0) {
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        return;
+    }
+    try {
+        for (let i = 0; i < entries.length; i += 100) {
+            await post(entries.slice(i, i + 100));
+        }
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        process.stdout.write(`📮 已补传离线期间的 ${entries.length} 条 SLS 日志\n`);
+    }
+    catch (e) {
+        warnThrottled(`spool 补传失败,留待下次重连: ${e.message}`); // 文件保留,下次再试
+    }
+}
+// ── 内部 ─────────────────────────────────────────────────────────
+async function post(entries) {
+    const res = await fetch(`${cfg.serverUrl}/ingest/logs`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${cfg.token}`, "content-type": "application/json" },
+        body: JSON.stringify({
+            entries: entries.map((e) => ({
+                ts: e.ts, level: e.level, event_type: e.event_type, message: e.message, fields: e.fields,
+            })),
+        }),
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+}
+function appendSpool(entries) {
+    try {
+        const dir = spoolDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        rotateSpool(dir);
+        const file = join(dir, `daemon-${Date.now()}-${process.pid}.jsonl`);
+        appendFileSync(file, entries.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    }
+    catch { /* spool 也失败(磁盘只读等):放弃这批,不能影响业务 */ }
+}
+/** 目录内文件超上限时删最旧,防止长期断网把磁盘写满。 */
+function rotateSpool(dir) {
+    try {
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => ({ f, mtime: statSync(join(dir, f)).mtimeMs }))
+            .sort((a, b) => a.mtime - b.mtime);
+        for (const { f } of files.slice(0, Math.max(0, files.length - SPOOL_MAX_FILES + 1))) {
+            unlinkSync(join(dir, f));
+        }
+    }
+    catch { /* 忽略 */ }
+}
+function spoolRemainingSync() {
+    if (inFlightBatch.length === 0 && queue.length === 0)
+        return;
+    const batch = [...inFlightBatch, ...queue];
+    inFlightBatch = [];
+    queue = [];
+    appendSpool(batch);
+}
+function warnThrottled(msg) {
+    const now = Date.now();
+    if (now - lastErrorAt > 60_000) {
+        lastErrorAt = now;
+        process.stderr.write(`[slog] ${msg}\n`);
+    }
+}
+function compact(fields) {
+    const out = {};
+    for (const [k, v] of Object.entries(fields)) {
+        if (v === undefined)
+            continue;
+        out[k] = typeof v === "string" && v.length > 4096 ? `${v.slice(0, 4096)}…(truncated)` : v;
+    }
+    return out;
+}

package/dist/supervised-runtime.js

@@ -0,0 +1,104 @@
+import { fileURLToPath } from "node:url";
+import { startDormantSupervisor, } from "./execution-supervisor.js";
+import { buildClaudeArgs } from "./runtimes/claude.js";
+import { RuntimeCancelledError } from "./runtime-cancellation.js";
+export function supervisorLaunch(request) {
+    const common = {
+        wakePrompt: request.wakePrompt,
+        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 {
+            command: request.bin,
+            args: buildClaudeArgs({
+                ...common,
+                bin: request.bin,
+                cwd: request.cwd,
+                env: request.env,
+                systemPromptPath: request.systemPromptPath,
+                ...(request.sessionId === undefined ? {} : {
+                    sessionId: request.sessionId,
+                    resume: request.resume,
+                }),
+            }),
+            cwd: request.cwd,
+            env: request.env,
+        };
+    }
+    if (request.runtime === "codex") {
+        return {
+            command: process.execPath,
+            args: [
+                fileURLToPath(new URL("./runtimes/codex-app-server-runner.js", import.meta.url)),
+                "--bin", request.bin,
+            ],
+            cwd: request.cwd,
+            env: request.env,
+            stdinText: JSON.stringify({
+                systemPrompt: request.systemPrompt,
+                wakePrompt: request.wakePrompt,
+                effectivePermission: request.effectivePermission,
+                ...(request.model === undefined ? {} : { model: request.model }),
+                ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
+                ...(request.sessionId === undefined ? {} : { sessionId: request.sessionId }),
+                ...(request.imagePaths === undefined ? {} : { imagePaths: request.imagePaths }),
+                resume: request.resume,
+            }),
+        };
+    }
+    if (request.effectivePermission !== "full_access") {
+        throw new Error(`Kimi ACP cannot enforce ${request.effectivePermission} permission`);
+    }
+    return {
+        command: process.execPath,
+        args: [
+            fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
+            "--bin", request.bin,
+            ...(request.model === undefined ? [] : ["--model", request.model]),
+            ...(request.sessionId === undefined ? [] : ["--session", request.sessionId]),
+            ...(request.resume ? ["--resume"] : []),
+        ],
+        cwd: request.cwd,
+        env: request.env,
+        stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
+    };
+}
+export async function launchSupervisedRuntime(request, startSupervisor = startDormantSupervisor, cancellation, platform) {
+    if (cancellation?.isRequested())
+        throw new RuntimeCancelledError();
+    const supervisor = await startSupervisor(supervisorLaunch(request), {
+        ownershipMode: "process-lifetime",
+        ...(platform === undefined ? {} : { platform }),
+    });
+    let stopPromise = null;
+    const cancelOnce = () => {
+        stopPromise ??= Promise.resolve().then(supervisor.cancel);
+        return stopPromise;
+    };
+    cancellation?.register(cancelOnce);
+    if (cancellation?.isRequested()) {
+        await cancellation.waitForStop();
+        throw new RuntimeCancelledError();
+    }
+    const release = supervisor.release();
+    if (cancellation === undefined) {
+        await release;
+    }
+    else {
+        await Promise.race([
+            release,
+            cancellation.requested.then(async () => {
+                await cancellation.waitForStop();
+                throw new RuntimeCancelledError();
+            }),
+        ]);
+    }
+    if (cancellation?.isRequested()) {
+        await cancellation.waitForStop();
+        throw new RuntimeCancelledError();
+    }
+    return { ...supervisor, cancel: cancelOnce };
+}

package/dist/token.js

@@ -0,0 +1,24 @@
+/** 用机器令牌为某 agent 换取 per-launch 的 sk_agent_*。 */
+export async function mintAgentToken(serverUrl, machineToken, handle, displayName, options = {}, fetchImpl = fetch) {
+    const res = await fetchImpl(`${serverUrl}/daemon/agents/token`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${machineToken}`,
+            "content-type": "application/json",
+        },
+        // 把本轮唤醒的线程根钉到 per-launch 令牌:服务端据此让 task/消息默认绑/回当前线程。
+        body: JSON.stringify({
+            handle,
+            ...(displayName ? { displayName } : {}),
+            ...(options.wakeThreadRoot ? { wakeThreadRoot: options.wakeThreadRoot } : {}),
+            ...(options.wakeContextUpToSeq !== undefined ? { wakeContextUpToSeq: options.wakeContextUpToSeq } : {}),
+            ...(options.agentRunId ? { agentRunId: options.agentRunId } : {}),
+            ...(options.executionId ? { executionId: options.executionId } : {}),
+        }),
+    });
+    const body = (await res.json().catch(() => null));
+    if (!res.ok || !body?.success || !body.data) {
+        throw new Error(`换取 agent 令牌失败 (HTTP ${res.status}): ${body?.error?.message ?? ""}`);
+    }
+    return body.data;
+}