@botlearn-course/daemon 0.0.1

package/dist/runtimes/ndjson-stream.js

@@ -0,0 +1,207 @@
+import { spawn } from "node:child_process";
+import { safeCommand, sanitizeRuntimeFailureText, tailText } from "../redaction.js";
+import { sliceUtf8Bytes, utf8ByteLength } from "./text-cap.js";
+import { consoleLogger, } from "./engine.js";
+/** 合成 exit-code 错误时保留的 stderr 末尾长度。 */
+const STDERR_ERROR_SNIPPET = 500;
+/** 单轮流式 assistant 文本字节上限 —— 防失控 CLI。 */
+const ASSISTANT_TEXT_CAP = 1 * 1024 * 1024;
+/** abort 时 SIGTERM → SIGKILL 的宽限期。 */
+const KILL_GRACE_MS = 5_000;
+/**
+ * 输出 newline-delimited JSON 的 CLI adapter 公共骨架。子类只需提供：
+ *   - resolveBinary() — 要 spawn 的可执行文件
+ *   - buildArgs()     — argv 尾部（不含二进制本身）
+ *   - handleEvent()   — 如何解释一条已解析的 JSON 事件
+ * spawn、abort、stderr 收集、行切分与 exit-code 错误合成由基类处理。
+ */
+export class NdjsonStreamAdapter {
+    log;
+    constructor(logger) {
+        this.log = logger ?? consoleLogger;
+    }
+    /** 覆盖以调整 env（FORCE_COLOR=0、NO_COLOR=1 等）。 */
+    spawnEnv(_opts) {
+        return { ...process.env };
+    }
+    async run(opts) {
+        if (opts.signal.aborted) {
+            return {
+                text: "",
+                newSessionId: opts.sessionId ?? "",
+                error: `${this.id} aborted before spawn`,
+            };
+        }
+        const binary = this.resolveBinary(opts);
+        const args = this.buildArgs(opts);
+        this.log.debug(`${this.id} spawn`, {
+            cwd: opts.cwd,
+            sessionId: opts.sessionId,
+            argv: args,
+        });
+        const startedAt = Date.now();
+        const child = spawn(binary, args, {
+            cwd: opts.cwd,
+            env: this.spawnEnv(opts),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        // spawn 是同步的，但若在 spawn 与稍后挂监听之间发生 abort 会被漏掉，
+        // 所以必须立即挂 abort 监听。
+        let killTimer = null;
+        const onAbort = () => {
+            if (child.killed)
+                return;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => {
+                if (!child.killed) {
+                    this.log.warn(`${this.id} did not exit after SIGTERM; sending SIGKILL`);
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+            }, KILL_GRACE_MS);
+            if (typeof killTimer.unref === "function")
+                killTimer.unref();
+        };
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        const state = {
+            newSessionId: opts.sessionId ?? "",
+            finalText: "",
+            assistantTextChunks: [],
+            assistantTextBytes: 0,
+            assistantTextCapped: false,
+        };
+        const appendAssistantText = (text) => {
+            if (!text)
+                return;
+            if (state.assistantTextCapped)
+                return;
+            const budget = ASSISTANT_TEXT_CAP - state.assistantTextBytes;
+            if (budget <= 0) {
+                state.assistantTextCapped = true;
+                this.log.warn(`${this.id} assistant text exceeded ${ASSISTANT_TEXT_CAP} bytes; dropping further chunks`);
+                return;
+            }
+            const bytes = utf8ByteLength(text);
+            if (bytes > budget) {
+                const chunk = sliceUtf8Bytes(text, budget);
+                if (chunk) {
+                    state.assistantTextChunks.push(chunk);
+                    state.assistantTextBytes += utf8ByteLength(chunk);
+                }
+                state.assistantTextCapped = true;
+                this.log.warn(`${this.id} assistant text hit ${ASSISTANT_TEXT_CAP}-byte cap`);
+                return;
+            }
+            state.assistantTextChunks.push(text);
+            state.assistantTextBytes += bytes;
+        };
+        let stderrTail = "";
+        let stdoutTail = "";
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderrTail = sanitizeRuntimeFailureText(stderrTail + chunk);
+        });
+        let seq = 0;
+        let stdoutBuf = "";
+        child.stdout.setEncoding("utf8");
+        const dispatchLine = (line) => {
+            if (!line)
+                return;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                this.log.warn(`${this.id} non-json stdout line`, { line: line.slice(0, 200) });
+                return;
+            }
+            seq += 1;
+            try {
+                this.handleEvent(obj, {
+                    state,
+                    seq,
+                    emitBlock: (b) => opts.onBlock?.(b),
+                    appendAssistantText,
+                    emitStatus: (e) => {
+                        try {
+                            opts.onStatus?.(e);
+                        }
+                        catch (err) {
+                            this.log.warn(`${this.id} onStatus threw`, { err: String(err) });
+                        }
+                    },
+                });
+            }
+            catch (err) {
+                this.log.warn(`${this.id} event handler threw`, { err: String(err) });
+            }
+        };
+        child.stdout.on("data", (chunk) => {
+            stdoutTail = sanitizeRuntimeFailureText(stdoutTail + chunk);
+            stdoutBuf += chunk;
+            let idx;
+            while ((idx = stdoutBuf.indexOf("\n")) !== -1) {
+                const line = stdoutBuf.slice(0, idx).trim();
+                stdoutBuf = stdoutBuf.slice(idx + 1);
+                dispatchLine(line);
+            }
+        });
+        let code = 0;
+        let signal = null;
+        try {
+            ({ code, signal } = await new Promise((resolve, reject) => {
+                child.on("error", reject);
+                child.on("close", (c, s) => resolve({ code: c, signal: s }));
+            }));
+        }
+        finally {
+            opts.signal.removeEventListener("abort", onAbort);
+            if (killTimer)
+                clearTimeout(killTimer);
+        }
+        // 冲刷最后一条没有换行符结尾的行。
+        const residual = stdoutBuf.trim();
+        if (residual)
+            dispatchLine(residual);
+        if (code !== 0 && !state.errorText) {
+            state.errorText = `${this.id} exited with code ${code}: ${stderrTail.slice(-STDERR_ERROR_SNIPPET)}`;
+        }
+        const rawText = state.finalText || state.assistantTextChunks.join("").trim();
+        if (code === 0 && !state.errorText && !rawText && looksLikeTerminalStderr(stderrTail)) {
+            state.errorText = `${this.id} reported an error on stderr: ${stderrTail.slice(-STDERR_ERROR_SNIPPET)}`;
+        }
+        const text = utf8ByteLength(rawText) > ASSISTANT_TEXT_CAP
+            ? sliceUtf8Bytes(rawText, ASSISTANT_TEXT_CAP)
+            : rawText;
+        return {
+            text,
+            newSessionId: state.newSessionId,
+            ...(state.costUsd !== undefined ? { costUsd: state.costUsd } : {}),
+            ...(state.errorText ? { error: state.errorText } : {}),
+            ...(state.errorText
+                ? {
+                    runtimeFailure: {
+                        runtime: this.id,
+                        cwd: opts.cwd,
+                        command: safeCommand([binary, ...args]),
+                        exit_code: code,
+                        signal,
+                        duration_ms: Date.now() - startedAt,
+                        stderr_tail: tailText(stderrTail, 8192),
+                        stdout_tail: tailText(stdoutTail, 8192),
+                        error_message: sanitizeRuntimeFailureText(state.errorText, 2048),
+                    },
+                }
+                : {}),
+        };
+    }
+}
+function looksLikeTerminalStderr(text) {
+    if (!text.trim())
+        return false;
+    return /\b(error|failed|failure|exception|traceback|unauthorized|forbidden|authentication|permission denied)\b|rate limit|quota exceeded|invalid api key|api call failed/i.test(text);
+}

package/dist/runtimes/openclaw-acp.d.ts

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+import { type ProbeDeps } from "./probe.js";
+import { type EngineAdapter, type EngineRunOptions, type EngineRunResult } from "./engine.js";
+import type { RuntimeModule, RuntimeProbe } from "../types.js";
+/** OpenClaw 网关端点。仅来自环境变量，不做本地发现。 */
+export interface OpenclawGatewayConfig {
+    url: string;
+    token?: string;
+    openclawAgent?: string;
+}
+export declare function resolveOpenclawGatewayFromEnv(env?: NodeJS.ProcessEnv): OpenclawGatewayConfig | null;
+/** 仅测试用：清空进程池。 */
+export declare function __resetOpenclawAcpPoolForTests(): void;
+/** 可用 = 二进制在 PATH 上且 BOTLEARN_OPENCLAW_URL 已配置。 */
+export declare function probeOpenclaw(deps?: ProbeDeps): RuntimeProbe;
+interface SpawnDeps {
+    spawnFn?: typeof spawn;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * OpenClaw ACP 引擎。spawn `openclaw acp --url <gateway> [--token <token>]`
+ * 并跨 run 复用子进程（stdio JSON-RPC）；网关端点仅来自
+ * BOTLEARN_OPENCLAW_URL / BOTLEARN_OPENCLAW_TOKEN / BOTLEARN_OPENCLAW_AGENT。
+ * 每 run 用 `_meta.sessionKey`（含 cwd，即 run 工作区）标识稳定会话；
+ * 缓存的 ACP sessionId 只是传输层句柄，load 失败即丢弃重建。
+ *
+ * 权限姿态：course run 在 owner 本机工作区执行，网关侧的权限策略由
+ * OpenClaw 自身配置决定，daemon 不代答权限请求（ACP acp 模式无 reverse-call）。
+ */
+export declare class OpenclawAcpAdapter implements EngineAdapter {
+    readonly id: "openclaw-acp";
+    private readonly spawnFn;
+    private readonly env;
+    constructor(deps?: SpawnDeps);
+    run(opts: EngineRunOptions): Promise<EngineRunResult>;
+    private acquireHandle;
+    private spawnAcpProcess;
+    private newSession;
+    private loadSession;
+    private prompt;
+}
+/**
+ * 构造 OpenClaw ACP `sessionKey`。始终包含 accountId 段，避免两个 daemon
+ * 身份在同一网关上的 key 冲突。
+ */
+export declare function buildAcpSessionKey(args: {
+    openclawAgent: string;
+    accountId: string;
+    conversationKey: string;
+}): string;
+export declare const openclawAcpModule: RuntimeModule;
+export {};