@nowcrew/daemon 0.5.19 → 0.5.21

package/dist/slog.js

@@ -6,7 +6,7 @@
  *     所以补传的日志仍落在正确时间点,时间线不乱;补传条目带 spooled=true + reported_at 归因。
  *   - 上报失败(server 不可达/断网)→ 落本地 spool(~/.crew/logs/sls-spool/*.jsonl);
  *     下次 WS 重连成功(drainSpool)时补传。「daemon 为什么断开」的现场就靠这批日志还原。
- *   - 进程退出(SIGINT/SIGTERM/exit)→ 残余队列同步落 spool,下次启动补传。
+ *   - 进程退出(exit)→ 残余队列同步落 spool,下次启动补传。异步信号由 main.ts 统一收口。
  *
  * 永不抛错、永不阻塞业务;未 init 时所有调用是 no-op(兼容单测/一次性 run 模式无凭证场景)。
  */
@@ -22,8 +22,10 @@ let cfg = null;
 let defaults = {};
 let queue = [];
 let timer = null;
-let flushing = false;
+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");
 }
@@ -34,12 +36,9 @@ export function initSlog(serverUrl, machineToken) {
     cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
     defaults = { host: hostname(), pid: process.pid };
     // 退出兜底:残余队列同步落 spool(exit 回调只能做同步工作,append 正合适)
-    process.once("exit", () => spoolRemainingSync());
-    for (const sig of ["SIGINT", "SIGTERM"]) {
-        process.once(sig, () => {
-            spoolRemainingSync();
-            process.exit(sig === "SIGINT" ? 130 : 143);
-        });
+    if (!exitHookInstalled) {
+        exitHookInstalled = true;
+        process.once("exit", () => spoolRemainingSync());
     }
 }
 /** 追加默认关联字段(如 ready 帧下发的 machine_id),之后每条日志自动带上。 */
@@ -73,20 +72,34 @@ export async function flushSlog() {
         clearTimeout(timer);
         timer = null;
     }
-    if (!cfg || flushing || queue.length === 0)
+    if (!cfg)
         return;
-    flushing = true;
-    const batch = queue;
-    queue = [];
+    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 post(batch);
-    }
-    catch (e) {
-        appendSpool(batch);
-        warnThrottled(`SLS 日志上报失败,已落本地 spool(${batch.length} 条): ${e.message}`);
+        await current;
     }
     finally {
-        flushing = false;
+        if (flushPromise === current)
+            flushPromise = null;
     }
 }
 /**
@@ -190,9 +203,10 @@ function rotateSpool(dir) {
     catch { /* 忽略 */ }
 }
 function spoolRemainingSync() {
-    if (queue.length === 0)
+    if (inFlightBatch.length === 0 && queue.length === 0)
         return;
-    const batch = queue;
+    const batch = [...inFlightBatch, ...queue];
+    inFlightBatch = [];
     queue = [];
     appendSpool(batch);
 }

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/websocket-shutdown.js

@@ -0,0 +1,53 @@
+import { WebSocket } from "ws";
+export function closeWebSocketWithinDeadline(socket, signal) {
+    if (socket === null || socket.readyState === WebSocket.CLOSED)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            socket.removeListener("close", onClose);
+            socket.removeListener("error", onError);
+            signal.removeEventListener("abort", onAbort);
+        };
+        const settle = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            outcome();
+        };
+        const onClose = () => settle(resolve);
+        const onError = () => {
+            if (socket.readyState === WebSocket.CLOSED)
+                onClose();
+        };
+        const onAbort = () => {
+            settle(() => {
+                if (socket.readyState !== WebSocket.CLOSED) {
+                    try {
+                        socket.terminate();
+                    }
+                    catch { /* deadline error remains authoritative */ }
+                }
+                reject(signal.reason);
+            });
+        };
+        socket.on("close", onClose);
+        socket.on("error", onError);
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+        else if (socket.readyState === WebSocket.CLOSED) {
+            onClose();
+        }
+        else if (socket.readyState !== WebSocket.CLOSING) {
+            try {
+                socket.close();
+            }
+            catch (error) {
+                settle(() => reject(error));
+            }
+        }
+    });
+}

package/dist/win32-job-object.js

@@ -0,0 +1,193 @@
+/**
+ * Windows Job Object 执行后端的 FFI 封装(仅 win32 生效)。
+ *
+ * Node 不暴露 Job Object API,这里用 koffi 直接调 kernel32.dll。koffi 是可选依赖
+ * (optionalDependencies),用 createRequire 惰性同步加载 —— 加载失败/非 win32 一律抛错,
+ * 由上层降级到 fail-closed,不影响 Mac/Linux 路径。
+ *
+ * 关键语义:job 上设 JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE 后,持有 job handle 的进程一旦退出
+ * (含崩溃),内核立即回收 Job 内所有进程 —— 等价于 POSIX「父死子亡 + 进程组整组清理」,且更强。
+ * 因此 job 必须由「离 runtime 最近、崩溃即代表该放弃所有权」的进程(supervisor child)创建并持有。
+ */
+import { createRequire } from "node:module";
+const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x0000_2000;
+const JOBOBJECT_EXTENDED_LIMIT_INFORMATION = 9;
+const JOBOBJECT_BASIC_ACCOUNTING_INFORMATION = 1;
+const PROCESS_TERMINATE = 0x0001;
+const PROCESS_SET_QUOTA = 0x0100;
+const JOB_ASSIGN_ACCESS = PROCESS_TERMINATE | PROCESS_SET_QUOTA;
+const JOB_EMPTY_POLL_MS = 10;
+// koffi 的 struct 布局/对齐由类型描述自动推导,无需手工塞 padding。
+// size_t/uintptr_t 在 x64/arm64 均为 8 字节,与 SIZE_T/ULONG_PTR 对齐。
+const BASIC_LIMIT_INFORMATION = {
+    PerProcessUserTimeLimit: "int64",
+    PerJobUserTimeLimit: "int64",
+    LimitFlags: "uint32",
+    MinimumWorkingSetSize: "size_t",
+    MaximumWorkingSetSize: "size_t",
+    ActiveProcessLimit: "uint32",
+    Affinity: "uintptr_t",
+    PriorityClass: "uint32",
+    SchedulingClass: "uint32",
+};
+const IO_COUNTERS = {
+    ReadOperationCount: "uint64",
+    WriteOperationCount: "uint64",
+    OtherOperationCount: "uint64",
+    ReadTransferCount: "uint64",
+    WriteTransferCount: "uint64",
+    OtherTransferCount: "uint64",
+};
+let cachedApi = null;
+let loadFailed = false;
+/**
+ * 惰性加载并绑定 kernel32。非 win32 或 koffi 不可用时抛错。结果缓存;失败也缓存(不反复重试)。
+ */
+function loadKernel32() {
+    if (cachedApi !== null)
+        return cachedApi;
+    if (loadFailed)
+        throw new Error("Windows Job Object backend previously failed to load");
+    if (process.platform !== "win32") {
+        loadFailed = true;
+        throw new Error("Windows Job Object backend is only available on win32");
+    }
+    try {
+        cachedApi = bindKernel32();
+        return cachedApi;
+    }
+    catch (error) {
+        loadFailed = true;
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+function bindKernel32() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- koffi 无类型声明,单点收窄。
+    const koffi = createRequire(import.meta.url)("koffi");
+    const lib = koffi.load("kernel32.dll");
+    koffi.struct("JOBOBJECT_BASIC_LIMIT_INFORMATION", BASIC_LIMIT_INFORMATION);
+    koffi.struct("IO_COUNTERS", IO_COUNTERS);
+    koffi.struct("JOBOBJECT_EXTENDED_LIMIT_INFORMATION", {
+        BasicLimitInformation: "JOBOBJECT_BASIC_LIMIT_INFORMATION",
+        IoInfo: "IO_COUNTERS",
+        ProcessMemoryLimit: "size_t",
+        JobMemoryLimit: "size_t",
+        PeakProcessMemoryUsed: "size_t",
+        PeakJobMemoryUsed: "size_t",
+    });
+    koffi.struct("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION", {
+        TotalUserTime: "int64",
+        TotalKernelTime: "int64",
+        ThisPeriodTotalUserTime: "int64",
+        ThisPeriodTotalKernelTime: "int64",
+        TotalPageFaultCount: "uint32",
+        TotalProcesses: "uint32",
+        ActiveProcesses: "uint32",
+        TotalTerminatedProcesses: "uint32",
+    });
+    const CreateJobObjectW = lib.func("void* __stdcall CreateJobObjectW(void* attrs, void* name)");
+    const SetInformationJobObject = lib.func("bool __stdcall SetInformationJobObject(void* job, int cls, void* info, uint32_t len)");
+    const OpenProcess = lib.func("void* __stdcall OpenProcess(uint32_t access, bool inherit, uint32_t pid)");
+    const AssignProcessToJobObject = lib.func("bool __stdcall AssignProcessToJobObject(void* job, void* process)");
+    const TerminateJobObject = lib.func("bool __stdcall TerminateJobObject(void* job, uint32_t code)");
+    const QueryInformationJobObject = lib.func("bool __stdcall QueryInformationJobObject(void* job, int cls, _Out_ void* info, uint32_t len, void* ret)");
+    const CloseHandle = lib.func("bool __stdcall CloseHandle(void* handle)");
+    const GetLastError = lib.func("uint32_t __stdcall GetLastError()");
+    return {
+        createJobObject: () => CreateJobObjectW(null, null),
+        setKillOnClose: (job) => {
+            // 只需把 LimitFlags 置上 KILL_ON_JOB_CLOSE,其余字段留 0。用 Buffer + offsetof 直写,
+            // 规避 koffi.encode 的入参数量怪癖;offset 由 koffi 从结构体推导,x64/arm64 一致。
+            const size = koffi.sizeof("JOBOBJECT_EXTENDED_LIMIT_INFORMATION");
+            const flagsOffset = koffi.offsetof("JOBOBJECT_BASIC_LIMIT_INFORMATION", "LimitFlags");
+            const buffer = Buffer.alloc(size);
+            buffer.writeUInt32LE(JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, flagsOffset);
+            return SetInformationJobObject(job, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, buffer, size);
+        },
+        openProcess: (access, inherit, pid) => OpenProcess(access, inherit, pid),
+        assignProcessToJob: (job, process) => AssignProcessToJobObject(job, process),
+        terminateJobObject: (job, exitCode) => TerminateJobObject(job, exitCode),
+        queryActiveProcessCount: (job) => {
+            const size = koffi.sizeof("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION");
+            const activeOffset = koffi.offsetof("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION", "ActiveProcesses");
+            const buffer = Buffer.alloc(size);
+            const ok = QueryInformationJobObject(job, JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, buffer, size, null);
+            if (!ok)
+                throw new Error(`QueryInformationJobObject failed (GetLastError=${GetLastError()})`);
+            return buffer.readUInt32LE(activeOffset);
+        },
+        closeHandle: (handle) => CloseHandle(handle),
+        getLastError: () => GetLastError(),
+    };
+}
+/**
+ * 同步探测:能否创建带 KILL_ON_JOB_CLOSE 的 Job Object。用于 backend 能力判定。
+ * 非 win32 / koffi 缺失 / API 调用失败 → false(fail-closed 降级 legacy)。副作用为零(建后即关)。
+ */
+export function isJobObjectSupported() {
+    if (process.platform !== "win32")
+        return false;
+    try {
+        const handle = createKillOnCloseJob();
+        closeJob(handle);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 创建带 KILL_ON_JOB_CLOSE 的 Job Object。失败抛错。 */
+export function createKillOnCloseJob() {
+    const api = loadKernel32();
+    const native = api.createJobObject();
+    if (!native)
+        throw new Error(`CreateJobObjectW failed (GetLastError=${api.getLastError()})`);
+    if (!api.setKillOnClose(native)) {
+        const code = api.getLastError();
+        api.closeHandle(native);
+        throw new Error(`SetInformationJobObject(KILL_ON_JOB_CLOSE) failed (GetLastError=${code})`);
+    }
+    return { native };
+}
+/** 把 pid 对应进程塞进 Job。进程随后 fork 的子孙默认继承 Job(未设 SILENT_BREAKAWAY,禁止逃逸)。 */
+export function assignProcessToJob(handle, pid) {
+    const api = loadKernel32();
+    const process = api.openProcess(JOB_ASSIGN_ACCESS, false, pid);
+    if (!process)
+        throw new Error(`OpenProcess(${pid}) failed (GetLastError=${api.getLastError()})`);
+    try {
+        if (!api.assignProcessToJob(handle.native, process)) {
+            throw new Error(`AssignProcessToJobObject(${pid}) failed (GetLastError=${api.getLastError()})`);
+        }
+    }
+    finally {
+        api.closeHandle(process);
+    }
+}
+/** 一次性杀光 Job 内所有进程(超时/取消/runtime 挂了 supervisor 还在)。 */
+export function terminateJob(handle, exitCode = 1) {
+    const api = loadKernel32();
+    if (!api.terminateJobObject(handle.native, exitCode)) {
+        throw new Error(`TerminateJobObject failed (GetLastError=${api.getLastError()})`);
+    }
+}
+/** 关闭 job handle。若为最后一个引用且设了 KILL_ON_JOB_CLOSE,内核连带杀光 Job 内进程。 */
+export function closeJob(handle) {
+    const api = loadKernel32();
+    api.closeHandle(handle.native);
+}
+/** 当前 Job 内活跃进程数(BasicAccountingInformation.ActiveProcesses)。 */
+export function activeProcessCount(handle) {
+    return loadKernel32().queryActiveProcessCount(handle.native);
+}
+/** 轮询等待 Job 清空(整组退出确认),复用 10ms 节奏。超时抛错。 */
+export async function waitForJobEmpty(handle, timeoutMs, pollMs = JOB_EMPTY_POLL_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        if (activeProcessCount(handle) === 0)
+            return;
+        if (Date.now() >= deadline)
+            throw new Error(`Job Object did not empty within ${timeoutMs}ms`);
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -21,7 +21,10 @@
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.11"
+    "@nowcrew/cli": "^0.4.12"
+  },
+  "optionalDependencies": {
+    "koffi": "^2.9.0"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",