@ronkovic/aad 0.3.0

package/src/modules/dashboard/__tests__/state-aggregator.test.ts

@@ -0,0 +1,330 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { StateAggregator } from "../services/state-aggregator";
+import { LogStore } from "../../logging";
+import type { LogEntry } from "../../logging";
+import type { TaskId, WorkerId, TaskStatus } from "../../../shared/types";
+import { createTaskId, createWorkerId } from "../../../shared/types";
+
+// Mock stores for testing
+interface Task {
+  taskId: TaskId;
+  status: TaskStatus;
+  dependsOn: TaskId[];
+  startTime?: string;
+  endTime?: string;
+}
+
+class MockTaskStore {
+  private tasks: Map<TaskId, Task> = new Map();
+
+  add(task: Task): void {
+    this.tasks.set(task.taskId, task);
+  }
+
+  async getAll(): Promise<Task[]> {
+    return Array.from(this.tasks.values());
+  }
+
+  async get(id: TaskId): Promise<Task | null> {
+    return this.tasks.get(id) ?? null;
+  }
+
+  async getByStatus(): Promise<Task[]> {
+    return [];
+  }
+
+  async save(): Promise<void> {}
+
+  async delete(): Promise<void> {}
+}
+
+class MockWorkerStateMachine {
+  constructor(private id: WorkerId, private _status: "idle" | "busy" | "stopped" = "idle") {}
+
+  isIdle(): boolean {
+    return this._status === "idle";
+  }
+
+  isBusy(): boolean {
+    return this._status === "busy";
+  }
+
+  isStopped(): boolean {
+    return this._status === "stopped";
+  }
+
+  getWorkerId(): WorkerId {
+    return this.id;
+  }
+}
+
+class MockProcessManager {
+  private workers: Map<WorkerId, MockWorkerStateMachine> = new Map();
+
+  addWorker(id: WorkerId, status: "idle" | "busy" | "stopped" = "idle"): void {
+    this.workers.set(id, new MockWorkerStateMachine(id, status));
+  }
+
+  getStats() {
+    let idle = 0;
+    let busy = 0;
+    let stopped = 0;
+    for (const worker of this.workers.values()) {
+      if (worker.isIdle()) idle++;
+      else if (worker.isBusy()) busy++;
+      else if (worker.isStopped()) stopped++;
+    }
+    return {
+      total: this.workers.size,
+      idle,
+      busy,
+      stopped,
+    };
+  }
+
+  getAllWorkers(): WorkerId[] {
+    return Array.from(this.workers.keys());
+  }
+
+  getWorker(id: WorkerId): MockWorkerStateMachine | null {
+    return this.workers.get(id) ?? null;
+  }
+}
+
+describe("StateAggregator", () => {
+  let logStore: LogStore;
+  let taskStore: MockTaskStore;
+  let processManager: MockProcessManager;
+  let aggregator: StateAggregator;
+
+  beforeEach(() => {
+    logStore = new LogStore();
+    taskStore = new MockTaskStore();
+    processManager = new MockProcessManager();
+    aggregator = new StateAggregator({
+      logStore,
+      taskStore: taskStore as any,
+      processManager: processManager as any,
+    });
+  });
+
+  test("getProgress calculates progress state correctly", async () => {
+    taskStore.add({
+      taskId: createTaskId("task-1"),
+      status: "pending",
+      dependsOn: [],
+    });
+    taskStore.add({
+      taskId: createTaskId("task-2"),
+      status: "running",
+      dependsOn: [],
+    });
+    taskStore.add({
+      taskId: createTaskId("task-3"),
+      status: "completed",
+      dependsOn: [],
+    });
+    taskStore.add({
+      taskId: createTaskId("task-4"),
+      status: "failed",
+      dependsOn: [],
+    });
+
+    const result = await aggregator.getProgress();
+
+    expect(result.progress).toEqual({
+      total: 4,
+      pending: 1,
+      running: 1,
+      completed: 1,
+      failed: 1,
+    });
+    expect(result.percentComplete).toBe(25); // 1 completed out of 4
+  });
+
+  test("getProgress handles zero tasks", async () => {
+    const result = await aggregator.getProgress();
+
+    expect(result.progress).toEqual({
+      total: 0,
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+    });
+    expect(result.percentComplete).toBe(0);
+  });
+
+  test("getTasks returns all tasks", async () => {
+    const task1 = {
+      taskId: createTaskId("task-1"),
+      status: "pending" as TaskStatus,
+      dependsOn: [],
+    };
+    const task2 = {
+      taskId: createTaskId("task-2"),
+      status: "running" as TaskStatus,
+      dependsOn: [createTaskId("task-1")],
+    };
+
+    taskStore.add(task1);
+    taskStore.add(task2);
+
+    const result = await aggregator.getTasks();
+
+    expect(result.tasks).toHaveLength(2);
+    expect(result.total).toBe(2);
+  });
+
+  test("getTaskLogs queries LogStore with taskId filter", async () => {
+    const entry1: LogEntry = {
+      level: "info",
+      service: "task-execution",
+      message: "Task started",
+      timestamp: Date.now(),
+      taskId: "task-1",
+    };
+    const entry2: LogEntry = {
+      level: "error",
+      service: "task-execution",
+      message: "Task failed",
+      timestamp: Date.now(),
+      taskId: "task-1",
+    };
+    const entry3: LogEntry = {
+      level: "info",
+      service: "task-execution",
+      message: "Other task",
+      timestamp: Date.now(),
+      taskId: "task-2",
+    };
+
+    logStore.add(entry1);
+    logStore.add(entry2);
+    logStore.add(entry3);
+
+    const result = aggregator.getTaskLogs(createTaskId("task-1"));
+
+    expect(result).toHaveLength(2);
+    const logEntry0 = result[0];
+    const logEntry1 = result[1];
+    if (logEntry0) expect(logEntry0.message).toBe("Task started");
+    if (logEntry1) expect(logEntry1.message).toBe("Task failed");
+  });
+
+  test("getWorkers returns worker stats and list", () => {
+    processManager.addWorker(createWorkerId("worker-1"), "busy");
+    processManager.addWorker(createWorkerId("worker-2"), "idle");
+
+    const result = aggregator.getWorkers();
+
+    expect(result.stats).toEqual({
+      total: 2,
+      idle: 1,
+      busy: 1,
+      stopped: 0,
+    });
+    expect(result.workers).toHaveLength(2);
+  });
+
+  test("getGraph builds dependency graph", async () => {
+    const task1 = {
+      taskId: createTaskId("task-1"),
+      status: "completed" as TaskStatus,
+      dependsOn: [],
+    };
+    const task2 = {
+      taskId: createTaskId("task-2"),
+      status: "running" as TaskStatus,
+      dependsOn: [createTaskId("task-1")],
+    };
+    const task3 = {
+      taskId: createTaskId("task-3"),
+      status: "pending" as TaskStatus,
+      dependsOn: [createTaskId("task-1"), createTaskId("task-2")],
+    };
+
+    taskStore.add(task1);
+    taskStore.add(task2);
+    taskStore.add(task3);
+
+    const result = await aggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(3);
+    expect(result.edges).toHaveLength(3); // task1->task2, task1->task3, task2->task3
+
+    const edge0 = result.edges[0];
+    const edge1 = result.edges[1];
+    const edge2 = result.edges[2];
+
+    if (edge0) {
+      expect(edge0.from).toBe("task-1");
+      expect(edge0.to).toBe("task-2");
+    }
+    if (edge1) {
+      expect(edge1.from).toBe("task-1");
+      expect(edge1.to).toBe("task-3");
+    }
+    if (edge2) {
+      expect(edge2.from).toBe("task-2");
+      expect(edge2.to).toBe("task-3");
+    }
+  });
+
+  test("getTimeline extracts task time ranges", async () => {
+    const now = Date.now();
+    taskStore.add({
+      taskId: createTaskId("task-1"),
+      status: "completed",
+      dependsOn: [],
+      startTime: new Date(now - 10000).toISOString(),
+      endTime: new Date(now - 5000).toISOString(),
+    });
+    taskStore.add({
+      taskId: createTaskId("task-2"),
+      status: "running",
+      dependsOn: [],
+      startTime: new Date(now - 3000).toISOString(),
+    });
+
+    const result = await aggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(2);
+    const task0 = result.tasks[0];
+    const task1 = result.tasks[1];
+    if (task0) {
+      expect(task0.id).toBe("task-1");
+      expect(task0.startTime).toBe(new Date(now - 10000).toISOString());
+      expect(task0.endTime).toBe(new Date(now - 5000).toISOString());
+    }
+    if (task1) {
+      expect(task1.id).toBe("task-2");
+      expect(task1.startTime).toBe(new Date(now - 3000).toISOString());
+      expect(task1.endTime).toBeUndefined();
+    }
+  });
+
+  test("queryLogs forwards filter to LogStore", () => {
+    const entry1: LogEntry = {
+      level: "error",
+      service: "planning",
+      message: "Error 1",
+      timestamp: Date.now(),
+    };
+    const entry2: LogEntry = {
+      level: "info",
+      service: "planning",
+      message: "Info 1",
+      timestamp: Date.now(),
+    };
+
+    logStore.add(entry1);
+    logStore.add(entry2);
+
+    const result = aggregator.queryLogs({ level: "error", limit: 10 });
+
+    expect(result).toHaveLength(1);
+    const entry = result[0];
+    if (entry) expect(entry.level).toBe("error");
+  });
+});

package/src/modules/dashboard/index.ts

@@ -0,0 +1,8 @@
+// Dashboard Module Public API
+
+export { DashboardServer, type DashboardServerOptions } from "./server";
+export { SSEBroadcaster, type SSEClient } from "./services/sse-broadcaster";
+export { StateAggregator, type StateAggregatorOptions } from "./services/state-aggregator";
+export { FileWatcher } from "./services/file-watcher";
+export { createAPIRoutes } from "./routes/api";
+export { createSSERoutes } from "./routes/sse";

package/src/modules/dashboard/routes/api.ts

@@ -0,0 +1,84 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import type { StateAggregator } from "../services/state-aggregator";
+import { createTaskId } from "../../../shared/types";
+
+const logQuerySchema = z.object({
+  level: z.string().optional(),
+  service: z.string().optional(),
+  taskId: z.string().optional(),
+  workerId: z.string().optional(),
+  limit: z
+    .string()
+    .optional()
+    .transform((val) => (val ? parseInt(val, 10) : undefined))
+    .refine((val) => val === undefined || (val > 0 && !isNaN(val)), {
+      message: "limit must be a positive number",
+    }),
+});
+
+export function createAPIRoutes(aggregator: StateAggregator): Hono {
+  const app = new Hono();
+
+  app.get("/api/progress", async (c) => {
+    const data = await aggregator.getProgress();
+    return c.json(data);
+  });
+
+  app.get("/api/tasks", async (c) => {
+    const data = await aggregator.getTasks();
+    return c.json(data);
+  });
+
+  app.get("/api/tasks/:id/logs", (c) => {
+    const taskId = createTaskId(c.req.param("id"));
+    const logs = aggregator.getTaskLogs(taskId);
+    return c.json(logs);
+  });
+
+  app.get("/api/workers", (c) => {
+    const data = aggregator.getWorkers();
+    return c.json(data);
+  });
+
+  app.get("/api/graph", async (c) => {
+    const data = await aggregator.getGraph();
+    return c.json(data);
+  });
+
+  app.get("/api/timeline", async (c) => {
+    const data = await aggregator.getTimeline();
+    return c.json(data);
+  });
+
+  app.get("/api/logs", (c) => {
+    const query = c.req.query();
+
+    // Validate query parameters with Zod
+    const parseResult = logQuerySchema.safeParse(query);
+
+    if (!parseResult.success) {
+      return c.json(
+        {
+          error: "Invalid query parameters",
+          details: parseResult.error.errors,
+        },
+        400
+      );
+    }
+
+    const validatedQuery = parseResult.data;
+
+    const logs = aggregator.queryLogs({
+      level: validatedQuery.level,
+      service: validatedQuery.service,
+      taskId: validatedQuery.taskId,
+      workerId: validatedQuery.workerId,
+      limit: validatedQuery.limit,
+    });
+
+    return c.json(logs);
+  });
+
+  return app;
+}

package/src/modules/dashboard/routes/sse.ts

@@ -0,0 +1,37 @@
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import type { SSEBroadcaster, SSEClient } from "../services/sse-broadcaster";
+
+export function createSSERoutes(broadcaster: SSEBroadcaster): Hono {
+  const app = new Hono();
+
+  app.get("/events/all", (c) => {
+    return streamSSE(c, async (stream) => {
+      // Create SSE client wrapper
+      const client: SSEClient = {
+        send: (data: string) => {
+          void stream.write(data);
+        },
+        close: () => {
+          // Stream will be closed automatically when function returns
+        },
+      };
+
+      // Register client with broadcaster
+      broadcaster.addClient(client);
+
+      // Keep connection alive until client disconnects
+      // Use a reasonable timeout loop instead of MAX_SAFE_INTEGER
+      try {
+        while (true) {
+          await stream.sleep(1000000); // Sleep for ~16 minutes, then loop
+        }
+      } finally {
+        // Cleanup on disconnect (via error or abort)
+        broadcaster.removeClient(client);
+      }
+    });
+  });
+
+  return app;
+}

package/src/modules/dashboard/server.ts

@@ -0,0 +1,111 @@
+import { Hono } from "hono";
+import type { Logger } from "pino";
+import { SSEBroadcaster } from "./services/sse-broadcaster";
+import { StateAggregator } from "./services/state-aggregator";
+import { createAPIRoutes } from "./routes/api";
+import { createSSERoutes } from "./routes/sse";
+import type { EventBus } from "../../shared/events";
+import type { LogStore } from "../../modules/logging";
+import type { TaskStore } from "../../modules/task-queue";
+import type { ProcessManager } from "../../modules/process-manager";
+import { DashboardError } from "../../shared/errors";
+import dashboardHTML from "./ui/dashboard.html" with { type: "text" };
+
+/**
+ * Bun.serve() return type
+ */
+interface BunServer {
+  stop(): void;
+  port: number | undefined;
+  hostname: string;
+  fetch: (request: Request) => Response | Promise<Response>;
+}
+
+export interface DashboardServerOptions {
+  eventBus: EventBus;
+  logStore: LogStore;
+  taskStore: TaskStore;
+  processManager: ProcessManager;
+  port: number;
+  host: string;
+  logger?: Logger;
+}
+
+export class DashboardServer {
+  private broadcaster: SSEBroadcaster;
+  private aggregator: StateAggregator;
+  private app: Hono;
+  private server: BunServer | null = null;
+  private port: number;
+  private host: string;
+  private logger?: Logger;
+
+  constructor(options: DashboardServerOptions) {
+    this.port = options.port;
+    this.host = options.host;
+    this.logger = options.logger;
+
+    // Initialize SSE broadcaster
+    this.broadcaster = new SSEBroadcaster(options.eventBus, options.logger);
+
+    // Initialize state aggregator
+    this.aggregator = new StateAggregator({
+      logStore: options.logStore,
+      taskStore: options.taskStore,
+      processManager: options.processManager,
+    });
+
+    // Create Hono app
+    this.app = new Hono();
+
+    // Serve static HTML dashboard (FIX #6: use text import for binary build)
+    this.app.get("/", (c) => {
+      return c.html(String(dashboardHTML));
+    });
+
+    // Mount API routes
+    this.app.route("/", createAPIRoutes(this.aggregator));
+
+    // Mount SSE routes
+    this.app.route("/", createSSERoutes(this.broadcaster));
+  }
+
+  start(): void {
+    if (this.server) {
+      // Already started
+      return;
+    }
+
+    // Start SSE broadcaster
+    this.broadcaster.start();
+
+    // Start HTTP server with Bun.serve
+    try {
+      this.server = Bun.serve({
+        port: this.port,
+        hostname: this.host,
+        fetch: this.app.fetch,
+      }) as BunServer;
+      this.logger?.info({ port: this.port, host: this.host }, "Dashboard server started");
+    } catch (error) {
+      throw new DashboardError("Failed to start dashboard server", {
+        port: this.port,
+        host: this.host,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  stop(): void {
+    if (!this.server) {
+      return;
+    }
+
+    // Stop SSE broadcaster
+    this.broadcaster.stop();
+
+    // Stop HTTP server
+    this.server.stop();
+    this.server = null;
+  }
+}

package/src/modules/dashboard/services/file-watcher.ts

@@ -0,0 +1,36 @@
+import type { EventBus } from "../../../shared/events";
+import type { FSWatcher } from "chokidar";
+
+/**
+ * FileWatcher - Bash script ブリッジ (オプション機能)
+ *
+ * Bashスクリプトがファイルシステムに書き込むイベントを監視し、
+ * EventBusに転送する。Phase 3では最小限のスタブ実装。
+ */
+export class FileWatcher {
+  private _eventBus: EventBus;
+  private _watchPath: string;
+  private watcher: FSWatcher | null = null;
+
+  constructor(eventBus: EventBus, watchPath: string) {
+    this._eventBus = eventBus;
+    this._watchPath = watchPath;
+  }
+
+  start(): void {
+    // Phase 3: 最小限のスタブ実装
+    // 実際のchokidarインスタンス化とファイル監視は将来の拡張として残す
+    // 現時点ではstart/stopのライフサイクルのみ提供
+
+    // Suppress unused variable warnings
+    void this._eventBus;
+    void this._watchPath;
+  }
+
+  stop(): void {
+    if (this.watcher) {
+      void this.watcher.close();
+      this.watcher = null;
+    }
+  }
+}

package/src/modules/dashboard/services/sse-broadcaster.ts

@@ -0,0 +1,81 @@
+import type { Logger } from "pino";
+import type { EventBus, AADEvent, EventListener } from "../../../shared/events";
+
+export interface SSEClient {
+  send(data: string): void;
+  close(): void;
+}
+
+export class SSEBroadcaster {
+  private eventBus: EventBus;
+  private clients: Set<SSEClient> = new Set();
+  private listener: EventListener<AADEvent> | null = null;
+  private logger?: Logger;
+
+  constructor(eventBus: EventBus, logger?: Logger) {
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+
+  start(): void {
+    this.listener = (event: AADEvent) => {
+      this.broadcast(event);
+    };
+
+    this.eventBus.on("*", this.listener);
+  }
+
+  stop(): void {
+    if (this.listener) {
+      this.eventBus.off("*", this.listener);
+      this.listener = null;
+    }
+
+    // Close all clients
+    for (const client of this.clients) {
+      try {
+        client.close();
+      } catch (error) {
+        this.logger?.debug({ error }, "Failed to close SSE client during cleanup");
+      }
+    }
+
+    this.clients.clear();
+  }
+
+  addClient(client: SSEClient): void {
+    this.clients.add(client);
+  }
+
+  removeClient(client: SSEClient): void {
+    this.clients.delete(client);
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+
+  private broadcast(event: AADEvent): void {
+    const data = `data: ${JSON.stringify(event)}\n\n`;
+    const failedClients: SSEClient[] = [];
+
+    for (const client of this.clients) {
+      try {
+        client.send(data);
+      } catch (error) {
+        this.logger?.debug({ error, eventType: event.type }, "Failed to send SSE event to client");
+        failedClients.push(client);
+      }
+    }
+
+    // Remove failed clients
+    for (const client of failedClients) {
+      this.clients.delete(client);
+      try {
+        client.close();
+      } catch (error) {
+        this.logger?.debug({ error }, "Failed to close disconnected SSE client");
+      }
+    }
+  }
+}