@konglx/rotom 2.21.0

package/dist/executor/index.js

@@ -0,0 +1,269 @@
+/**
+ * Mesh Executor — Agent 服务（多 Worker 架构）
+ *
+ * 一个 executor 进程管理多个数字员工（worker），每个 worker 拥有：
+ * - 独立身份（name/token/profile）
+ * - 独立 WebSocket 连接
+ * - 独立 CLI 后端（claude/codex/openclaw/...）
+ * - 独立任务队列
+ *
+ * 配置向后兼容：单 worker 格式仍然可用。
+ *
+ * Usage:
+ *   npx tsx src/executor/index.ts                                # 读 ~/.rotom/executor.config.json
+ *   npx tsx src/executor/index.ts --config /path/to/config.json  # 显式指定
+ */
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ClaudeCodeExecutor } from "./executors/claude-code.js";
+import { CodexExecutor } from "./executors/codex.js";
+import { HermesCliExecutor } from "./executors/hermes-cli.js";
+import { OpenclawExecutor } from "./executors/openclaw.js";
+import { PiExecutor } from "./executors/pi.js";
+import { ExecutorWorker } from "./worker.js";
+import { SessionStore } from "./session-store.js";
+import { ensureRotomSkillMd } from "../shared/skill-md.js";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor", { stream: "stderr" });
+const ROTOM_HOME = process.env.ROTOM_HOME || path.join(os.homedir(), ".rotom");
+const DEFAULT_CONFIG_PATH = path.join(ROTOM_HOME, "executor.config.json");
+const AUTO_CONFIG_PATH = path.join(ROTOM_HOME, ".auto-executor.json");
+function loadConfig() {
+    // 优先级:CLI --config > 用户配置 executor.config.json > master 自动生成 .auto-executor.json
+    const configIdx = process.argv.indexOf("--config");
+    if (configIdx !== -1 && process.argv[configIdx + 1]) {
+        const configPath = path.resolve(process.argv[configIdx + 1]);
+        if (!fs.existsSync(configPath)) {
+            log.error(`Config not found: ${configPath}`);
+            process.exit(1);
+        }
+        return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+    if (fs.existsSync(DEFAULT_CONFIG_PATH)) {
+        return JSON.parse(fs.readFileSync(DEFAULT_CONFIG_PATH, "utf-8"));
+    }
+    if (fs.existsSync(AUTO_CONFIG_PATH)) {
+        const auto = JSON.parse(fs.readFileSync(AUTO_CONFIG_PATH, "utf-8"));
+        log.info(`Loaded auto-config from ${AUTO_CONFIG_PATH} (OPC mode, token optional)`);
+        if (auto.scanClis) {
+            // CLI 扫描模式:为每个本机已安装的 CLI 起一个 worker。
+            const installed = detectInstalledClis();
+            if (installed.length === 0) {
+                log.error("scanClis=true but no known CLI (claude/openclaw/codex/hermes/pi) found in PATH");
+                process.exit(1);
+            }
+            return {
+                master: auto.master,
+                workers: installed.map(cli => ({
+                    name: cli,
+                    cliTool: cli,
+                    workingDir: auto.workingDir,
+                })),
+            };
+        }
+        if (!auto.defaultAgent) {
+            log.error(`${AUTO_CONFIG_PATH} missing defaultAgent or scanClis — invalid OPC config`);
+            process.exit(1);
+        }
+        return {
+            master: auto.master,
+            name: auto.defaultAgent.name,
+            // token 可能为 null(本机信任模式),undefined 比 null 更干净
+            token: auto.token ?? undefined,
+            cliTool: auto.defaultAgent.cliTool,
+            profile: auto.defaultAgent.profile,
+            workingDir: auto.workingDir,
+        };
+    }
+    log.error(`No config found. Either:\n` +
+        `  1. Run mesh-master (it auto-spawns a local executor in OPC mode), or\n` +
+        `  2. Create ${DEFAULT_CONFIG_PATH}:\n` +
+        JSON.stringify({
+            master: "ws://localhost:28800",
+            workers: [
+                { name: "Claude·Agent", token: "mesh_xxx", cliTool: "claude", workingDir: "/path/to/project" },
+            ],
+        }, null, 2));
+    process.exit(1);
+}
+// ── CLI tool detection ──────────────────────────────────────────────────
+const CLI_PRIORITY = ["claude", "openclaw", "codex", "pi"];
+const ALL_KNOWN_CLIS = ["claude", "openclaw", "codex", "hermes", "pi"];
+function detectCliTool() {
+    for (const tool of CLI_PRIORITY) {
+        try {
+            execSync(`which ${tool}`, { stdio: "pipe" });
+            return tool;
+        }
+        catch { /* not found */ }
+    }
+    return "claude";
+}
+/**
+ * 扫描本机已安装的 CLI,返回数组。OPC 模式下若无 executor.config.json,
+ * 为每个已安装的 CLI 自动注册一个 agent(name 默认 = CLI 名,可通过后续
+ * 配置覆盖)。这是"每台机器 = 一个真人 + 多个 CLI agent"语义的关键。
+ */
+function detectInstalledClis() {
+    const found = [];
+    for (const tool of ALL_KNOWN_CLIS) {
+        try {
+            execSync(`which ${tool}`, { stdio: "pipe" });
+            found.push(tool);
+        }
+        catch { /* not installed */ }
+    }
+    return found;
+}
+function createExecutor(tool) {
+    switch (tool) {
+        case "claude":
+            return new ClaudeCodeExecutor();
+        case "hermes":
+            return new HermesCliExecutor();
+        case "openclaw":
+            return new OpenclawExecutor();
+        case "codex":
+            return new CodexExecutor();
+        case "pi":
+            return new PiExecutor();
+        default:
+            throw new Error(`Unknown cliTool "${tool}". Valid values: claude | codex | hermes | openclaw | pi. ` +
+                `Configure one of these explicitly in executor.config.json (the previous generic passthrough has been removed — set a known tool to avoid silent misconfiguration).`);
+    }
+}
+// ── Normalize config to WorkerConfig[] ──────────────────────────────────
+function normalizeWorkers(config) {
+    // 兼容 .auto-executor.json 格式(由 master ensureLocalExecutor 生成):
+    // 该格式有 defaultAgent 字段,无顶层 name/token。统一在这里转换,无论配置
+    // 是从 CLI --config、executor.config.json 还是 .auto-executor.json 读来的。
+    const maybeAuto = config;
+    // scanClis 模式:扫本机 CLI,每个一个 worker
+    if (maybeAuto.scanClis === true) {
+        const auto = maybeAuto;
+        const installed = detectInstalledClis();
+        if (installed.length === 0) {
+            log.error("scanClis=true but no known CLI (claude/openclaw/codex/hermes/pi) found in PATH");
+            process.exit(1);
+        }
+        return {
+            master: auto.master,
+            workers: installed.map(cli => ({
+                name: cli,
+                cliTool: cli,
+                workingDir: auto.workingDir,
+            })),
+        };
+    }
+    if (maybeAuto.defaultAgent && typeof maybeAuto.defaultAgent === "object") {
+        const auto = maybeAuto;
+        const da = auto.defaultAgent;
+        return {
+            master: auto.master,
+            workers: [{
+                    name: da.name,
+                    token: auto.token ?? undefined,
+                    cliTool: da.cliTool,
+                    profile: da.profile,
+                    workingDir: auto.workingDir,
+                }],
+        };
+    }
+    if ("workers" in config && Array.isArray(config.workers)) {
+        return { master: config.master, workers: config.workers };
+    }
+    // Single worker backward compatibility
+    const single = config;
+    return {
+        master: single.master,
+        workers: [{
+                name: single.name,
+                token: single.token,
+                cliTool: single.cliTool,
+                profile: single.profile,
+                workingDir: single.workingDir,
+                maxConcurrent: single.maxConcurrent,
+            }],
+    };
+}
+// ── Main ────────────────────────────────────────────────────────────────
+const config = loadConfig();
+const { master, workers } = normalizeWorkers(config);
+if (!master) {
+    log.error("Config requires: master");
+    process.exit(1);
+}
+if (workers.length === 0) {
+    log.error("Config requires at least one worker");
+    process.exit(1);
+}
+for (const w of workers) {
+    if (!w.name) {
+        log.error(`Worker requires: name (got: ${JSON.stringify({ name: w.name })})`);
+        process.exit(1);
+    }
+    if (!w.token) {
+        // OPC 模式下 token 可空 —— 走 master 端 isLoopback 信任。
+        // 但远程连接(用户配 ws://remote)时空 token 必失败,提示一下。
+        const isLoopbackMaster = /^wss?:\/\/(127\.0\.0\.1|localhost|\[?::1\]?)(:\d+)?(\/|$)/.test(master);
+        if (isLoopbackMaster) {
+            log.info(`worker "${w.name}" has no token — relying on master loopback trust`);
+        }
+        else {
+            log.warn(`worker "${w.name}" has no token but master is remote (${master}) — auth will likely fail`);
+        }
+    }
+    // workingDir 必填 + 存在性 + 可读性校验
+    // 跨机器部署时该路径必须存在于 executor 本地 FS,与 master 无关
+    if (!w.workingDir) {
+        log.error(`worker "${w.name}" missing required "workingDir" in executor.config.json — agent needs a local project dir to read. Aborting.`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(w.workingDir)) {
+        log.error(`worker "${w.name}" workingDir "${w.workingDir}" does not exist on this machine. Aborting.`);
+        process.exit(1);
+    }
+    try {
+        fs.accessSync(w.workingDir, fs.constants.R_OK);
+    }
+    catch {
+        log.error(`worker "${w.name}" workingDir "${w.workingDir}" is not readable. Aborting.`);
+        process.exit(1);
+    }
+}
+const fallbackCli = detectCliTool();
+const workerInstances = [];
+// 进程级共享 SessionStore —— 所有 worker 共用同一份内存 map。持久化在 master
+// DB 的 agent_sessions 表里,worker 启动时通过 session_sync_push 从 master 拉。
+const sharedSessions = new SessionStore();
+// 一次性迁移:把旧的 ~/.rotom/sessions.json 灌进内存,auth_ok 后会推给 master
+// 落 DB。文件读完即删,后续启动直接走 master DB。
+sharedSessions.backfillFromLegacyJson(ROTOM_HOME);
+for (const w of workers) {
+    const cliTool = w.cliTool || fallbackCli;
+    const executor = createExecutor(cliTool);
+    // 第 5 个参数 rotomHome:SessionStore 文件落点,与 per-group cwd 派生路径解耦;
+    // 第 6 个参数 sharedSessions:进程级单例,所有 worker 共用。
+    const worker = new ExecutorWorker(w, executor, master, cliTool, ROTOM_HOME, sharedSessions);
+    workerInstances.push(worker);
+    const mapCount = w.workingDirMap ? Object.keys(w.workingDirMap).length : 0;
+    log.info(`worker "${w.name}" base cwd: ${w.workingDir} (per-group: <base>/<groupId>${mapCount > 0 ? `, ${mapCount} explicit override(s)` : ""})`);
+}
+log.info(`Starting ${workerInstances.length} worker(s) (fallback cli: ${fallbackCli})`);
+// 启动时把 SKILL.md 落到 ~/.rotom/。幂等(内容相同则跳过),best-effort。
+ensureRotomSkillMd();
+for (const worker of workerInstances) {
+    worker.start();
+}
+// Graceful shutdown
+function shutdown() {
+    log.info(`Shutting down ${workerInstances.length} worker(s)...`);
+    for (const worker of workerInstances) {
+        worker.stop();
+    }
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

package/dist/executor/jsonrpc-transport.js

@@ -0,0 +1,125 @@
+/**
+ * JSON-RPC 2.0 transport for executor CLI backends that speak the protocol
+ * over stdio (codex app-server, hermes-cli acp_adapter).
+ *
+ * Owns:
+ *   • pending-request map (id → resolver)
+ *   • line framing from stdout
+ *   • dispatch of responses / notifications / server-requests
+ *
+ * Does NOT own: process lifecycle (see process-runner.ts), stdin write
+ * (we hand the caller a `send` function that wraps JSON + newline).
+ */
+import { createInterface } from "node:readline";
+import { encodeJsonLine } from "../shared/json-codec.js";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor-jsonrpc", { stream: "stderr" });
+/**
+ * Build a JSON-RPC transport bound to `stdout` for incoming frames and
+ * `stdin` (if provided) for outgoing writes.
+ *
+ * The caller still owns the underlying process — when it exits, call
+ * `rejectPending` so any in-flight requests unblock with an error instead
+ * of hanging forever.
+ */
+export function createJsonRpcTransport(opts) {
+    const pending = new Map();
+    let idCounter = 1;
+    const nextId = () => idCounter++;
+    const send = (msg) => {
+        if (!opts.stdin || opts.stdin.destroyed)
+            return;
+        opts.stdin.write(encodeJsonLine(msg));
+    };
+    const notify = (method, params) => {
+        send({
+            jsonrpc: "2.0",
+            method,
+            ...(params !== undefined ? { params } : {}),
+        });
+    };
+    const request = (method, params) => {
+        const id = nextId();
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject, method });
+            send({ jsonrpc: "2.0", id, method, params });
+        });
+    };
+    const respond = (id, result) => {
+        send({ jsonrpc: "2.0", id, result });
+    };
+    const respondError = (id, code, message) => {
+        send({ jsonrpc: "2.0", id, error: { code, message } });
+    };
+    const rejectPending = (err) => {
+        for (const [id, p] of pending) {
+            p.reject(err);
+            pending.delete(id);
+        }
+    };
+    const handleLine = (line) => {
+        if (!line.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            log.warn(opts.label, "Discarding malformed JSON-RPC frame:", err.message);
+            return;
+        }
+        const hasId = "id" in parsed;
+        const hasMethod = "method" in parsed;
+        if (hasMethod && hasId) {
+            // server → client request
+            try {
+                opts.onRequest?.(String(parsed.method), parsed.params, parsed.id);
+            }
+            catch (err) {
+                log.error(opts.label, "onRequest handler threw for", parsed.method, ":", err.message);
+            }
+            return;
+        }
+        if (hasMethod) {
+            // server → client notification
+            try {
+                opts.onNotification?.(String(parsed.method), parsed.params);
+            }
+            catch (err) {
+                log.error(opts.label, "onNotification handler threw for", parsed.method, ":", err.message);
+            }
+            return;
+        }
+        if (hasId) {
+            // response (success or error)
+            const response = parsed;
+            const p = pending.get(response.id);
+            if (p) {
+                pending.delete(response.id);
+                if (response.error) {
+                    p.reject(new Error(`JSON-RPC ${p.method} failed: ${response.error.message}`));
+                }
+                else {
+                    p.resolve(response.result);
+                }
+            }
+            try {
+                opts.onResponse?.(response);
+            }
+            catch (err) {
+                log.error(opts.label, "onResponse handler threw:", err.message);
+            }
+        }
+    };
+    const rl = createInterface({ input: opts.stdout });
+    rl.on("line", handleLine);
+    return {
+        send,
+        notify,
+        request,
+        respond,
+        respondError,
+        rejectPending,
+        nextId,
+    };
+}

package/dist/executor/process-runner.js

@@ -0,0 +1,101 @@
+/**
+ * Process lifecycle helper for CLI executors.
+ *
+ * Every CLI executor (claude-code / codex / hermes-cli / openclaw) repeats
+ * the same dance:
+ *   1. spawn(bin, args, { cwd, env, stdio: ["pipe","pipe","pipe"] })
+ *   2. on AbortSignal → kill SIGTERM, then SIGKILL after 3s
+ *   3. resolve on `close`, resolve(error=1) on `error`
+ *   4. emit a Spawning/Exited log line with a label
+ *
+ * This module centralizes that pattern so the executors only carry the
+ * protocol-specific line-parsing logic on top. Executors retain ownership
+ * of `proc.stdin.write/end` and the stdout/stderr listener wiring.
+ *
+ * The return type is `ChildProcessByStdio<Writable, Readable, Readable>` so
+ * callers can attach `.on("data", ...)` to `proc.stdout` / `proc.stderr` and
+ * `proc.stdin.write(...)` without non-null assertions. We cast to the typed
+ * spawn signature internally — all 4 executors actually use
+ * `["pipe","pipe","pipe"]` (openclaw's variant is also piped), so this is
+ * safe in practice.
+ */
+import { spawn } from "node:child_process";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor-process-runner", { stream: "stderr" });
+/**
+ * Spawn a long-running CLI process and wire up the abort/timeout/close
+ * sequence shared by every executor.
+ *
+ * The returned `proc` is fully owned by the caller — they can attach
+ * stdout/stderr listeners and write to stdin. The handle just owns the
+ * lifecycle (abort + done).
+ */
+export function runProcess(opts) {
+    const graceMs = opts.graceMs ?? 3000;
+    const stdio = opts.stdio ?? ["pipe", "pipe", "pipe"];
+    log.info(opts.label, "Spawning", opts.bin, `(cwd: ${opts.cwd}, args: ${opts.args.join(" ")})`);
+    const proc = spawn(opts.bin, opts.args, {
+        cwd: opts.cwd,
+        env: { ...process.env, ...(opts.env ?? {}) },
+        stdio,
+    });
+    let killedByAbort = false;
+    const killHard = () => {
+        try {
+            proc.kill("SIGKILL");
+        }
+        catch {
+            /* already gone */
+        }
+    };
+    const killGraceful = () => {
+        if (proc.killed || proc.exitCode != null)
+            return;
+        try {
+            proc.kill("SIGTERM");
+        }
+        catch {
+            /* already gone */
+        }
+        setTimeout(killHard, graceMs).unref();
+    };
+    const abort = (reason) => {
+        if (killedByAbort)
+            return;
+        killedByAbort = true;
+        log.info(opts.label, `Aborted${reason ? `: ${reason}` : ""}, killing pid=${proc.pid}`);
+        killGraceful();
+    };
+    if (opts.signal) {
+        if (opts.signal.aborted) {
+            abort("signal already aborted");
+        }
+        else {
+            opts.signal.addEventListener("abort", () => abort("signal"), { once: true });
+        }
+    }
+    let timeoutTimer;
+    if (opts.timeoutMs) {
+        timeoutTimer = setTimeout(() => {
+            log.info(opts.label, `Timeout ${opts.timeoutMs}ms exceeded, killing pid=${proc.pid}`);
+            killHard();
+        }, opts.timeoutMs);
+        timeoutTimer.unref();
+    }
+    const done = new Promise((resolve) => {
+        proc.on("close", (code, signal) => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            const exitCode = code ?? (killedByAbort ? 1 : 0);
+            log.info(opts.label, `Exited code=${exitCode}${signal ? ` signal=${signal}` : ""}`);
+            resolve({ exitCode, signal });
+        });
+        proc.on("error", (err) => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            log.error(opts.label, "Spawn error:", err.message);
+            resolve({ exitCode: 1, signal: null });
+        });
+    });
+    return { proc, done, abort };
+}

package/dist/executor/reasoning-status.js

@@ -0,0 +1,83 @@
+/**
+ * Reasoning status helpers — port of codex-rs/tui/src/chatwidget.rs:2017-2043
+ * (`extract_first_bold`) and the surrounding `set_status_header` /
+ * `restore_reasoning_status_header` pattern from
+ * codex-rs/tui/src/chatwidget/streaming.rs:8-17.
+ *
+ * The model is prompted (implicitly via the dashboard's own prompt
+ * composition) to begin each reasoning block with a bold title, e.g.
+ *   **Reviewing the failing test**
+ * We accumulate the reasoning deltas, extract the first complete `**...**`
+ * segment, and emit it as a `[status:thinking]…[/status:thinking]` tag so the
+ * dashboard can show a sticky "currently thinking about X" pill at the top of
+ * the streaming message while keeping the full reasoning collapsed in a
+ * `<details>` block.
+ *
+ * The hand-scan (no regex) is intentional: it matches codex's exact behavior,
+ * including the "first `**` we see is the start; if it never closes, stop
+ * looking and wait for more deltas" rule, and avoids backtracking on long
+ * inputs.
+ */
+export const STATUS_TAG_OPEN = "[status:thinking]";
+export const STATUS_TAG_CLOSE = "[/status:thinking]";
+/**
+ * Find the first complete `**…**` pair in `s` and return the trimmed inner
+ * text. Returns null when no complete pair has been seen yet (which is the
+ * expected outcome when called on a partial delta — call again with more
+ * deltas later).
+ */
+export function extractFirstBold(s) {
+    const bytes = new TextEncoder().encode(s);
+    let i = 0;
+    while (i + 1 < bytes.length) {
+        if (bytes[i] === 0x2a && bytes[i + 1] === 0x2a) {
+            // 0x2a = '*'
+            const start = i + 2;
+            let j = start;
+            while (j + 1 < bytes.length) {
+                if (bytes[j] === 0x2a && bytes[j + 1] === 0x2a) {
+                    const inner = s.slice(start, j);
+                    const trimmed = inner.trim();
+                    return trimmed.length > 0 ? trimmed : null;
+                }
+                j++;
+            }
+            return null;
+        }
+        i++;
+    }
+    return null;
+}
+/**
+ * State machine that owns the running reasoning buffer and emits a
+ * `[status:thinking]…[/status:thinking]` tag every time `extractFirstBold`
+ * yields a new header. The downstream `MarkdownContent` parser collapses
+ * repeated emissions down to the latest one and shows it as a sticky pill.
+ */
+export function createReasoningStatusBuffer(emit) {
+    let buffer = "";
+    let lastEmitted = null;
+    return {
+        append(delta) {
+            buffer += delta;
+            const header = extractFirstBold(buffer);
+            if (header && header !== lastEmitted) {
+                lastEmitted = header;
+                emit(`${STATUS_TAG_OPEN}${header}${STATUS_TAG_CLOSE}`);
+            }
+        },
+        reset() {
+            buffer = "";
+            lastEmitted = null;
+        },
+    };
+}
+/**
+ * Imperative setter for non-reasoning status updates ("Working", "Running",
+ * "Done", "Failed", etc.). Use this from `item/started`, `step_start`,
+ * `lifecycle`, etc. — anywhere the executor wants to overwrite the current
+ * status without going through the reasoning buffer.
+ */
+export function emitStatus(onOutput, text) {
+    onOutput(`${STATUS_TAG_OPEN}${text}${STATUS_TAG_CLOSE}`);
+}