@konglx/rotom 2.21.0

package/dist/cli/common.js

@@ -0,0 +1,321 @@
+/**
+ * rotom — shared types, config management, HTTP client, output helpers, CLI arg parsing.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-cli", { stream: "stderr" });
+// ── Constants ─────────────────────────────────────────────────────────────
+export const ROTOM_HOME = process.env.ROTOM_HOME || path.join(os.homedir(), ".rotom");
+export const ROTOM_CONFIG = path.join(ROTOM_HOME, "config.json");
+export const DEFAULT_EXECUTOR_CONFIG = path.join(ROTOM_HOME, "executor.config.json");
+// ── Path helpers ──────────────────────────────────────────────────────────
+export function expandHome(p) {
+    if (!p)
+        return p;
+    if (p.startsWith("~/"))
+        return path.join(os.homedir(), p.slice(2));
+    if (p === "~")
+        return os.homedir();
+    return p;
+}
+export function installRoot() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, "..", "..");
+}
+export function runShellScript(scriptRel, args) {
+    const scriptPath = path.join(installRoot(), scriptRel);
+    if (!fs.existsSync(scriptPath)) {
+        fail(`shell script not found: ${scriptPath}`);
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn("bash", [scriptPath, ...args], { stdio: "inherit" });
+        child.on("error", (err) => reject(err));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+// ── Config load / save ────────────────────────────────────────────────────
+export function loadRotomConfig() {
+    if (!fs.existsSync(ROTOM_CONFIG))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(ROTOM_CONFIG, "utf-8"));
+    }
+    catch (e) {
+        fail(`failed to parse ${ROTOM_CONFIG}: ${e.message}`);
+    }
+}
+export function saveRotomConfig(cfg) {
+    if (!fs.existsSync(ROTOM_HOME))
+        fs.mkdirSync(ROTOM_HOME, { recursive: true });
+    fs.writeFileSync(ROTOM_CONFIG, JSON.stringify(cfg, null, 2));
+}
+export function resolveFromExecutorConfig(name, configPath) {
+    if (!fs.existsSync(configPath))
+        return null;
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const workers = Array.isArray(raw?.workers)
+        ? raw.workers
+        : (raw?.name ? [raw] : []);
+    const w = workers.find((x) => x?.name === name);
+    if (!w)
+        return null;
+    const master = w.master || raw?.master;
+    if (!master || !w.token) {
+        fail(`executor config ${configPath} missing master/token for "${name}"`);
+    }
+    return {
+        name, master, token: w.token, kind: "executor", configPath,
+        ...(w.cliTool ? { cliTool: w.cliTool } : {}),
+        ...(w.workingDir ? { workingDir: w.workingDir } : {}),
+        ...(w.profile ? { profile: w.profile } : {}),
+    };
+}
+export function listExecutorWorkers(configPath) {
+    if (!fs.existsSync(configPath))
+        return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        const workers = Array.isArray(raw?.workers)
+            ? raw.workers
+            : (raw?.name ? [raw] : []);
+        return workers.map((w) => w?.name).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+export function resolveAgentFromEntry(name, entry) {
+    const p = expandHome(entry.configPath);
+    if (!fs.existsSync(p))
+        fail(`config not found for agent "${name}": ${p}`);
+    const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+    if (entry.kind === "openclaw") {
+        const ch = raw?.channels?.["a2a-gateway"];
+        if (!ch?.token || !ch?.master || !ch?.name) {
+            fail(`openclaw config ${p} missing channels['a2a-gateway'].{master,token,name}`);
+        }
+        if (ch.name !== name) {
+            fail(`agent name mismatch: rotom expects "${name}" but ${p} declares "${ch.name}"`);
+        }
+        return { name, master: ch.master, token: ch.token, kind: "openclaw", configPath: p };
+    }
+    if (entry.kind === "local") {
+        // rotom join 产物:扁平结构,对齐 executor.config.json workers[] 单条 entry + master 字段。
+        // { master, name, token, cliTool?, workingDir?, profile? }
+        if (!raw?.token || !raw?.master || !raw?.name) {
+            fail(`local agent config ${p} missing {master,token,name}`);
+        }
+        if (raw.name !== name) {
+            fail(`agent name mismatch: rotom expects "${name}" but ${p} declares "${raw.name}"`);
+        }
+        return {
+            name, master: raw.master, token: raw.token, kind: "local", configPath: p,
+            ...(raw.cliTool ? { cliTool: raw.cliTool } : {}),
+            ...(raw.workingDir ? { workingDir: raw.workingDir } : {}),
+            ...(raw.profile ? { profile: raw.profile } : {}),
+        };
+    }
+    const resolved = resolveFromExecutorConfig(name, p);
+    if (!resolved)
+        fail(`executor config ${p} has no worker named "${name}"`);
+    return resolved;
+}
+export function resolveAgent(asFlag) {
+    const cfg = loadRotomConfig();
+    const chosen = process.env.ROTOM_AGENT || asFlag || cfg.defaultAgent;
+    log.info(`Resolving agent with --as=${asFlag} ROTOM_AGENT=${process.env.ROTOM_AGENT} defaultAgent=${cfg.defaultAgent}`);
+    if (!chosen) {
+        const known = cfg.agents ? Object.keys(cfg.agents) : [];
+        const executorWorkers = listExecutorWorkers(DEFAULT_EXECUTOR_CONFIG);
+        const lines = [];
+        if (known.length)
+            lines.push(`Registered agents: ${known.join(", ")}`);
+        if (executorWorkers.length)
+            lines.push(`Executor workers (${DEFAULT_EXECUTOR_CONFIG}): ${executorWorkers.join(", ")}`);
+        if (lines.length === 0) {
+            lines.push(`No agents registered yet. Either:`, `  - create ${DEFAULT_EXECUTOR_CONFIG} (auto-discovered), or`, `  - rotom config add-openclaw <name> <path-to-openclaw.json>`, `  - rotom config add-executor <name> <path-to-executor.config.json>`);
+        }
+        else {
+            lines.push(`Use: rotom --as <name> ... or rotom config use <name>`);
+        }
+        fail(`no agent selected (--as / ROTOM_AGENT / defaultAgent all unset)\n${lines.join("\n")}`);
+    }
+    const entry = cfg.agents?.[chosen];
+    if (entry)
+        return resolveAgentFromEntry(chosen, entry);
+    const fromExecutor = resolveFromExecutorConfig(chosen, DEFAULT_EXECUTOR_CONFIG);
+    if (fromExecutor)
+        return fromExecutor;
+    const master = process.env.ROTOM_MASTER;
+    const token = process.env.ROTOM_TOKEN;
+    if (master && token) {
+        return { name: chosen, master, token, kind: "executor", configPath: "(env)" };
+    }
+    const known = cfg.agents ? Object.keys(cfg.agents).join(", ") : "(none)";
+    const executorWorkers = listExecutorWorkers(DEFAULT_EXECUTOR_CONFIG);
+    const hint = executorWorkers.length
+        ? `\nAvailable in ${DEFAULT_EXECUTOR_CONFIG}: ${executorWorkers.join(", ")}`
+        : "";
+    fail(`agent "${chosen}" not registered in ${ROTOM_CONFIG}\nKnown: ${known}${hint}`);
+}
+// ── HTTP client ───────────────────────────────────────────────────────────
+export function masterHttpUrl(masterWsOrHttp) {
+    return masterWsOrHttp
+        .replace(/^ws:\/\//, "http://")
+        .replace(/^wss:\/\//, "https://")
+        .replace(/\/+$/, "");
+}
+export async function api(agent, method, route, body) {
+    const url = `${masterHttpUrl(agent.master)}/api${route}`;
+    const init = {
+        method,
+        headers: {
+            "Authorization": `Bearer ${agent.token}`,
+            "Content-Type": "application/json",
+        },
+    };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const idempotent = method === "GET" || method === "PUT" || method === "DELETE";
+    const maxAttempts = idempotent ? 2 : 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        let resp;
+        try {
+            resp = await fetch(url, init);
+            const text = await resp.text();
+            let data;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = text;
+            }
+            if (!resp.ok) {
+                const detail = typeof data === "object" && data?.error ? data.error : text;
+                failKind("http", url, resp.status, method, route, detail);
+            }
+            return data;
+        }
+        catch (e) {
+            const reason = e.message;
+            const partial = resp !== undefined;
+            if (attempt < maxAttempts && !partial) {
+                await new Promise((r) => setTimeout(r, 800));
+                continue;
+            }
+            failKind(partial ? "partial-response" : "network", url, reason, partial ? resp.status : 0);
+        }
+    }
+    throw new Error("rotom: api() loop fell through");
+}
+// ── Output helpers ────────────────────────────────────────────────────────
+export let pretty = false;
+export function setPretty(v) { pretty = v; }
+export function isPretty() { return pretty; }
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, pretty ? 2 : 0) + "\n");
+}
+export function printTable(rows, columns) {
+    if (!pretty || !rows?.length) {
+        printJson(rows);
+        return;
+    }
+    const cols = columns || Object.keys(rows[0]);
+    const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length)));
+    const sep = cols.map((_, i) => "─".repeat(widths[i])).join("─┼─");
+    const header = cols.map((c, i) => c.padEnd(widths[i])).join(" │ ");
+    process.stdout.write(header + "\n" + sep + "\n");
+    for (const r of rows) {
+        process.stdout.write(cols.map((c, i) => String(r[c] ?? "").padEnd(widths[i])).join(" │ ") + "\n");
+    }
+}
+export function fail(msg) {
+    process.stderr.write(`rotom: ${msg}\n`);
+    process.exit(1);
+}
+export function failKind(kind, ...args) {
+    const prefix = kind === "network"
+        ? "rotom network"
+        : kind === "partial-response"
+            ? "rotom partial-response"
+            : kind === "http"
+                ? "rotom http"
+                : "rotom";
+    process.stderr.write(`${prefix}: ${args.map((a) => String(a)).join(" ")}\n`);
+    const code = kind === "network" || kind === "partial-response" ? 75 :
+        kind === "http" ? 69 : 1;
+    process.exit(code);
+}
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (const a of argv) {
+        if (a.startsWith("--")) {
+            const eq = a.indexOf("=");
+            if (eq !== -1) {
+                const k = a.slice(2, eq);
+                const v = a.slice(eq + 1);
+                flags[k] = v === "" ? true : v;
+            }
+            else {
+                if (a.startsWith("--no-")) {
+                    flags[a.slice(5)] = false;
+                    continue;
+                }
+                flags[a.slice(2)] = true;
+            }
+        }
+        else if (a.startsWith("-") && a.length === 2) {
+            flags[a[1]] = true;
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    for (const key of Object.keys(flags)) {
+        if (flags[key] !== true)
+            continue;
+        const idx = argv.indexOf(`--${key}`);
+        if (idx === -1 && key.length === 1)
+            continue;
+        if (idx === -1)
+            continue;
+        const valIdx = idx + 1;
+        if (valIdx < argv.length && !argv[valIdx].startsWith("-")) {
+            const m = argv[valIdx].match(/^-?\d+(\.\d+)?$/);
+            if (m) {
+                flags[key] = m[0];
+            }
+            else {
+                flags[key] = argv[valIdx];
+            }
+        }
+    }
+    return { positional, flags };
+}
+export function requireFlag(flags, name) {
+    const v = flags[name];
+    if (v === undefined || v === true || v === false) {
+        fail(`--${name} is required`);
+    }
+    return v;
+}
+export function flagStr(flags, name) {
+    const v = flags[name];
+    if (v === undefined || v === true || v === false)
+        return undefined;
+    return v;
+}
+export function flagInt(flags, name) {
+    const v = flagStr(flags, name);
+    if (!v)
+        return undefined;
+    const n = Number(v);
+    if (!Number.isFinite(n))
+        fail(`--${name} must be a number`);
+    return n;
+}

package/dist/cli/config.js

@@ -0,0 +1,65 @@
+/**
+ * rotom config — agent configuration management.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROTOM_CONFIG, loadRotomConfig, saveRotomConfig, resolveAgentFromEntry, expandHome, printJson, fail, } from "./common.js";
+import { usage, unknownSubcommand } from "./routes.js";
+export async function cmdConfig(rest, _flags) {
+    const sub = rest[0];
+    const cfg = loadRotomConfig();
+    cfg.agents = cfg.agents || {};
+    if (sub === "show") {
+        printJson({ configPath: ROTOM_CONFIG, ...cfg });
+        return;
+    }
+    if (sub === "init") {
+        if (fs.existsSync(ROTOM_CONFIG))
+            fail(`${ROTOM_CONFIG} already exists`);
+        saveRotomConfig({ agents: {} });
+        process.stdout.write(`Created ${ROTOM_CONFIG}\n`);
+        return;
+    }
+    if (sub === "use") {
+        const name = rest[1];
+        if (!name)
+            usage("config use", "<name>");
+        if (!cfg.agents?.[name])
+            fail(`agent "${name}" not registered`);
+        cfg.defaultAgent = name;
+        saveRotomConfig(cfg);
+        process.stdout.write(`defaultAgent = ${name}\n`);
+        return;
+    }
+    if (sub === "add-openclaw" || sub === "add-executor") {
+        const name = rest[1];
+        const cfgPath = rest[2];
+        if (!name || !cfgPath)
+            usage(`config ${sub}`, "<name> <path>");
+        const abs = path.resolve(expandHome(cfgPath));
+        if (!fs.existsSync(abs))
+            fail(`config file not found: ${abs}`);
+        const kind = sub === "add-openclaw" ? "openclaw" : "executor";
+        cfg.agents[name] = { configPath: abs, kind };
+        if (!cfg.defaultAgent)
+            cfg.defaultAgent = name;
+        saveRotomConfig(cfg);
+        const resolved = resolveAgentFromEntry(name, cfg.agents[name]);
+        process.stdout.write(`Registered ${name} (${kind}) → master=${resolved.master}\n`);
+        return;
+    }
+    if (sub === "remove") {
+        const name = rest[1];
+        if (!name)
+            usage("config remove", "<name>");
+        if (!cfg.agents[name])
+            fail(`agent "${name}" not registered`);
+        delete cfg.agents[name];
+        if (cfg.defaultAgent === name)
+            delete cfg.defaultAgent;
+        saveRotomConfig(cfg);
+        process.stdout.write(`Removed ${name}\n`);
+        return;
+    }
+    unknownSubcommand("config", sub);
+}

package/dist/cli/directory.js

@@ -0,0 +1,17 @@
+/**
+ * rotom directory — list agents.
+ */
+import { api, flagStr, printTable } from "./common.js";
+export async function cmdDirectory(agent, flags) {
+    const route = flags.online === true ? "/agents/online" : "/agents";
+    let data = await api(agent, "GET", route);
+    const domain = flagStr(flags, "domain");
+    if (domain)
+        data = data.filter((a) => a.domain === domain);
+    printTable(data.map((a) => ({
+        name: a.name,
+        domain: a.domain || "-",
+        status: a.status,
+        description: (a.description || "").slice(0, 60),
+    })), ["name", "domain", "status", "description"]);
+}

package/dist/cli/executor.js

@@ -0,0 +1,58 @@
+/**
+ * rotom executor — start executor workers.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { spawn } from "node:child_process";
+import { installRoot, fail, flagStr } from "./common.js";
+export async function cmdExecutor(rest, flags) {
+    const root = installRoot();
+    const distJs = path.join(root, "dist", "executor", "index.js");
+    const srcTs = path.join(root, "src", "executor", "index.ts");
+    const fwd = [];
+    const cfg = flagStr(flags, "config");
+    if (cfg)
+        fwd.push("--config", cfg);
+    for (const a of rest)
+        fwd.push(a);
+    let useTsx = false;
+    let entry;
+    if (fs.existsSync(distJs)) {
+        entry = distJs;
+    }
+    else if (fs.existsSync(srcTs)) {
+        const tsxBin = path.join(root, "node_modules", ".bin", "tsx");
+        if (!fs.existsSync(tsxBin)) {
+            fail(`tsx not found at ${tsxBin} — required for dev mode. Run \`pnpm install\` first.`);
+        }
+        entry = tsxBin;
+        useTsx = true;
+    }
+    else {
+        fail(`cannot find executor entry: tried ${distJs} and ${srcTs}`);
+    }
+    const cmdline = useTsx
+        ? [entry, srcTs, ...fwd]
+        : [entry, ...fwd];
+    const bin = useTsx ? entry : process.execPath;
+    await new Promise((resolve) => {
+        const child = spawn(bin, cmdline, { stdio: "inherit" });
+        const forward = (sig) => { try {
+            child.kill(sig);
+        }
+        catch { /* already gone */ } };
+        process.on("SIGINT", () => forward("SIGINT"));
+        process.on("SIGTERM", () => forward("SIGTERM"));
+        child.on("exit", (code, signal) => {
+            if (code !== null && code !== undefined) {
+                process.exit(code);
+                return;
+            }
+            const sigNum = signal ? os.constants.signals[signal] : 0;
+            process.exit(typeof sigNum === "number" && sigNum > 0 ? 128 + sigNum : 1);
+            resolve();
+        });
+        child.on("error", (err) => fail(`failed to spawn executor: ${err.message}`));
+    });
+}

package/dist/cli/fed.js

@@ -0,0 +1,91 @@
+/**
+ * rotom fed — 跨机对话 CLI(走本机 rotom-link daemon)。
+ *
+ *   rotom fed members                列出可见 agent(从协调 master 同步来的目录)
+ *   rotom fed ask <ref> "<question>"  阻塞等回复(--timeout 5m,对齐 src/cli/ask.ts)
+ *
+ * `<ref>` 形如 "alice@hostB" 或 "alice"(后者依赖团队内 name 唯一)。
+ * 走本机 link daemon 的 http://127.0.0.1:28900。
+ */
+import { fail, flagStr, printJson } from "./common.js";
+import { masterFetch } from "./routes.js";
+import { parseAgentRef } from "../shared/protocol/federation.js";
+const DEFAULT_LINK_PORT = 28900;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+function linkHttpBase(flags) {
+    const port = flagStr(flags, "port") ?? String(DEFAULT_LINK_PORT);
+    return `http://127.0.0.1:${port}`;
+}
+async function probeLink(httpBase) {
+    const probe = await masterFetch(`${httpBase}/health`, { method: "GET" }).catch(() => null);
+    if (!probe || probe.status === 0) {
+        fail(`rotom-link daemon unreachable at ${httpBase}. ` +
+            `Start it first: \`rotom link start\` (after \`rotom link join <coordEndpoint> --hostname <name>\`).`);
+    }
+}
+export async function cmdFed(rest, flags) {
+    const sub = rest[0];
+    if (!sub) {
+        fail("usage: rotom fed <members|ask> [args]\n" +
+            "  members                              列出可见 agent (协调 master 同步目录)\n" +
+            "  ask <ref> \"<question>\" [--timeout 5m]   阻塞等回复 (ref 形如 alice@hostB 或 alice)");
+    }
+    const httpBase = linkHttpBase(flags);
+    await probeLink(httpBase);
+    const args = rest.slice(1);
+    switch (sub) {
+        case "members": return cmdFedMembers(httpBase);
+        case "ask": return cmdFedAsk(httpBase, args, flags);
+        default: fail(`unknown fed subcommand: ${sub}\nRun 'rotom fed' for usage.`);
+    }
+}
+async function cmdFedMembers(httpBase) {
+    const resp = await masterFetch(`${httpBase}/fed/directory`, { method: "GET" });
+    if (resp.status < 200 || resp.status >= 300) {
+        const err = resp.data?.error ?? JSON.stringify(resp.data);
+        fail(`fed members failed (HTTP ${resp.status}): ${err}`);
+    }
+    printJson(resp.data);
+}
+async function cmdFedAsk(httpBase, args, flags) {
+    const ref = args[0];
+    const message = args.slice(1).join(" ").trim();
+    if (!ref) {
+        fail("usage: rotom fed ask <ref> \"<question>\"\n  ref e.g. alice@hostB 或 alice(团队内 name 唯一)");
+    }
+    if (!message) {
+        fail(`question is empty (got: ${args.slice(1).join(" ")})`);
+    }
+    // 校验 ref 形式:不带 @ 的裸 name 也接受,link daemon 会依赖团队内唯一性
+    const parsed = parseAgentRef(ref);
+    if (!parsed.hostname) {
+        process.stderr.write(`[rotom-fed] warning: "${ref}" 不带 @hostname,link daemon 会按团队内 name 唯一性路由\n`);
+    }
+    const timeoutStr = flagStr(flags, "timeout");
+    const timeoutMs = timeoutStr ? parseDurationMs(timeoutStr) : DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const resp = await masterFetch(`${httpBase}/fed/ask`, {
+            method: "POST",
+            body: JSON.stringify({ to: ref, message }),
+            signal: controller.signal,
+        });
+        if (resp.status < 200 || resp.status >= 300) {
+            const err = resp.data?.error ?? JSON.stringify(resp.data);
+            fail(`fed ask failed (HTTP ${resp.status}): ${err}`);
+        }
+        printJson(resp.data);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function parseDurationMs(s) {
+    const m = s.match(/^(\d+)(s|m|h)$/);
+    if (!m)
+        fail(`invalid --timeout: ${s} (e.g. 30s / 5m / 1h)`);
+    const n = parseInt(m[1], 10);
+    const unit = m[2];
+    return n * (unit === "s" ? 1000 : unit === "m" ? 60_000 : 3_600_000);
+}