macro-agent 0.2.5 → 0.2.6

package/src/api/server.ts

@@ -1,380 +0,0 @@
-/**
- * REST API server for macro-agent.
- *
- * Provides HTTP endpoints for managing agents, tasks, teams, and metrics.
- *
- * @module api/server
- */
-
-import express, { type Request, type Response } from "express";
-import type { Server } from "node:http";
-import type { MacroAgentSystemV2 } from "../boot-v2.js";
-import type { ApiServer, ApiServerConfig } from "./types.js";
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/** Extract a single string from Express v5 param/query (string | string[]). */
-function str(value: unknown): string | undefined {
-  if (typeof value === "string") return value;
-  if (Array.isArray(value) && typeof value[0] === "string") return value[0];
-  return undefined;
-}
-
-// =============================================================================
-// Placeholder metrics (will be replaced when metrics module lands)
-// =============================================================================
-
-interface MetricsSnapshot {
-  agents: {
-    total: number;
-    running: number;
-    stopped: number;
-    failed: number;
-  };
-  tasks: {
-    total: number;
-    open: number;
-    in_progress: number;
-    closed: number;
-  };
-  uptime: number;
-  collectedAt: string;
-}
-
-async function collectMetricsPlaceholder(
-  system: MacroAgentSystemV2,
-  startTime: number
-): Promise<MetricsSnapshot> {
-  const agents = system.agentStore.listAgents();
-  const running = agents.filter((a) => a.state === "running").length;
-  const stopped = agents.filter((a) => a.state === "stopped").length;
-  const failed = agents.filter((a) => a.state === "failed").length;
-
-  let taskMetrics = { total: 0, open: 0, in_progress: 0, closed: 0 };
-  try {
-    const tasks = await system.tasksAdapter.listTasks();
-    taskMetrics = {
-      total: tasks.length,
-      open: tasks.filter((t) => t.status === "open").length,
-      in_progress: tasks.filter((t) => t.status === "in_progress").length,
-      closed: tasks.filter((t) => t.status === "closed").length,
-    };
-  } catch {
-    // opentasks may be down
-  }
-
-  return {
-    agents: {
-      total: agents.length,
-      running,
-      stopped,
-      failed,
-    },
-    tasks: taskMetrics,
-    uptime: (Date.now() - startTime) / 1000,
-    collectedAt: new Date().toISOString(),
-  };
-}
-
-// =============================================================================
-// Factory
-// =============================================================================
-
-export function createApiServer(
-  system: MacroAgentSystemV2,
-  config?: ApiServerConfig
-): ApiServer {
-  const port = config?.port ?? 3000;
-  const host = config?.host ?? "127.0.0.1";
-  const startTime = Date.now();
-
-  const app = express();
-  app.use(express.json());
-
-  // ── Health ──────────────────────────────────────────────────────
-
-  app.get("/api/health", (_req: Request, res: Response) => {
-    res.json({
-      ok: true,
-      uptime: (Date.now() - startTime) / 1000,
-      version: "0.1.1",
-    });
-  });
-
-  // ── Agents ─────────────────────────────────────────────────────
-
-  app.get("/api/agents", (req: Request, res: Response) => {
-    try {
-      const state = str(req.query.state);
-      const role = str(req.query.role);
-      const team = str(req.query.team);
-      const limit = parseInt(str(req.query.limit) ?? "50", 10) || 50;
-      const offset = parseInt(str(req.query.offset) ?? "0", 10) || 0;
-
-      const filter: Record<string, unknown> = {};
-      if (state) filter.state = state;
-      if (role) filter.role = role;
-      if (team) filter.team = team;
-
-      const agents = system.agentManager.list(
-        Object.keys(filter).length > 0 ? (filter as any) : undefined
-      );
-
-      const total = agents.length;
-      const paged = agents.slice(offset, offset + limit);
-
-      res.json({ agents: paged, total });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/agents/:id", (req: Request, res: Response) => {
-    try {
-      const id = str(req.params.id);
-      const agent = system.agentManager.get(id!);
-      if (!agent) {
-        res.status(404).json({ error: "Agent not found" });
-        return;
-      }
-      res.json(agent);
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/agents/:id/hierarchy", (req: Request, res: Response) => {
-    try {
-      const id = str(req.params.id)!;
-      const depthStr = str(req.query.depth);
-      const options = depthStr ? { depth: parseInt(depthStr, 10) } : undefined;
-
-      const hierarchy = system.agentManager.getHierarchy(id, options);
-      if (!hierarchy) {
-        res.status(404).json({ error: "Agent not found" });
-        return;
-      }
-      res.json(hierarchy);
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/agents/:id/inbox", async (req: Request, res: Response) => {
-    try {
-      const id = str(req.params.id)!;
-      const agent = system.agentManager.get(id);
-      if (!agent) {
-        res.status(404).json({ error: "Agent not found" });
-        return;
-      }
-
-      const limit = parseInt(str(req.query.limit) ?? "20", 10) || 20;
-      const unreadOnly = str(req.query.unreadOnly) === "true";
-
-      const messages = await system.inboxAdapter.checkInbox(id, {
-        limit,
-        unreadOnly,
-      });
-
-      res.json({ messages });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.post("/api/agents", async (req: Request, res: Response) => {
-    try {
-      const { task, role, parent, cwd } = req.body;
-
-      if (!task) {
-        res.status(400).json({ error: "Missing required field: task" });
-        return;
-      }
-
-      const spawned = await system.agentManager.spawn({
-        task,
-        role,
-        parent,
-        cwd,
-      });
-
-      res.status(201).json(spawned);
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.delete("/api/agents/:id", async (req: Request, res: Response) => {
-    try {
-      const id = str(req.params.id)!;
-      const agent = system.agentManager.get(id);
-      if (!agent) {
-        res.status(404).json({ error: "Agent not found" });
-        return;
-      }
-
-      const reason = str(req.query.reason) ?? "cancelled";
-      await system.agentManager.terminate(id, reason as any);
-
-      res.json({ ok: true });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  // ── Tasks ──────────────────────────────────────────────────────
-
-  app.get("/api/tasks", async (req: Request, res: Response) => {
-    try {
-      const status = str(req.query.status);
-      const assignee = str(req.query.assignee);
-      const limitStr = str(req.query.limit);
-
-      const filter: Record<string, unknown> = {};
-      if (status) filter.status = status;
-      if (assignee) filter.assignee = assignee;
-      if (limitStr) filter.limit = parseInt(limitStr, 10);
-
-      const tasks = await system.tasksAdapter.listTasks(
-        Object.keys(filter).length > 0 ? (filter as any) : undefined
-      );
-
-      res.json({ tasks });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/tasks/ready", async (req: Request, res: Response) => {
-    try {
-      const limitStr = str(req.query.limit);
-      const tagsStr = str(req.query.tags);
-
-      const opts: { limit?: number; tags?: string[] } = {};
-      if (limitStr) opts.limit = parseInt(limitStr, 10);
-      if (tagsStr) opts.tags = tagsStr.split(",");
-
-      const tasks = await system.tasksAdapter.queryReady(opts);
-
-      res.json({ tasks });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  // ── Metrics ────────────────────────────────────────────────────
-
-  app.get("/api/metrics", async (_req: Request, res: Response) => {
-    try {
-      // Try real metrics module first, fall back to placeholder
-      let snapshot: MetricsSnapshot;
-      try {
-        // Dynamic import — module may not exist yet (built in parallel)
-        const metricsPath = "../metrics/metrics.js";
-        const metricsModule = await (import(metricsPath) as Promise<any>);
-        snapshot = await metricsModule.collectMetrics(system, startTime);
-      } catch {
-        snapshot = await collectMetricsPlaceholder(system, startTime);
-      }
-      res.json(snapshot);
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/metrics/agents", (_req: Request, res: Response) => {
-    try {
-      const agents = system.agentStore.listAgents();
-      const running = agents.filter((a) => a.state === "running").length;
-      const stopped = agents.filter((a) => a.state === "stopped").length;
-      const failed = agents.filter((a) => a.state === "failed").length;
-
-      res.json({
-        total: agents.length,
-        running,
-        stopped,
-        failed,
-      });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  app.get("/api/metrics/tasks", async (_req: Request, res: Response) => {
-    try {
-      const tasks = await system.tasksAdapter.listTasks();
-      res.json({
-        total: tasks.length,
-        open: tasks.filter((t) => t.status === "open").length,
-        in_progress: tasks.filter((t) => t.status === "in_progress").length,
-        closed: tasks.filter((t) => t.status === "closed").length,
-      });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  // ── Teams ──────────────────────────────────────────────────────
-
-  app.get("/api/teams", (_req: Request, res: Response) => {
-    try {
-      const agents = system.agentStore.listAgents();
-      const teamMap = new Map<
-        string,
-        { name: string; agentCount: number; roles: Set<string> }
-      >();
-
-      for (const agent of agents) {
-        const teamName = agent.team ?? "default";
-        let entry = teamMap.get(teamName);
-        if (!entry) {
-          entry = { name: teamName, agentCount: 0, roles: new Set() };
-          teamMap.set(teamName, entry);
-        }
-        entry.agentCount++;
-        entry.roles.add(agent.role);
-      }
-
-      const teams = Array.from(teamMap.values()).map((t) => ({
-        name: t.name,
-        agentCount: t.agentCount,
-        roles: Array.from(t.roles),
-      }));
-
-      res.json({ teams });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message ?? "Internal server error" });
-    }
-  });
-
-  // ── Server Lifecycle ───────────────────────────────────────────
-
-  let server: Server | null = null;
-
-  return {
-    app,
-
-    async start(): Promise<void> {
-      return new Promise((resolve) => {
-        server = app.listen(port, host, () => {
-          console.log(`[api] Listening on ${host}:${port}`);
-          resolve();
-        });
-      });
-    },
-
-    async stop(): Promise<void> {
-      if (server) {
-        return new Promise((resolve) => {
-          server!.close(() => {
-            server = null;
-            resolve();
-          });
-        });
-      }
-    },
-  };
-}

package/src/api/types.ts

@@ -1,39 +0,0 @@
-/**
- * REST API request/response types.
- *
- * @module api/types
- */
-
-import type { Express } from "express";
-
-// =============================================================================
-// Server
-// =============================================================================
-
-export interface ApiServer {
-  /** Express application instance */
-  app: Express;
-  /** Start listening */
-  start(): Promise<void>;
-  /** Stop the server */
-  stop(): Promise<void>;
-}
-
-export interface ApiServerConfig {
-  port?: number;
-  host?: string;
-}
-
-// =============================================================================
-// Responses
-// =============================================================================
-
-export interface HealthResponse {
-  ok: true;
-  uptime: number;
-  version: string;
-}
-
-export interface ErrorResponse {
-  error: string;
-}

package/src/auth/__tests__/token.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateToken, secureCompare, AgentTokenManager } from "../token.js";
-
-describe("generateToken", () => {
-  it("generates a hex string of expected length", () => {
-    const token = generateToken();
-    // 32 bytes = 64 hex chars
-    expect(token).toHaveLength(64);
-    expect(token).toMatch(/^[0-9a-f]+$/);
-  });
-
-  it("generates different tokens each time", () => {
-    const a = generateToken();
-    const b = generateToken();
-    expect(a).not.toBe(b);
-  });
-
-  it("respects custom byte length", () => {
-    const token = generateToken(16);
-    expect(token).toHaveLength(32); // 16 bytes = 32 hex chars
-  });
-});
-
-describe("secureCompare", () => {
-  it("returns true for identical strings", () => {
-    expect(secureCompare("abc123", "abc123")).toBe(true);
-  });
-
-  it("returns false for different strings of same length", () => {
-    expect(secureCompare("abc123", "xyz789")).toBe(false);
-  });
-
-  it("returns false for different length strings", () => {
-    expect(secureCompare("short", "longer-string")).toBe(false);
-  });
-
-  it("returns true for empty strings", () => {
-    expect(secureCompare("", "")).toBe(true);
-  });
-});
-
-describe("AgentTokenManager", () => {
-  it("creates and verifies a token", () => {
-    const mgr = new AgentTokenManager();
-    const token = mgr.createToken("agent-1");
-    expect(token).toHaveLength(64);
-    expect(mgr.verifyToken("agent-1", token)).toBe(true);
-  });
-
-  it("rejects wrong token", () => {
-    const mgr = new AgentTokenManager();
-    mgr.createToken("agent-1");
-    expect(mgr.verifyToken("agent-1", "wrong-token")).toBe(false);
-  });
-
-  it("rejects unknown agent", () => {
-    const mgr = new AgentTokenManager();
-    expect(mgr.verifyToken("unknown", "any-token")).toBe(false);
-  });
-
-  it("revokes a token", () => {
-    const mgr = new AgentTokenManager();
-    const token = mgr.createToken("agent-1");
-    expect(mgr.revokeToken("agent-1")).toBe(true);
-    expect(mgr.verifyToken("agent-1", token)).toBe(false);
-    expect(mgr.hasToken("agent-1")).toBe(false);
-  });
-
-  it("revoke returns false for unknown agent", () => {
-    const mgr = new AgentTokenManager();
-    expect(mgr.revokeToken("unknown")).toBe(false);
-  });
-
-  it("hasToken returns correct state", () => {
-    const mgr = new AgentTokenManager();
-    expect(mgr.hasToken("agent-1")).toBe(false);
-    mgr.createToken("agent-1");
-    expect(mgr.hasToken("agent-1")).toBe(true);
-  });
-
-  it("createToken overwrites previous token", () => {
-    const mgr = new AgentTokenManager();
-    const token1 = mgr.createToken("agent-1");
-    const token2 = mgr.createToken("agent-1");
-    expect(token1).not.toBe(token2);
-    expect(mgr.verifyToken("agent-1", token1)).toBe(false);
-    expect(mgr.verifyToken("agent-1", token2)).toBe(true);
-  });
-
-  it("manages multiple agents independently", () => {
-    const mgr = new AgentTokenManager();
-    const t1 = mgr.createToken("agent-1");
-    const t2 = mgr.createToken("agent-2");
-    expect(mgr.verifyToken("agent-1", t1)).toBe(true);
-    expect(mgr.verifyToken("agent-2", t2)).toBe(true);
-    // Cross-validation fails
-    expect(mgr.verifyToken("agent-1", t2)).toBe(false);
-    expect(mgr.verifyToken("agent-2", t1)).toBe(false);
-  });
-});

package/src/auth/index.ts

@@ -1 +0,0 @@
-export { generateToken, secureCompare, AgentTokenManager } from "./token.js";

package/src/auth/token.ts

@@ -1,82 +0,0 @@
-/**
- * Authentication Token Utilities
- *
- * Provides token generation, secure comparison, and per-agent
- * token management for the macro-agent server.
- */
-
-import * as crypto from "crypto";
-
-// =============================================================================
-// Token Generation
-// =============================================================================
-
-/**
- * Generate a cryptographically random hex token.
- */
-export function generateToken(bytes = 32): string {
-  return crypto.randomBytes(bytes).toString("hex");
-}
-
-// =============================================================================
-// Secure Comparison
-// =============================================================================
-
-/**
- * Constant-time string comparison to prevent timing attacks.
- */
-export function secureCompare(a: string, b: string): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-  const bufA = Buffer.from(a);
-  const bufB = Buffer.from(b);
-  return crypto.timingSafeEqual(bufA, bufB);
-}
-
-// =============================================================================
-// Agent Token Manager
-// =============================================================================
-
-/**
- * Manages per-agent authentication tokens.
- *
- * Each spawned agent gets a unique token at spawn time. The token is
- * passed to the subprocess via environment variable and validated on
- * every MCP bridge RPC call.
- */
-export class AgentTokenManager {
-  private tokens = new Map<string, string>();
-
-  /**
-   * Create and store a token for an agent. Returns the generated token.
-   */
-  createToken(agentId: string): string {
-    const token = generateToken();
-    this.tokens.set(agentId, token);
-    return token;
-  }
-
-  /**
-   * Verify that a token matches the one stored for an agent.
-   */
-  verifyToken(agentId: string, token: string): boolean {
-    const stored = this.tokens.get(agentId);
-    if (!stored) return false;
-    return secureCompare(stored, token);
-  }
-
-  /**
-   * Revoke an agent's token (e.g., on terminate).
-   */
-  revokeToken(agentId: string): boolean {
-    return this.tokens.delete(agentId);
-  }
-
-  /**
-   * Check if an agent has a registered token.
-   */
-  hasToken(agentId: string): boolean {
-    return this.tokens.has(agentId);
-  }
-}