@ronkovic/aad 0.3.0

package/src/modules/cli/shutdown.ts

@@ -0,0 +1,122 @@
+/**
+ * Shutdown Manager
+ * LIFO順でshutdownハンドラを実行し、二重shutdown防止、シグナルハンドリングを提供
+ */
+
+import type { Logger } from "pino";
+
+export type ShutdownHandler = () => Promise<void>;
+
+export interface ShutdownManager {
+  /**
+   * shutdownハンドラを登録 (LIFO順で実行される)
+   * @param name ハンドラの識別名
+   * @param handler 非同期shutdown処理
+   */
+  register(name: string, handler: ShutdownHandler): void;
+
+  /**
+   * 登録された全ハンドラをLIFO順で実行
+   * 二重呼び出しは無視される
+   */
+  onShutdown(): Promise<void>;
+
+  /**
+   * SIGINT/SIGTERMシグナルハンドラをインストール
+   * シグナル受信時にonShutdown()を呼び出す
+   */
+  installSignalHandlers(): void;
+}
+
+interface HandlerEntry {
+  name: string;
+  handler: ShutdownHandler;
+}
+
+export class ShutdownManagerImpl implements ShutdownManager {
+  private handlers: HandlerEntry[] = [];
+  private isShuttingDown = false;
+  private hasShutdown = false;
+
+  constructor(private logger: Logger) {}
+
+  register(name: string, handler: ShutdownHandler): void {
+    if (this.hasShutdown) {
+      this.logger.warn({ name }, "Cannot register handler after shutdown");
+      return;
+    }
+
+    this.handlers.push({ name, handler });
+    this.logger.debug({ name, total: this.handlers.length }, "Shutdown handler registered");
+  }
+
+  async onShutdown(): Promise<void> {
+    // 二重shutdown防止
+    if (this.isShuttingDown || this.hasShutdown) {
+      this.logger.debug("Shutdown already in progress or completed, ignoring");
+      return;
+    }
+
+    this.isShuttingDown = true;
+    this.logger.info({ handlerCount: this.handlers.length }, "Starting shutdown sequence");
+
+    const errors: Array<{ name: string; error: unknown }> = [];
+
+    // LIFO順で実行 (最後に登録されたものから実行)
+    for (let i = this.handlers.length - 1; i >= 0; i--) {
+      const entry = this.handlers[i];
+      if (!entry) continue;
+
+      try {
+        this.logger.info({ name: entry.name }, `Executing shutdown handler: ${entry.name}`);
+        await entry.handler();
+        this.logger.debug({ name: entry.name }, `Shutdown handler completed: ${entry.name}`);
+      } catch (error) {
+        this.logger.error({ name: entry.name, error }, `Shutdown handler failed: ${entry.name}`);
+        errors.push({ name: entry.name, error });
+        // エラーが発生しても残りのハンドラを実行
+      }
+    }
+
+    this.hasShutdown = true;
+    this.isShuttingDown = false;
+
+    if (errors.length > 0) {
+      this.logger.error({ errors, total: errors.length }, "Shutdown completed with errors");
+      // 最初のエラーをthrow
+      const firstError = errors[0];
+      throw new Error(
+        `Shutdown handler "${firstError!.name}" failed: ${
+          firstError!.error instanceof Error ? firstError!.error.message : String(firstError!.error)
+        }`
+      );
+    }
+
+    this.logger.info("Shutdown sequence completed successfully");
+  }
+
+  installSignalHandlers(): void {
+    const handleSignal = (signal: string): void => {
+      this.logger.info({ signal }, `Received ${signal} signal`);
+      void this.onShutdown().then(() => {
+        this.logger.info({ signal }, `Shutdown complete, exiting with code 0`);
+        process.exit(0);
+      }).catch((error) => {
+        this.logger.error({ signal, error }, `Shutdown failed, exiting with code 1`);
+        process.exit(1);
+      });
+    };
+
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+
+    this.logger.debug("Signal handlers installed (SIGINT, SIGTERM)");
+  }
+}
+
+/**
+ * ShutdownManagerインスタンスを作成
+ */
+export function createShutdownManager(logger: Logger): ShutdownManager {
+  return new ShutdownManagerImpl(logger);
+}

package/src/modules/dashboard/__tests__/api-routes.test.ts

@@ -0,0 +1,204 @@
+import { describe, test, expect, mock } from "bun:test";
+import { Hono } from "hono";
+import { createAPIRoutes } from "../routes/api";
+import type { StateAggregator } from "../services/state-aggregator";
+import { createTaskId } from "../../../shared/types";
+
+// Mock StateAggregator
+function createMockAggregator(): StateAggregator {
+  return {
+    getProgress: mock(() => ({
+      progress: {
+        total: 10,
+        pending: 2,
+        running: 3,
+        completed: 4,
+        failed: 1,
+      },
+      percentComplete: 40,
+    })),
+    getTasks: mock(() => ({
+      tasks: [
+        {
+          id: createTaskId("task-1"),
+          status: "completed" as const,
+          dependsOn: [],
+        },
+        {
+          id: createTaskId("task-2"),
+          status: "running" as const,
+          dependsOn: [createTaskId("task-1")],
+        },
+      ],
+      total: 2,
+    })),
+    getTaskLogs: mock((taskId) => [
+      {
+        level: "info",
+        service: "task-execution",
+        message: `Log for ${taskId}`,
+        timestamp: Date.now(),
+        taskId: taskId as string,
+      },
+    ]),
+    getWorkers: mock(() => ({
+      stats: {
+        total: 4,
+        idle: 1,
+        busy: 3,
+      },
+      workers: [
+        { id: "worker-1" as any, status: "busy" as const },
+        { id: "worker-2" as any, status: "idle" as const },
+      ],
+    })),
+    getGraph: mock(() => ({
+      nodes: [
+        { id: "task-1", status: "completed" },
+        { id: "task-2", status: "running" },
+      ],
+      edges: [{ from: "task-1", to: "task-2" }],
+    })),
+    getTimeline: mock(() => ({
+      tasks: [
+        {
+          id: "task-1",
+          status: "completed",
+          startTime: Date.now() - 10000,
+          endTime: Date.now() - 5000,
+        },
+      ],
+    })),
+    queryLogs: mock(() => [
+      {
+        level: "error",
+        service: "planning",
+        message: "Test error",
+        timestamp: Date.now(),
+      },
+    ]),
+  } as any;
+}
+
+describe("API Routes", () => {
+  test("GET /api/progress returns progress data", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/progress");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(data.progress.total).toBe(10);
+    expect(data.percentComplete).toBe(40);
+  });
+
+  test("GET /api/tasks returns tasks array", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/tasks");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(data.tasks).toHaveLength(2);
+    expect(data.total).toBe(2);
+  });
+
+  test("GET /api/tasks/:id/logs returns task-specific logs", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/tasks/task-1/logs");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(Array.isArray(data)).toBe(true);
+    expect(data[0].message).toContain("task-1");
+  });
+
+  test("GET /api/workers returns worker stats and list", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/workers");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(data.stats.total).toBe(4);
+    expect(data.workers).toHaveLength(2);
+  });
+
+  test("GET /api/graph returns dependency graph", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/graph");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(data.nodes).toHaveLength(2);
+    expect(data.edges).toHaveLength(1);
+  });
+
+  test("GET /api/timeline returns task timeline", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/timeline");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(data.tasks).toHaveLength(1);
+    expect(data.tasks[0].status).toBe("completed");
+  });
+
+  test("GET /api/logs returns filtered logs", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/logs");
+    expect(res.status).toBe(200);
+
+    const data = (await res.json()) as any;
+    expect(Array.isArray(data)).toBe(true);
+    expect(data[0].level).toBe("error");
+  });
+
+  test("GET /api/logs with query params applies filters", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    const res = await app.request("/api/logs?level=error&limit=50");
+    expect(res.status).toBe(200);
+
+    // Verify queryLogs was called
+    expect(aggregator.queryLogs).toHaveBeenCalled();
+  });
+
+  test("GET /api/logs validates query parameters", async () => {
+    const aggregator = createMockAggregator();
+    const app = new Hono();
+    app.route("/", createAPIRoutes(aggregator));
+
+    // Valid limit
+    const res1 = await app.request("/api/logs?limit=100");
+    expect(res1.status).toBe(200);
+
+    // Invalid limit (negative)
+    const res2 = await app.request("/api/logs?limit=-10");
+    expect(res2.status).toBe(400);
+
+    // Invalid limit (non-numeric)
+    const res3 = await app.request("/api/logs?limit=abc");
+    expect(res3.status).toBe(400);
+  });
+});

package/src/modules/dashboard/__tests__/file-watcher.test.ts

@@ -0,0 +1,34 @@
+import { describe, test, expect } from "bun:test";
+import { FileWatcher } from "../services/file-watcher";
+import { EventBus } from "../../../shared/events";
+
+describe("FileWatcher", () => {
+  test("constructor does not throw", () => {
+    const eventBus = new EventBus();
+    const watcher = new FileWatcher(eventBus, "/tmp/test-watch");
+
+    expect(watcher).toBeDefined();
+  });
+
+  test("start initializes watcher", () => {
+    const eventBus = new EventBus();
+    const watcher = new FileWatcher(eventBus, "/tmp/test-watch");
+
+    expect(() => watcher.start()).not.toThrow();
+  });
+
+  test("stop closes watcher", () => {
+    const eventBus = new EventBus();
+    const watcher = new FileWatcher(eventBus, "/tmp/test-watch");
+
+    watcher.start();
+    expect(() => watcher.stop()).not.toThrow();
+  });
+
+  test("stop without start is safe", () => {
+    const eventBus = new EventBus();
+    const watcher = new FileWatcher(eventBus, "/tmp/test-watch");
+
+    expect(() => watcher.stop()).not.toThrow();
+  });
+});

package/src/modules/dashboard/__tests__/server.test.ts

@@ -0,0 +1,120 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { DashboardServer } from "../server";
+import { EventBus } from "../../../shared/events";
+import { LogStore } from "../../logging/log-store";
+
+// Mock dependencies
+class MockTaskStore {
+  getAll() {
+    return [];
+  }
+  get() {
+    return undefined;
+  }
+}
+
+class MockProcessManager {
+  getStats() {
+    return { total: 0, idle: 0, busy: 0 };
+  }
+  getWorkers() {
+    return [];
+  }
+}
+
+describe("DashboardServer", () => {
+  let server: DashboardServer;
+  let eventBus: EventBus;
+  let logStore: LogStore;
+  let taskStore: MockTaskStore;
+  let processManager: MockProcessManager;
+  const testPort = 13333 + Math.floor(Math.random() * 1000); // Random port to avoid conflicts
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+    logStore = new LogStore();
+    taskStore = new MockTaskStore();
+    processManager = new MockProcessManager();
+
+    server = new DashboardServer({
+      eventBus,
+      logStore,
+      taskStore: taskStore as any,
+      processManager: processManager as any,
+      port: testPort,
+      host: "localhost",
+    });
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  test("constructor does not throw", () => {
+    expect(server).toBeDefined();
+  });
+
+  test("start initializes HTTP server", async () => {
+    await server.start();
+
+    // Verify server is listening by making a request
+    const res = await fetch(`http://localhost:${testPort}/api/progress`);
+    expect(res.ok).toBe(true);
+  });
+
+  test("GET / returns HTML page", async () => {
+    await server.start();
+
+    const res = await fetch(`http://localhost:${testPort}/`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toContain("text/html");
+
+    const html = await res.text();
+    expect(html).toContain("<html");
+    expect(html).toContain("AAD Dashboard");
+  });
+
+  test("GET /api/progress returns JSON", async () => {
+    await server.start();
+
+    const res = await fetch(`http://localhost:${testPort}/api/progress`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toContain("application/json");
+
+    const data = (await res.json()) as any;
+    expect(data.progress).toBeDefined();
+    expect(data.percentComplete).toBeDefined();
+  });
+
+  test("stop closes HTTP server", async () => {
+    await server.start();
+
+    // Server is listening
+    const res1 = await fetch(`http://localhost:${testPort}/api/progress`);
+    expect(res1.ok).toBe(true);
+
+    await server.stop();
+
+    // Server should no longer respond
+    try {
+      await fetch(`http://localhost:${testPort}/api/progress`);
+      expect.unreachable("Server should be stopped");
+    } catch (error) {
+      // Expected: connection refused or similar error
+      expect(error).toBeDefined();
+    }
+  });
+
+  test("multiple start calls are safe", async () => {
+    await server.start();
+    await server.start(); // Should not throw
+
+    const res = await fetch(`http://localhost:${testPort}/api/progress`);
+    expect(res.ok).toBe(true);
+  });
+
+  test("stop without start is safe", async () => {
+    await server.stop(); // Should not throw
+    expect(true).toBe(true);
+  });
+});

package/src/modules/dashboard/__tests__/sse-broadcaster.test.ts

@@ -0,0 +1,163 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import { SSEBroadcaster } from "../services/sse-broadcaster";
+import { EventBus, type AADEvent } from "../../../shared/events";
+
+describe("SSEBroadcaster", () => {
+  let eventBus: EventBus;
+  let broadcaster: SSEBroadcaster;
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+    broadcaster = new SSEBroadcaster(eventBus);
+  });
+
+  test("start subscribes to EventBus wildcard", () => {
+    const onSpy = mock(() => {});
+    eventBus.on = onSpy;
+
+    broadcaster.start();
+
+    expect(onSpy).toHaveBeenCalledWith("*", expect.any(Function));
+  });
+
+  test("addClient increases client count", () => {
+    const mockClient = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.addClient(mockClient);
+    expect(broadcaster.getClientCount()).toBe(1);
+
+    broadcaster.addClient({
+      send: mock(() => {}),
+      close: mock(() => {}),
+    });
+    expect(broadcaster.getClientCount()).toBe(2);
+  });
+
+  test("removeClient decreases client count", () => {
+    const mockClient = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.addClient(mockClient);
+    expect(broadcaster.getClientCount()).toBe(1);
+
+    broadcaster.removeClient(mockClient);
+    expect(broadcaster.getClientCount()).toBe(0);
+  });
+
+  test("EventBus emit triggers send on all clients", () => {
+    const client1 = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+    const client2 = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.start();
+    broadcaster.addClient(client1);
+    broadcaster.addClient(client2);
+
+    const event: AADEvent = {
+      type: "task:dispatched",
+      taskId: "task-1" as any,
+      workerId: "worker-1" as any,
+    };
+
+    eventBus.emit(event);
+
+    expect(client1.send).toHaveBeenCalledTimes(1);
+    expect(client1.send).toHaveBeenCalledWith(expect.stringContaining("task:dispatched"));
+    expect(client2.send).toHaveBeenCalledTimes(1);
+    expect(client2.send).toHaveBeenCalledWith(expect.stringContaining("task:dispatched"));
+  });
+
+  test("send error removes failing client automatically", () => {
+    const failingClient = {
+      send: mock(() => {
+        throw new Error("Connection closed");
+      }),
+      close: mock(() => {}),
+    };
+    const goodClient = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.start();
+    broadcaster.addClient(failingClient);
+    broadcaster.addClient(goodClient);
+
+    expect(broadcaster.getClientCount()).toBe(2);
+
+    const event: AADEvent = {
+      type: "worker:idle",
+      workerId: "worker-1" as any,
+    };
+
+    eventBus.emit(event);
+
+    // Failing client should be removed
+    expect(broadcaster.getClientCount()).toBe(1);
+    expect(goodClient.send).toHaveBeenCalledTimes(1);
+  });
+
+  test("stop closes all clients and unsubscribes", () => {
+    const client1 = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+    const client2 = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.start();
+    broadcaster.addClient(client1);
+    broadcaster.addClient(client2);
+
+    broadcaster.stop();
+
+    expect(client1.close).toHaveBeenCalledTimes(1);
+    expect(client2.close).toHaveBeenCalledTimes(1);
+    expect(broadcaster.getClientCount()).toBe(0);
+
+    // EventBus should not trigger sends after stop
+    const event: AADEvent = {
+      type: "run:completed",
+      runId: "run-1" as any,
+    };
+
+    eventBus.emit(event);
+    expect(client1.send).toHaveBeenCalledTimes(0);
+  });
+
+  test("handles multiple events to same clients", () => {
+    const client = {
+      send: mock(() => {}),
+      close: mock(() => {}),
+    };
+
+    broadcaster.start();
+    broadcaster.addClient(client);
+
+    eventBus.emit({
+      type: "task:dispatched",
+      taskId: "task-1" as any,
+      workerId: "worker-1" as any,
+    });
+
+    eventBus.emit({
+      type: "task:completed",
+      taskId: "task-1" as any,
+      result: { success: true } as any,
+    });
+
+    expect(client.send).toHaveBeenCalledTimes(2);
+  });
+});

package/src/modules/dashboard/__tests__/sse-routes.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect, mock } from "bun:test";
+import { Hono } from "hono";
+import { createSSERoutes } from "../routes/sse";
+import type { SSEBroadcaster, SSEClient } from "../services/sse-broadcaster";
+
+// Mock SSEBroadcaster
+function createMockBroadcaster(): SSEBroadcaster {
+  return {
+    start: mock(() => {}),
+    stop: mock(() => {}),
+    addClient: mock(() => {}),
+    removeClient: mock(() => {}),
+    getClientCount: mock(() => 0),
+  } as any;
+}
+
+describe("SSE Routes", () => {
+  test("GET /events/all returns 200 with SSE content type", async () => {
+    const broadcaster = createMockBroadcaster();
+    const app = new Hono();
+    app.route("/", createSSERoutes(broadcaster));
+
+    const res = await app.request("/events/all");
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toContain("text/event-stream");
+  });
+
+  test("GET /events/all calls addClient on broadcaster", async () => {
+    const broadcaster = createMockBroadcaster();
+    const app = new Hono();
+    app.route("/", createSSERoutes(broadcaster));
+
+    await app.request("/events/all");
+
+    expect(broadcaster.addClient).toHaveBeenCalled();
+  });
+
+  test("SSE route registers client with send and close methods", async () => {
+    const broadcaster = createMockBroadcaster();
+    let capturedClient: SSEClient | undefined;
+
+    broadcaster.addClient = mock((client: SSEClient) => {
+      capturedClient = client;
+    }) as any;
+
+    const app = new Hono();
+    app.route("/", createSSERoutes(broadcaster));
+
+    await app.request("/events/all");
+
+    expect(capturedClient).toBeDefined();
+    if (capturedClient !== undefined) {
+      expect(typeof capturedClient.send).toBe("function");
+      expect(typeof capturedClient.close).toBe("function");
+    }
+  });
+});