@m8i-51/shoal 0.1.19 → 0.1.21

package/server/__tests__/runs.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("fs");
+
+import * as fs from "fs";
+import { listRuns, getReportPath } from "../runs";
+import type { RunLog, Finding } from "../../framework/types";
+
+function mockRunLog(overrides: Partial<RunLog> = {}): RunLog {
+  return {
+    runId: "run_1",
+    startedAt: "2026-01-01T00:00:00.000Z",
+    completedAt: "2026-01-01T00:05:00.000Z",
+    repo: "test",
+    agents: [],
+    summary: {
+      totalAgents: 0,
+      completed: 0,
+      errors: 0,
+      iterationLimitReached: 0,
+      totalActions: 0,
+      totalIssuesPosted: 0,
+      regressionChecked: 0,
+      regressionFailed: 0,
+      rateLimitRetries: 0,
+      cost: { inputTokens: 0, outputTokens: 0, estimatedUSD: null },
+    },
+    ...overrides,
+  };
+}
+
+function mockFinding(overrides: Partial<Finding> = {}): Finding {
+  return {
+    id: "f1",
+    runId: "run_1",
+    agentId: "a1",
+    agentName: "Alice",
+    role: "tester",
+    title: "title",
+    body: "body",
+    category: "bug",
+    timestamp: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.mocked(fs.existsSync).mockReturnValue(false);
+  vi.mocked(fs.readdirSync).mockReturnValue([] as unknown as ReturnType<typeof fs.readdirSync>);
+  vi.mocked(fs.readFileSync).mockReturnValue("{}" as unknown as ReturnType<typeof fs.readFileSync>);
+});
+
+describe("listRuns", () => {
+  it("logs ディレクトリがない → 空配列", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    expect(listRuns()).toEqual([]);
+  });
+
+  it("running_*.json から実行中の run を isLive:true で返す", () => {
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue(["running_run_live.json"] as unknown as ReturnType<typeof fs.readdirSync>);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ runId: "run_live", startedAt: "2026-06-01T00:00:00.000Z" }) as unknown as ReturnType<typeof fs.readFileSync>
+    );
+    const result = listRuns();
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({ runId: "run_live", status: "running", isLive: true });
+  });
+
+  it("report_ プレフィックスのファイルは run ログとして扱わない", () => {
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue(["report_run_1.html"] as unknown as ReturnType<typeof fs.readdirSync>);
+    expect(listRuns()).toEqual([]);
+  });
+
+  it("通常の run ログを完了状態のサマリーに変換する", () => {
+    const log = mockRunLog({
+      runId: "run_done",
+      agents: [
+        { agentType: "explorer", agentId: "a1", agentName: "A", role: "r", startedAt: "", completedAt: null, status: "completed", iterations: 1, actions: [], visitedPaths: [], issuesPosted: [], regressionChecks: [], error: null },
+        { agentType: "explorer", agentId: "a2", agentName: "B", role: "r", startedAt: "", completedAt: null, status: "error", iterations: 1, actions: [], visitedPaths: [], issuesPosted: [], regressionChecks: [], error: "x" },
+      ],
+    });
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue(["2026-01-01T00-00-00_run_done.json"] as unknown as ReturnType<typeof fs.readdirSync>);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(log) as unknown as ReturnType<typeof fs.readFileSync>);
+
+    const result = listRuns();
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      runId: "run_done",
+      status: "completed",
+      agentCount: 2,
+      completedAgents: 1,
+      errorAgents: 1,
+      hasReport: false,
+    });
+  });
+
+  it("findings/run_id/ 内の finding を category 別に集計する（triage_result.json は除外）", () => {
+    const log = mockRunLog({ runId: "run_with_findings" });
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => {
+      const s = String(p);
+      return s.endsWith("logs") || s.endsWith("findings/run_with_findings") || s.includes("findings") && s.endsWith("run_with_findings");
+    });
+    vi.mocked(fs.readdirSync).mockImplementation((p: unknown) => {
+      const s = String(p);
+      if (s.endsWith("logs")) return ["2026-01-01T00-00-00_run_with_findings.json"] as unknown as ReturnType<typeof fs.readdirSync>;
+      return ["f0.json", "f1.json", "triage_result.json"] as unknown as ReturnType<typeof fs.readdirSync>;
+    });
+    vi.mocked(fs.readFileSync).mockImplementation((p: unknown) => {
+      const s = String(p);
+      if (s.endsWith("f0.json")) return JSON.stringify(mockFinding({ id: "f0", category: "bug" })) as unknown as ReturnType<typeof fs.readFileSync>;
+      if (s.endsWith("f1.json")) return JSON.stringify(mockFinding({ id: "f1", category: "ux" })) as unknown as ReturnType<typeof fs.readFileSync>;
+      if (s.endsWith("triage_result.json")) {
+        return JSON.stringify({ runId: "run_with_findings", completedAt: "x", issued: [], skipped: [], unprocessed: [] }) as unknown as ReturnType<typeof fs.readFileSync>;
+      }
+      return JSON.stringify(log) as unknown as ReturnType<typeof fs.readFileSync>;
+    });
+
+    const result = listRuns();
+    expect(result).toHaveLength(1);
+    expect(result[0].findingCount).toBe(2);
+    expect(result[0].findingsByCategory).toEqual({ bug: 1, ux: 1 });
+  });
+
+  it("同じ runId が複数ファイルに登場しても重複しない", () => {
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "running_run_dup.json",
+      "2026-01-01T00-00-00_run_dup.json",
+    ] as unknown as ReturnType<typeof fs.readdirSync>);
+    vi.mocked(fs.readFileSync).mockImplementation((p: unknown) => {
+      const s = String(p);
+      if (s.includes("running_run_dup")) {
+        return JSON.stringify({ runId: "run_dup", startedAt: "2026-01-01T00:00:00.000Z" }) as unknown as ReturnType<typeof fs.readFileSync>;
+      }
+      return JSON.stringify(mockRunLog({ runId: "run_dup" })) as unknown as ReturnType<typeof fs.readFileSync>;
+    });
+
+    const result = listRuns();
+    expect(result).toHaveLength(1);
+    expect(result[0].isLive).toBe(true);
+  });
+
+  it("startedAt の降順でソートされる", () => {
+    const older = mockRunLog({ runId: "run_old", startedAt: "2026-01-01T00:00:00.000Z" });
+    const newer = mockRunLog({ runId: "run_new", startedAt: "2026-06-01T00:00:00.000Z" });
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "2026-01-01T00-00-00_run_old.json",
+      "2026-06-01T00-00-00_run_new.json",
+    ] as unknown as ReturnType<typeof fs.readdirSync>);
+    vi.mocked(fs.readFileSync).mockImplementation((p: unknown) => {
+      const s = String(p);
+      if (s.includes("run_old")) return JSON.stringify(older) as unknown as ReturnType<typeof fs.readFileSync>;
+      return JSON.stringify(newer) as unknown as ReturnType<typeof fs.readFileSync>;
+    });
+
+    const result = listRuns();
+    expect(result.map((r) => r.runId)).toEqual(["run_new", "run_old"]);
+  });
+
+  it("壊れた JSON の run ログはスキップする", () => {
+    vi.mocked(fs.existsSync).mockImplementation((p: unknown) => String(p).endsWith("logs"));
+    vi.mocked(fs.readdirSync).mockReturnValue(["2026-01-01T00-00-00_run_broken.json"] as unknown as ReturnType<typeof fs.readdirSync>);
+    vi.mocked(fs.readFileSync).mockReturnValue("not json" as unknown as ReturnType<typeof fs.readFileSync>);
+    expect(listRuns()).toEqual([]);
+  });
+});
+
+describe("getReportPath", () => {
+  it("不正な runId → null", () => {
+    expect(getReportPath("bad-id")).toBeNull();
+  });
+
+  it("report ファイルが存在しない → null", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    expect(getReportPath("run_123")).toBeNull();
+  });
+
+  it("report ファイルが存在する → パスを返す", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    expect(getReportPath("run_123")).toMatch(/report_run_123\.html$/);
+  });
+});

package/server/__tests__/scheduler.test.ts

@@ -83,15 +83,17 @@ describe("scheduler — 時刻判定ロジック", () => {
   it("スケジュール時刻に一致したとき spawnRun を呼ぶ", async () => {
     vi.useFakeTimers();
 
-    // 月曜 09:00 に固定（UTC = ローカルとして扱う）
+    // 月曜 09:00 に固定。scheduler は new Date().getDay() などローカル時刻を使うため、
+    // テスト設定も同じメソッドで一致させる（環境のタイムゾーンに依存するが両者が整合する）
     const monday9am = new Date("2026-05-11T09:00:00.000Z");
     vi.setSystemTime(monday9am);
+    const now = new Date();
 
     const config: ScheduleConfig = {
       enabled: true,
-      dayOfWeek: monday9am.getDay(),
-      hour: monday9am.getHours(),
-      minute: monday9am.getMinutes(),
+      dayOfWeek: now.getDay(),
+      hour: now.getHours(),
+      minute: now.getMinutes(),
       lastRunDate: null,
     };
     vi.mocked(fs.existsSync).mockReturnValue(true);
@@ -111,13 +113,14 @@ describe("scheduler — 時刻判定ロジック", () => {
 
     const monday9am = new Date("2026-05-11T09:00:00.000Z");
     vi.setSystemTime(monday9am);
-    const today = monday9am.toISOString().slice(0, 10);
+    const now = new Date();
+    const today = now.toISOString().slice(0, 10); // scheduler と同じ UTC 日付を使う
 
     const config: ScheduleConfig = {
       enabled: true,
-      dayOfWeek: monday9am.getDay(),
-      hour: monday9am.getHours(),
-      minute: monday9am.getMinutes(),
+      dayOfWeek: now.getDay(),
+      hour: now.getHours(),
+      minute: now.getMinutes(),
       lastRunDate: today,
     };
     vi.mocked(fs.existsSync).mockReturnValue(true);

package/server/index.ts

@@ -8,6 +8,7 @@ import { listRuns, getReportPath } from "./runs.js";
 import { activeSessions, spawnRun, cancelSession } from "./runner.js";
 import { loadSchedule, saveSchedule, startScheduler, type ScheduleConfig } from "./scheduler.js";
 import { generateDiary, getDiaryPath } from "../framework/diary.js";
+import { findCrossRunDuplicates } from "../framework/cross-run-dedup.js";
 import type { Finding } from "../framework/types.js";
 
 function specFilePath(baseUrl: string): string {
@@ -141,9 +142,10 @@ function loadAllFindings(): (Finding & { runId: string })[] {
     const dir = join(base, runDir);
     try {
       for (const file of readdirSync(dir)) {
-        if (!file.endsWith(".json")) continue;
+        if (!file.endsWith(".json") || file === "triage_result.json") continue;
         try {
           const f: Finding = JSON.parse(readFileSync(join(dir, file), "utf-8"));
+          if (typeof f.timestamp !== "string") continue;
           all.push({ ...f, runId: runDir });
         } catch { /* skip */ }
       }
@@ -156,6 +158,10 @@ app.get("/api/findings", (_req, res) => {
   res.json(loadAllFindings());
 });
 
+app.get("/api/findings/cross-run-duplicates", (_req, res) => {
+  res.json(findCrossRunDuplicates(loadAllFindings()));
+});
+
 app.get("/api/findings/export", (_req, res) => {
   const findings = loadAllFindings().map(({ id, title, body, category, agentName, role, timestamp, runId }) => ({
     id, title, body, category, agentName, role, timestamp, runId,
@@ -174,7 +180,8 @@ app.post("/api/findings/proxy-url", async (req, res) => {
     parsed = new URL(url);
     if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("invalid protocol");
     const h = parsed.hostname;
-    if (h === "localhost" || h === "127.0.0.1" || h === "::1" || h.startsWith("192.168.") || h.startsWith("10.") || h.endsWith(".local")) {
+    const bare = h.replace(/^\[|\]$/g, ""); // IPv6 brackets: [::1] → ::1
+    if (bare === "localhost" || bare === "127.0.0.1" || bare === "::1" || bare.startsWith("192.168.") || bare.startsWith("10.") || bare.endsWith(".local")) {
       res.status(400).json({ error: "private urls not allowed" });
       return;
     }
@@ -320,6 +327,27 @@ app.get("/api/runs/:runId/log", (req, res) => {
   res.status(404).json({ error: "no log found" });
 });
 
+// ----------------------------------------------------------------
+// API: schedule config
+// ----------------------------------------------------------------
+app.get("/api/schedule", (_req, res) => {
+  res.json(loadSchedule());
+});
+
+app.patch("/api/schedule", (req, res) => {
+  const current = loadSchedule();
+  const { enabled, dayOfWeek, hour, minute } = req.body as Partial<ScheduleConfig>;
+  const updated: ScheduleConfig = {
+    ...current,
+    ...(enabled != null ? { enabled: Boolean(enabled) } : {}),
+    ...(dayOfWeek != null && Number.isInteger(dayOfWeek) && dayOfWeek >= 0 && dayOfWeek <= 6 ? { dayOfWeek } : {}),
+    ...(hour != null && Number.isInteger(hour) && hour >= 0 && hour <= 23 ? { hour } : {}),
+    ...(minute != null && Number.isInteger(minute) && minute >= 0 && minute <= 59 ? { minute } : {}),
+  };
+  saveSchedule(updated);
+  res.json(updated);
+});
+
 // ----------------------------------------------------------------
 // Static: serve built React app
 // ----------------------------------------------------------------
@@ -351,28 +379,11 @@ process.on("unhandledRejection", (reason) => {
   console.error("[server] unhandledRejection:", reason);
 });
 
-// ----------------------------------------------------------------
-// API: schedule config
-// ----------------------------------------------------------------
-app.get("/api/schedule", (_req, res) => {
-  res.json(loadSchedule());
-});
+export { app };
 
-app.patch("/api/schedule", (req, res) => {
-  const current = loadSchedule();
-  const { enabled, dayOfWeek, hour, minute } = req.body as Partial<ScheduleConfig>;
-  const updated: ScheduleConfig = {
-    ...current,
-    ...(enabled != null ? { enabled: Boolean(enabled) } : {}),
-    ...(dayOfWeek != null && Number.isInteger(dayOfWeek) && dayOfWeek >= 0 && dayOfWeek <= 6 ? { dayOfWeek } : {}),
-    ...(hour != null && Number.isInteger(hour) && hour >= 0 && hour <= 23 ? { hour } : {}),
-    ...(minute != null && Number.isInteger(minute) && minute >= 0 && minute <= 59 ? { minute } : {}),
-  };
-  saveSchedule(updated);
-  res.json(updated);
-});
-
-app.listen(PORT, () => {
-  console.log(`\nshoal dashboard → http://localhost:${PORT}\n`);
-  startScheduler();
-});
+if (process.env.NODE_ENV !== "test") {
+  app.listen(PORT, () => {
+    console.log(`\nshoal dashboard → http://localhost:${PORT}\n`);
+    startScheduler();
+  });
+}

package/server/runs.ts

@@ -25,9 +25,10 @@ function countFindings(runId: string): { total: number; byCategory: Record<strin
   const byCategory: Record<string, number> = {};
   let total = 0;
   for (const file of fs.readdirSync(dir)) {
-    if (!file.endsWith(".json")) continue;
+    if (!file.endsWith(".json") || file === "triage_result.json") continue;
     try {
       const f: Finding = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+      if (typeof f.category !== "string") continue;
       byCategory[f.category] = (byCategory[f.category] ?? 0) + 1;
       total++;
     } catch {