maestro-agent 0.0.1 → 0.0.3

package/src/api/roles.ts

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { Router } from "../core/router";
+import { json, body } from "../core/router";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { syncRolesFromDirectory, buildFullRolePrompt } from "../roles";
+import { createWorkspaceRole } from "../roles/workspace-role";
+
+export function registerRoleRoutes(router: Router, ctx: HubContext) {
+  router.get("/api/roles", () => {
+    return json(ctx.db.query("SELECT * FROM role ORDER BY id ASC").all());
+  });
+
+  router.post("/api/roles/reload", () => {
+    const rolesDir = join(ctx.hubDir, "roles");
+    if (!existsSync(rolesDir)) return json({ roles: [] });
+    const roles = syncRolesFromDirectory(ctx.db, rolesDir);
+    return json({ roles });
+  });
+
+  // Get role.md raw content for editing
+  router.get("/api/roles/:id/content", (_req, params) => {
+    const role = ctx.db.query("SELECT * FROM role WHERE id = ?").get(params.id) as any;
+    if (!role) return json({ error: "Not found" }, 404);
+    if (!role.role_md_path || !existsSync(role.role_md_path)) {
+      return json({ error: "Role file not found" }, 404);
+    }
+    const content = readFileSync(role.role_md_path, "utf-8");
+    const rolesDir = join(ctx.hubDir, "roles");
+    const fullPrompt = buildFullRolePrompt(rolesDir, role.role_md_path);
+    return json({ content, full_prompt: fullPrompt, path: role.role_md_path });
+  });
+
+  // Update role.md content (triggers hot-reload on next poll)
+  router.put("/api/roles/:id/content", async (req, params) => {
+    const role = ctx.db.query("SELECT * FROM role WHERE id = ?").get(params.id) as any;
+    if (!role) return json({ error: "Not found" }, 404);
+    if (!role.role_md_path) return json({ error: "Role has no file path" }, 400);
+    const { content } = await body(req);
+    if (!content) return json({ error: "content is required" }, 400);
+    writeFileSync(role.role_md_path, content, "utf-8");
+    // Force reload
+    const rolesDir = join(ctx.hubDir, "roles");
+    syncRolesFromDirectory(ctx.db, rolesDir);
+    const updated = ctx.db.query("SELECT * FROM role WHERE id = ?").get(params.id);
+    return json(updated);
+  });
+
+  // DELETE /api/roles/:id
+  router.delete("/api/roles/:id", (_req, params) => {
+    const role = ctx.db.query("SELECT * FROM role WHERE id = ?").get(params.id) as any;
+    if (!role) return json({ error: "Not found" }, 404);
+    const bound = ctx.db.query("SELECT id FROM agent WHERE role_id = ? AND status != 'offline' LIMIT 1").get(params.id);
+    if (bound) return json({ error: "Role has active agents bound" }, 409);
+    ctx.db.run("DELETE FROM role WHERE id = ?", [params.id]);
+    if (role.role_md_path && existsSync(role.role_md_path)) {
+      const { unlinkSync } = require("fs");
+      try { unlinkSync(role.role_md_path); } catch {}
+    }
+    ctx.bus.publish("role.deleted", { id: params.id });
+    return json({ id: params.id, deleted: true });
+  });
+
+  // POST /api/workspaces/:wid/roles - upload role.md for a workspace
+  router.post("/api/workspaces/:wid/roles", async (req, params) => {
+    const { id, name, content, runtime_id, capabilities, preferred_runtimes, headcount, project_id } = await body(req);
+    if (!name) return json({ error: "name is required" }, 400);
+    const created = createWorkspaceRole(ctx.db, {
+      workspaceId: params.wid,
+      projectId: project_id || null,
+      id,
+      name,
+      capabilities: Array.isArray(capabilities) ? capabilities : [],
+      preferredRuntimes: Array.isArray(preferred_runtimes) ? preferred_runtimes : [],
+      headcount: Number(headcount || 1),
+      runtimeId: runtime_id || null,
+      hubDir: ctx.hubDir,
+    }, ctx.bus?.publish ? ctx.bus.publish.bind(ctx.bus) : undefined);
+
+    if (content) {
+      writeFileSync(created.roleMdPath, content, "utf-8");
+      syncRolesFromDirectory(ctx.db, join(ctx.hubDir, "roles"));
+    }
+
+    return json({ ...created.role, agents: created.agents }, 201);
+  });
+
+  // GET /api/workspaces/:wid/roles
+  router.get("/api/workspaces/:wid/roles", (_req, params) => {
+    const roles = ctx.db.query("SELECT * FROM role WHERE workspace_id = ? ORDER BY id ASC").all(params.wid);
+    return json(roles);
+  });
+
+  // Instantiate agents for a role
+  router.post("/api/roles/:id/instantiate", async (req, params) => {
+    const role = ctx.db.query("SELECT * FROM role WHERE id = ?").get(params.id) as any;
+    if (!role) return json({ error: "Role not found" }, 404);
+    const { runtime_id, count } = await body(req);
+    if (!runtime_id) return json({ error: "runtime_id is required" }, 400);
+
+    const runtime = ctx.db.query("SELECT * FROM agent_runtime WHERE id = ?").get(runtime_id) as any;
+    if (!runtime) return json({ error: "Runtime not found" }, 404);
+
+    const headcount = count || role.headcount || 1;
+    const agents: any[] = [];
+
+    for (let i = 0; i < headcount; i++) {
+      const agentId = generateId("agent");
+      const ts = now();
+      const name = `${role.name}-${i + 1}`;
+      const workdir = null;
+      ctx.db.run(
+        "INSERT INTO agent (id, role_id, runtime_id, name, workdir, status, created_at, last_active_at) VALUES (?, ?, ?, ?, ?, 'idle', ?, ?)",
+        [agentId, role.id, runtime_id, name, workdir, ts, ts]
+      );
+      agents.push({ id: agentId, name, role_id: role.id, runtime_id, status: "idle", workdir });
+      ctx.bus.publish("agent.spawned", { id: agentId, name, runtime_id });
+    }
+
+    return json(agents, 201);
+  });
+}

package/src/api/runtimes.ts

@@ -0,0 +1,62 @@
+import type { Router } from "../core/router";
+import { json, body } from "../core/router";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { required } from "../core/validate";
+import { checkRuntimeHealth, runtimeWaterline } from "../ops";
+import { registerDiscoveredRuntimes } from "../discovery";
+
+export function registerRuntimeRoutes(router: Router, ctx: HubContext) {
+  router.get("/api/runtimes", () => {
+    const rows = (ctx.db.query("SELECT * FROM agent_runtime ORDER BY created_at DESC").all() as any[])
+      .map((runtime) => ({ ...runtime, waterline: runtimeWaterline(ctx.db, runtime.id, Number(runtime.capacity ?? -1)) }));
+    return json(rows);
+  });
+
+  router.post("/api/runtimes", async (req) => {
+    const { type, transport, cmd, target, capacity, capabilities, version } = await body(req);
+    required({ type, transport }, ["type", "transport"]);
+    const id = generateId("runtime");
+    const ts = now();
+    ctx.db.run(
+      "INSERT INTO agent_runtime (id, type, transport, cmd, target, version, capacity, status, capabilities_json, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, 'online', ?, ?)",
+      [id, type, transport, cmd || null, target || null, version || null, capacity ?? -1, JSON.stringify(capabilities || []), ts]
+    );
+    return json({ id, type, transport, version: version || null, status: "online", created_at: ts }, 201);
+  });
+
+  router.post("/api/runtimes/:id/healthcheck", async (_req, params) => {
+    const runtime = ctx.db.query("SELECT * FROM agent_runtime WHERE id = ?").get(params.id) as any;
+    if (!runtime) return json({ error: "Not found" }, 404);
+    return json(await checkRuntimeHealth(ctx.db, runtime));
+  });
+
+  router.patch("/api/runtimes/:id", async (req, params) => {
+    const runtime = ctx.db.query("SELECT * FROM agent_runtime WHERE id = ?").get(params.id) as any;
+    if (!runtime) return json({ error: "Not found" }, 404);
+    const { capacity, oversubscription_factor } = await body(req);
+    if (capacity !== undefined) {
+      ctx.db.run("UPDATE agent_runtime SET capacity = ? WHERE id = ?", [capacity, params.id]);
+    }
+    if (oversubscription_factor !== undefined) {
+      ctx.db.run("UPDATE agent_runtime SET oversubscription_factor = ? WHERE id = ?", [oversubscription_factor, params.id]);
+    }
+    const updated = ctx.db.query("SELECT * FROM agent_runtime WHERE id = ?").get(params.id) as any;
+    return json({ ...updated, waterline: runtimeWaterline(ctx.db, updated.id, Number(updated.capacity ?? -1)) });
+  });
+
+  // 重新探测本机 Runtimes，新发现的自动注册
+  router.post("/api/runtimes/discover", async () => {
+    try {
+      const result = await registerDiscoveredRuntimes(ctx.db);
+      return json({
+        discovered: result.discovered.length,
+        added: result.added.length,
+        skipped: result.skipped.length,
+        new_runtimes: result.added,
+      });
+    } catch (err: any) {
+      return json({ error: `Discovery failed: ${err.message || err}` }, 500);
+    }
+  });
+}

package/src/api/scheduled-tasks.ts

@@ -0,0 +1,203 @@
+import type { Router } from "../core/router";
+import { body, json } from "../core/router";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { computeNextFireAt, runDueScheduledTasks, validateScheduleInput } from "../scheduler";
+
+export function registerScheduledTaskRoutes(router: Router, ctx: HubContext) {
+  router.get("/api/scheduled-tasks", (req) => {
+    const url = new URL(req.url);
+    const workspaceId = url.searchParams.get("workspace_id");
+    const enabled = url.searchParams.get("enabled");
+    let sql = `
+      SELECT
+        scheduled_task.*,
+        project.name AS project_name,
+        role.name AS resolved_role_name
+      FROM scheduled_task
+      LEFT JOIN project ON project.id = scheduled_task.project_id
+      LEFT JOIN role ON role.id = scheduled_task.assignee_role_id
+      WHERE 1=1`;
+    const params: any[] = [];
+    if (workspaceId) {
+      sql += " AND scheduled_task.workspace_id = ?";
+      params.push(workspaceId);
+    }
+    if (enabled !== null) {
+      sql += " AND scheduled_task.enabled = ?";
+      params.push(enabled === "true" || enabled === "1" ? 1 : 0);
+    }
+    sql += " ORDER BY scheduled_task.enabled DESC, scheduled_task.next_fire_at ASC, scheduled_task.created_at DESC";
+    return json(ctx.db.query(sql).all(...params));
+  });
+
+  router.post("/api/scheduled-tasks", async (req) => {
+    const input = await body(req);
+    const normalized = normalizeScheduledTaskInput(ctx, input);
+    if ("error" in normalized) return json({ error: normalized.error }, normalized.status);
+
+    const id = generateId("sched");
+    const ts = now();
+    const nextFireAt = computeNextFireAt(normalized, ts);
+    ctx.db.run(
+      `INSERT INTO scheduled_task (
+        id, workspace_id, project_id, title, description, priority, schedule_type, cron_expr, run_at,
+        assignee_role_id, assignee_role_name, enabled, next_fire_at, created_by, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        normalized.workspace_id,
+        normalized.project_id,
+        normalized.title,
+        normalized.description || null,
+        normalized.priority,
+        normalized.schedule_type,
+        normalized.cron_expr || null,
+        normalized.run_at || null,
+        normalized.assignee_role_id || null,
+        normalized.assignee_role_name || null,
+        normalized.enabled,
+        nextFireAt,
+        normalized.created_by,
+        ts,
+        ts,
+      ],
+    );
+    ctx.bus?.publish?.("scheduled_task.created", { id, workspace_id: normalized.workspace_id, next_fire_at: nextFireAt });
+    return json(ctx.db.query("SELECT * FROM scheduled_task WHERE id = ?").get(id), 201);
+  });
+
+  router.patch("/api/scheduled-tasks/:id", async (req, params) => {
+    const existing = ctx.db.query("SELECT * FROM scheduled_task WHERE id = ?").get(params.id) as any;
+    if (!existing) return json({ error: "Not found" }, 404);
+    const input = await body(req);
+    const merged = {
+      ...existing,
+      ...input,
+      workspace_id: input.workspace_id || existing.workspace_id,
+      project_id: input.project_id || existing.project_id,
+    };
+    const normalized = normalizeScheduledTaskInput(ctx, merged, existing);
+    if ("error" in normalized) return json({ error: normalized.error }, normalized.status);
+
+    const ts = now();
+    const scheduleChanged = input.schedule_type !== undefined || input.cron_expr !== undefined || input.run_at !== undefined || input.enabled !== undefined;
+    const nextFireAt = normalized.enabled
+      ? (scheduleChanged ? computeNextFireAt(normalized, ts) : existing.next_fire_at)
+      : null;
+    ctx.db.run(
+      `UPDATE scheduled_task SET
+        workspace_id = ?, project_id = ?, title = ?, description = ?, priority = ?, schedule_type = ?,
+        cron_expr = ?, run_at = ?, assignee_role_id = ?, assignee_role_name = ?, enabled = ?,
+        next_fire_at = ?, updated_at = ?
+       WHERE id = ?`,
+      [
+        normalized.workspace_id,
+        normalized.project_id,
+        normalized.title,
+        normalized.description || null,
+        normalized.priority,
+        normalized.schedule_type,
+        normalized.cron_expr || null,
+        normalized.run_at || null,
+        normalized.assignee_role_id || null,
+        normalized.assignee_role_name || null,
+        normalized.enabled,
+        nextFireAt,
+        ts,
+        params.id,
+      ],
+    );
+    ctx.bus?.publish?.("scheduled_task.updated", { id: params.id, workspace_id: normalized.workspace_id, next_fire_at: nextFireAt });
+    return json(ctx.db.query("SELECT * FROM scheduled_task WHERE id = ?").get(params.id));
+  });
+
+  router.delete("/api/scheduled-tasks/:id", (_req, params) => {
+    const existing = ctx.db.query("SELECT * FROM scheduled_task WHERE id = ?").get(params.id) as any;
+    if (!existing) return json({ error: "Not found" }, 404);
+    ctx.db.run("DELETE FROM scheduled_task WHERE id = ?", [params.id]);
+    ctx.bus?.publish?.("scheduled_task.deleted", { id: params.id, workspace_id: existing.workspace_id });
+    return json({ id: params.id, deleted: true });
+  });
+
+  router.post("/api/scheduled-tasks/run", async (req) => {
+    const input = await body(req).catch(() => ({}));
+    return json(await runDueScheduledTasks(ctx, input.now || now()));
+  });
+}
+
+function normalizeScheduledTaskInput(ctx: HubContext, input: any, existing?: any):
+  | {
+    workspace_id: string;
+    project_id: string;
+    title: string;
+    description: string;
+    priority: number;
+    schedule_type: "cron" | "once";
+    cron_expr: string | null;
+    run_at: number | null;
+    assignee_role_id: string | null;
+    assignee_role_name: string | null;
+    enabled: number;
+    created_by: string;
+  }
+  | { error: string; status: number } {
+  const workspaceId = String(input.workspace_id || "").trim();
+  if (!workspaceId) return { error: "workspace_id is required", status: 400 };
+  const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(workspaceId) as any;
+  if (!workspace) return { error: "Workspace not found", status: 404 };
+
+  const projectId = resolveProjectId(ctx, workspaceId, input.project_id);
+  if (!projectId) return { error: "project_id is required when the workspace has no projects", status: 400 };
+
+  const title = String(input.title || "").trim();
+  if (!title) return { error: "title is required", status: 400 };
+
+  let scheduleType: "cron" | "once";
+  try {
+    scheduleType = validateScheduleInput(input) as "cron" | "once";
+  } catch (err: any) {
+    return { error: err.message, status: 400 };
+  }
+
+  const role = resolveRole(ctx, workspaceId, input.assignee_role_id, input.assignee_role || input.assignee_role_name);
+  if ("error" in role) return role;
+
+  return {
+    workspace_id: workspaceId,
+    project_id: projectId,
+    title,
+    description: String(input.description ?? existing?.description ?? ""),
+    priority: Number(input.priority ?? existing?.priority ?? 0),
+    schedule_type: scheduleType,
+    cron_expr: scheduleType === "cron" ? String(input.cron_expr || "").trim() : null,
+    run_at: scheduleType === "once" ? Number(input.run_at) : null,
+    assignee_role_id: role.role?.id || null,
+    assignee_role_name: role.role?.name || String(input.assignee_role_name || input.assignee_role || "").trim() || null,
+    enabled: input.enabled === undefined ? Number(existing?.enabled ?? 1) : (input.enabled ? 1 : 0),
+    created_by: String(input.created_by || existing?.created_by || "user"),
+  };
+}
+
+function resolveProjectId(ctx: HubContext, workspaceId: string, projectId?: string) {
+  if (projectId) {
+    const project = ctx.db.query("SELECT id FROM project WHERE id = ? AND workspace_id = ?").get(projectId, workspaceId) as any;
+    return project?.id || null;
+  }
+  const project = ctx.db.query("SELECT id FROM project WHERE workspace_id = ? ORDER BY created_at ASC LIMIT 1").get(workspaceId) as any;
+  return project?.id || null;
+}
+
+function resolveRole(ctx: HubContext, workspaceId: string, roleId?: string | null, roleName?: string | null) {
+  if (roleId) {
+    const role = ctx.db.query("SELECT * FROM role WHERE id = ? AND workspace_id = ?").get(roleId, workspaceId) as any;
+    return role ? { role } : { error: "Assignee role not found", status: 404 };
+  }
+  if (roleName) {
+    const role = ctx.db.query(
+      "SELECT * FROM role WHERE workspace_id = ? AND LOWER(name) = LOWER(?) ORDER BY created_at ASC LIMIT 1",
+    ).get(workspaceId, roleName) as any;
+    return role ? { role } : { error: "Assignee role not found", status: 404 };
+  }
+  return { role: null };
+}