@konglx/rotom 2.21.0

package/dist/master/api/messages.js

@@ -0,0 +1,157 @@
+import { createLogger } from "../../shared/logger.js";
+const log = createLogger("mesh-api");
+export function registerMessageRoutes(apiRouter, db, _auth, hub, router) {
+    apiRouter.get("/audit", (req, res) => {
+        const limit = Math.min(parseInt(req.query.limit) || 50, 500);
+        res.json(db.listAudit(limit));
+    });
+    apiRouter.get("/stats", (_req, res) => {
+        const basic = db.stats();
+        const msgStats = db.agentMessageStats();
+        res.json({ ...basic, agents: msgStats });
+    });
+    apiRouter.get("/messages", (req, res) => {
+        const agent = req.query.agent;
+        const from = req.query.from;
+        const to = req.query.to;
+        const status = req.query.status;
+        const keyword = req.query.keyword;
+        const groupId = req.query.groupId;
+        const limit = Math.min(parseInt(req.query.limit) || 100, 500);
+        const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+        const before = req.query.before;
+        const messages = db.listMessages({ agent, from, to, status, keyword, groupId, limit, offset, before });
+        const total = db.countMessages({ agent, from, to, status, keyword, groupId, before });
+        res.json({ messages, total });
+    });
+    apiRouter.post("/messages/send", (req, res) => {
+        const { from, to, message } = req.body;
+        if (!from || !to || !message) {
+            res.status(400).json({ error: "from, to, and message are required" });
+            return;
+        }
+        const fromAgent = db.getAgentByName(from);
+        if (!fromAgent) {
+            res.status(404).json({ error: `Sender agent "${from}" not found` });
+            return;
+        }
+        const toAgent = db.getAgentByName(to);
+        if (!toAgent) {
+            res.status(404).json({ error: `Target agent "${to}" not found` });
+            return;
+        }
+        const requestId = `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        if (!router) {
+            res.status(500).json({ error: "Message router not available" });
+            return;
+        }
+        const routeResult = router.route(fromAgent.id, {
+            requestId,
+            target: to,
+            payload: { message }
+        });
+        if (routeResult.error) {
+            res.status(500).json({ error: routeResult.error });
+            return;
+        }
+        let delivered = false;
+        let queued = false;
+        if (routeResult.targetAgentId && hub) {
+            delivered = hub.sendToAgent(routeResult.targetAgentId, {
+                type: "a2a_message",
+                requestId,
+                from: { name: from, domain: fromAgent.domain || undefined, status: "online" },
+                payload: { message },
+                routeType: "exact",
+            });
+            if (!delivered) {
+                queued = true;
+            }
+        }
+        db.logMessage({
+            requestId,
+            fromName: from,
+            fromDomain: fromAgent.domain || undefined,
+            toName: to,
+            toDomain: toAgent.domain || undefined,
+            routeType: "exact",
+            direction: "send",
+            payload: JSON.stringify({ message }),
+            status: routeResult.error ? "failed" : queued ? "queued" : delivered ? "delivered" : "failed",
+            source: "api",
+        });
+        res.json({
+            requestId,
+            delivered,
+            queued,
+            message: "Message sent successfully"
+        });
+    });
+    // Cancel an in-flight streaming chat reply. Body: { requestId, agentName, reason? }.
+    // agentName is the responder currently generating (the streaming bubble's `from`),
+    // not the original sender — master uses it to route the chat_cancelled WS message
+    // to that specific worker. Returns delivered=false when the responder is offline
+    // or unknown; the caller can treat that as "stream is already broken" and move on.
+    apiRouter.post("/messages/cancel", (req, res) => {
+        const { requestId, agentName, reason } = req.body || {};
+        if (!requestId || typeof requestId !== "string" ||
+            !agentName || typeof agentName !== "string") {
+            res.status(400).json({ error: "requestId and agentName are required" });
+            return;
+        }
+        if (!hub) {
+            res.status(500).json({ error: "WSHub not available" });
+            return;
+        }
+        const delivered = hub.pushChatCancel(agentName, requestId, typeof reason === "string" && reason ? reason : undefined);
+        res.json({ ok: true, delivered });
+    });
+    apiRouter.get("/whoami", (req, res) => {
+        const agentAuth = req.agentAuth;
+        if (agentAuth) {
+            const agent = db.getAgentById(agentAuth.id);
+            res.json({ kind: "agent", name: agentAuth.name, id: agentAuth.id, domain: agent?.domain || null });
+            return;
+        }
+        res.json({ kind: "dashboard" });
+    });
+    apiRouter.post("/cli/groups/:groupId/send", (req, res) => {
+        const agentAuth = req.agentAuth;
+        if (!agentAuth) {
+            res.status(403).json({ error: "Mesh token required (use a Bearer mesh_xxx token)" });
+            return;
+        }
+        if (!hub) {
+            res.status(500).json({ error: "WSHub not available" });
+            return;
+        }
+        const group = db.getGroupById(req.params.groupId);
+        if (!group) {
+            res.status(404).json({ error: "Group not found" });
+            return;
+        }
+        if (group.archived_at) {
+            res.status(403).json({ error: "Group is archived, cannot send messages" });
+            return;
+        }
+        const { target, message, noDispatch, needReply } = req.body || {};
+        if (!target || !message) {
+            res.status(400).json({ error: "target and message are required" });
+            return;
+        }
+        const r = hub.sendAsAgent({
+            fromName: agentAuth.name,
+            target,
+            message,
+            groupId: req.params.groupId,
+            groupName: group.name,
+            ...(noDispatch === true ? { noDispatch: true } : {}),
+            ...(needReply === true ? { needReply: true } : {}),
+        });
+        if (r.error) {
+            res.status(400).json(r);
+            return;
+        }
+        res.json(r);
+    });
+}

package/dist/master/api/notes.js

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { createLogger } from "../../shared/logger.js";
+const log = createLogger("mesh-api");
+export function registerNoteRoutes(apiRouter, db) {
+    apiRouter.get("/groups/:groupId/notes", (req, res) => {
+        const group = db.getGroupById(req.params.groupId);
+        if (!group) {
+            res.status(404).json({ error: "Group not found" });
+            return;
+        }
+        res.json(db.listNotesByGroup(req.params.groupId));
+    });
+    apiRouter.post("/groups/:groupId/notes", (req, res) => {
+        const group = db.getGroupById(req.params.groupId);
+        if (!group) {
+            res.status(404).json({ error: "Group not found" });
+            return;
+        }
+        if (group.archived_at) {
+            res.status(403).json({ error: "Group is archived, cannot create notes" });
+            return;
+        }
+        const { title, description, createdBy } = req.body;
+        if (!title || !createdBy) {
+            res.status(400).json({ error: "title and createdBy are required" });
+            return;
+        }
+        const id = randomUUID();
+        db.createNote({
+            id, groupId: req.params.groupId,
+            title: String(title).trim(),
+            description: description == null ? "" : String(description),
+            createdBy,
+        });
+        log.info(`Note created: "${title}" (${id}) in group ${req.params.groupId}`);
+        res.status(201).json({ id, title });
+    });
+    apiRouter.get("/notes/:id", (req, res) => {
+        const note = db.getNoteById(req.params.id);
+        if (!note) {
+            res.status(404).json({ error: "Note not found" });
+            return;
+        }
+        res.json(note);
+    });
+    apiRouter.put("/notes/:id", (req, res) => {
+        const note = db.getNoteById(req.params.id);
+        if (!note) {
+            res.status(404).json({ error: "Note not found" });
+            return;
+        }
+        const { title, description } = req.body;
+        const fields = {};
+        if (title !== undefined) {
+            const t = String(title).trim();
+            if (!t) {
+                res.status(400).json({ error: "title cannot be empty" });
+                return;
+            }
+            fields.title = t;
+        }
+        if (description !== undefined) {
+            fields.description = description === null ? "" : String(description);
+        }
+        db.updateNote(req.params.id, fields);
+        res.json({ ok: true });
+    });
+    apiRouter.delete("/notes/:id", (req, res) => {
+        const note = db.getNoteById(req.params.id);
+        if (!note) {
+            res.status(404).json({ error: "Note not found" });
+            return;
+        }
+        db.deleteNote(req.params.id);
+        res.json({ ok: true });
+    });
+}

package/dist/master/api/schedule-patterns.js

@@ -0,0 +1,133 @@
+/**
+ * /api/schedule-patterns — 调度模式参考库 CRUD
+ *
+ * - 列表: GET /api/schedule-patterns
+ * - 新建: POST /api/schedule-patterns
+ * - 改:   PATCH /api/schedule-patterns/:id
+ * - 删:   DELETE /api/schedule-patterns/:id  (种子模式 is_default=1 返回 400)
+ *
+ * 身份验证沿用 api/index.ts 的 permissive middleware。
+ */
+import { createLogger } from "../../shared/logger.js";
+const log = createLogger("mesh-api-schedule-patterns");
+function asString(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+function asInt(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return Math.trunc(v);
+    if (typeof v === "string" && /^-?\d+$/.test(v.trim()))
+        return parseInt(v.trim(), 10);
+    return undefined;
+}
+/**
+ * schedule_config 接受对象或 JSON 字符串;null/空串/缺省=不设置(返回 null)。
+ * 返回 undefined 表示「格式非法」,由调用方返回 400。
+ */
+function normalizeScheduleConfig(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === "string") {
+        if (v.trim() === "")
+            return null;
+        try {
+            JSON.parse(v);
+            return v;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (typeof v === "object") {
+        return JSON.stringify(v);
+    }
+    return undefined;
+}
+export function registerSchedulePatternRoutes(apiRouter, db) {
+    // ── 列表 ─────────────────────────────────────────────────────────────────
+    apiRouter.get("/schedule-patterns", (_req, res) => {
+        res.json(db.listSchedulePatterns());
+    });
+    // ── 新建 ─────────────────────────────────────────────────────────────────
+    apiRouter.post("/schedule-patterns", (req, res) => {
+        const b = req.body;
+        const name = asString(b.name);
+        if (!name) {
+            res.status(400).json({ error: "name is required" });
+            return;
+        }
+        const scheduleConfig = normalizeScheduleConfig(b.schedule_config);
+        if (scheduleConfig === undefined) {
+            res.status(400).json({ error: "schedule_config must be a JSON object or JSON string" });
+            return;
+        }
+        const pat = db.createSchedulePattern({
+            name,
+            description: typeof b.description === "string" ? b.description : "",
+            schedule_config: scheduleConfig,
+            sort_order: asInt(b.sort_order) ?? 0,
+        });
+        log.info(`Schedule pattern created: #${pat.id} "${pat.name}"`);
+        res.status(201).json(pat);
+    });
+    // ── 改 ───────────────────────────────────────────────────────────────────
+    apiRouter.patch("/schedule-patterns/:id", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const existing = db.getSchedulePattern(id);
+        if (!existing) {
+            res.status(404).json({ error: "Schedule pattern not found" });
+            return;
+        }
+        const b = req.body;
+        const patch = {};
+        if (b.name !== undefined) {
+            const s = asString(b.name);
+            if (!s) {
+                res.status(400).json({ error: "name cannot be empty" });
+                return;
+            }
+            patch.name = s;
+        }
+        if (b.description !== undefined) {
+            patch.description = typeof b.description === "string" ? b.description : "";
+        }
+        if (b.schedule_config !== undefined) {
+            const v = normalizeScheduleConfig(b.schedule_config);
+            if (v === undefined) {
+                res.status(400).json({ error: "schedule_config must be a JSON object or JSON string" });
+                return;
+            }
+            patch.schedule_config = v;
+        }
+        if (b.sort_order !== undefined) {
+            patch.sort_order = asInt(b.sort_order) ?? 0;
+        }
+        const pat = db.updateSchedulePattern(id, patch);
+        log.info(`Schedule pattern updated: #${id}`);
+        res.json(pat);
+    });
+    // ── 删 ───────────────────────────────────────────────────────────────────
+    apiRouter.delete("/schedule-patterns/:id", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const existing = db.getSchedulePattern(id);
+        if (!existing) {
+            res.status(404).json({ error: "Schedule pattern not found" });
+            return;
+        }
+        if (existing.is_default === 1) {
+            res.status(400).json({ error: "Cannot delete default schedule pattern" });
+            return;
+        }
+        db.deleteSchedulePattern(id);
+        log.info(`Schedule pattern deleted: #${id}`);
+        res.json({ ok: true });
+    });
+}

package/dist/master/api/schedules.js

@@ -0,0 +1,272 @@
+/**
+ * /api/schedules — 群内定时任务 CRUD + trigger
+ *
+ * - 列表:GET /api/schedules?group_id=<id>
+ * - 详情:GET /api/schedules/:id
+ * - 新建:POST /api/schedules
+ * - 改:   PATCH /api/schedules/:id(改 schedule 字段会重算 next_run_at)
+ * - 删:   DELETE /api/schedules/:id
+ * - 立刻触发:POST /api/schedules/:id/trigger
+ *
+ * 身份验证沿用 api/index.ts 的 permissive middleware(Dashboard cookie + agent Bearer 都允许)。
+ */
+import { createLogger } from "../../shared/logger.js";
+const log = createLogger("mesh-api-schedules");
+function asString(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+function asInt(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return Math.trunc(v);
+    if (typeof v === "string" && /^-?\d+$/.test(v.trim()))
+        return parseInt(v.trim(), 10);
+    return undefined;
+}
+function asBool(v) {
+    if (typeof v === "boolean")
+        return v;
+    if (v === "true" || v === 1 || v === "1")
+        return true;
+    if (v === "false" || v === 0 || v === "0")
+        return false;
+    return undefined;
+}
+function asMode(v) {
+    return v === "agent" || v === "message" ? v : undefined;
+}
+function asScheduleKind(v) {
+    return v === "once" || v === "interval" ? v : undefined;
+}
+export function registerScheduleRoutes(apiRouter, db) {
+    // ── 列表 ─────────────────────────────────────────────────────────────────
+    apiRouter.get("/schedules", (req, res) => {
+        const groupId = asString(req.query.group_id);
+        res.json(db.listScheduledTasks(groupId ? { groupId } : undefined));
+    });
+    // ── 详情 ─────────────────────────────────────────────────────────────────
+    apiRouter.get("/schedules/:id", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const task = db.getScheduledTask(id);
+        if (!task) {
+            res.status(404).json({ error: "Scheduled task not found" });
+            return;
+        }
+        res.json(task);
+    });
+    // ── 新建 ─────────────────────────────────────────────────────────────────
+    apiRouter.post("/schedules", (req, res) => {
+        const b = req.body;
+        const name = asString(b.name);
+        const groupId = asString(b.group_id);
+        const mode = asMode(b.mode);
+        const scheduleKind = asScheduleKind(b.schedule_kind) ?? "interval";
+        const prompt = asString(b.prompt);
+        if (!name) {
+            res.status(400).json({ error: "name is required" });
+            return;
+        }
+        if (!groupId) {
+            res.status(400).json({ error: "group_id is required" });
+            return;
+        }
+        if (!prompt) {
+            res.status(400).json({ error: "prompt is required" });
+            return;
+        }
+        if (!mode) {
+            res.status(400).json({ error: "mode must be 'agent' or 'message'" });
+            return;
+        }
+        if (!db.getGroupById(groupId)) {
+            res.status(404).json({ error: `Group not found: ${groupId}` });
+            return;
+        }
+        let intervalSec = null;
+        let runAt = null;
+        if (scheduleKind === "interval") {
+            intervalSec = asInt(b.interval_sec) ?? null;
+            if (intervalSec === null || intervalSec < 30) {
+                res.status(400).json({ error: "interval_sec must be an integer >= 30 for schedule_kind=interval" });
+                return;
+            }
+        }
+        else {
+            runAt = asInt(b.run_at) ?? null;
+            if (runAt === null || runAt <= Date.now()) {
+                res.status(400).json({ error: "run_at must be a future epoch ms timestamp for schedule_kind=once" });
+                return;
+            }
+        }
+        let agentName = null;
+        if (mode === "agent") {
+            agentName = asString(b.agent_name) ?? null;
+            if (!agentName) {
+                res.status(400).json({ error: "agent_name is required for mode=agent" });
+                return;
+            }
+        }
+        else if (b.agent_name !== undefined) {
+            // message 模式也允许带 agent_name,但存也无所谓 —— 这里忽略,保持 NULL
+            agentName = asString(b.agent_name) ?? null;
+        }
+        const repeatTimes = b.repeat_times === null || b.repeat_times === undefined
+            ? null
+            : (() => {
+                const n = asInt(b.repeat_times);
+                return n !== undefined && n > 0 ? n : null;
+            })();
+        const enabled = asBool(b.enabled);
+        const task = db.createScheduledTask({
+            name,
+            groupId,
+            mode,
+            agentName,
+            scheduleKind,
+            intervalSec,
+            runAt,
+            prompt,
+            repeatTimes,
+            enabled: enabled !== undefined ? enabled : true,
+        });
+        log.info(`Schedule created: #${task.id} "${task.name}" (${task.mode}/${task.schedule_kind}) in group ${groupId}`);
+        res.status(201).json(task);
+    });
+    // ── 改 ───────────────────────────────────────────────────────────────────
+    apiRouter.patch("/schedules/:id", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const existing = db.getScheduledTask(id);
+        if (!existing) {
+            res.status(404).json({ error: "Scheduled task not found" });
+            return;
+        }
+        const b = req.body;
+        const patch = {};
+        if (b.name !== undefined) {
+            const s = asString(b.name);
+            if (!s) {
+                res.status(400).json({ error: "name cannot be empty" });
+                return;
+            }
+            patch.name = s;
+        }
+        if (b.mode !== undefined) {
+            const m = asMode(b.mode);
+            if (!m) {
+                res.status(400).json({ error: "mode must be 'agent' or 'message'" });
+                return;
+            }
+            patch.mode = m;
+        }
+        if (b.agent_name !== undefined) {
+            patch.agentName = asString(b.agent_name) ?? null;
+        }
+        if (b.prompt !== undefined) {
+            const s = asString(b.prompt);
+            if (!s) {
+                res.status(400).json({ error: "prompt cannot be empty" });
+                return;
+            }
+            patch.prompt = s;
+        }
+        if (b.enabled !== undefined) {
+            const v = asBool(b.enabled);
+            if (v === undefined) {
+                res.status(400).json({ error: "enabled must be boolean" });
+                return;
+            }
+            patch.enabled = v;
+        }
+        if (b.repeat_times !== undefined) {
+            if (b.repeat_times === null) {
+                patch.repeatTimes = null;
+            }
+            else {
+                const n = asInt(b.repeat_times);
+                if (n === undefined || n <= 0) {
+                    res.status(400).json({ error: "repeat_times must be a positive integer or null" });
+                    return;
+                }
+                patch.repeatTimes = n;
+            }
+        }
+        // schedule 字段改动:三种字段互相影响,做一次合并校验
+        const newKind = b.schedule_kind !== undefined ? asScheduleKind(b.schedule_kind) : existing.schedule_kind;
+        const newInterval = b.interval_sec !== undefined ? asInt(b.interval_sec) : (existing.interval_sec ?? undefined);
+        const newRunAt = b.run_at !== undefined ? asInt(b.run_at) : (existing.run_at ?? undefined);
+        if (b.schedule_kind !== undefined && !newKind) {
+            res.status(400).json({ error: "schedule_kind must be 'once' or 'interval'" });
+            return;
+        }
+        if (newKind === "interval") {
+            if (newInterval === undefined || newInterval < 30) {
+                res.status(400).json({ error: "interval_sec must be an integer >= 30 for schedule_kind=interval" });
+                return;
+            }
+            patch.scheduleKind = "interval";
+            patch.intervalSec = newInterval;
+        }
+        else if (newKind === "once") {
+            if (newRunAt === undefined || newRunAt <= Date.now()) {
+                res.status(400).json({ error: "run_at must be a future epoch ms timestamp for schedule_kind=once" });
+                return;
+            }
+            patch.scheduleKind = "once";
+            patch.runAt = newRunAt;
+        }
+        const updated = db.updateScheduledTask(id, patch);
+        if (!updated) {
+            // shouldn't happen, we already checked existence
+            res.status(404).json({ error: "Scheduled task not found" });
+            return;
+        }
+        log.info(`Schedule #${id} updated`);
+        res.json(updated);
+    });
+    // ── 删 ───────────────────────────────────────────────────────────────────
+    apiRouter.delete("/schedules/:id", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const ok = db.deleteScheduledTask(id);
+        if (!ok) {
+            res.status(404).json({ error: "Scheduled task not found" });
+            return;
+        }
+        log.info(`Schedule #${id} deleted`);
+        res.json({ ok: true });
+    });
+    // ── 立刻触发 ─────────────────────────────────────────────────────────────
+    apiRouter.post("/schedules/:id/trigger", (req, res) => {
+        const id = asInt(req.params.id);
+        if (id === undefined) {
+            res.status(400).json({ error: "id must be an integer" });
+            return;
+        }
+        const task = db.getScheduledTask(id);
+        if (!task) {
+            res.status(404).json({ error: "Scheduled task not found" });
+            return;
+        }
+        if (!task.enabled) {
+            res.status(409).json({ error: "Scheduled task is disabled — re-enable it first" });
+            return;
+        }
+        const ok = db.triggerScheduledTask(id);
+        if (!ok) {
+            res.status(409).json({ error: "Scheduled task is disabled" });
+            return;
+        }
+        log.info(`Schedule #${id} "${task.name}" manually triggered`);
+        res.json({ ok: true, id, next_run_at: Date.now() });
+    });
+}