@calltelemetry/openclaw-linear 0.5.2 → 0.6.1

package/src/infra/notify.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  createNoopNotifier,
+  createDiscordNotifier,
+  type NotifyPayload,
+} from "./notify.js";
+
+// ---------------------------------------------------------------------------
+// Noop notifier
+// ---------------------------------------------------------------------------
+
+describe("createNoopNotifier", () => {
+  it("returns function that resolves without error", async () => {
+    const notify = createNoopNotifier();
+    await expect(notify("dispatch", {
+      identifier: "API-1",
+      title: "test",
+      status: "dispatched",
+    })).resolves.toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Discord notifier
+// ---------------------------------------------------------------------------
+
+describe("createDiscordNotifier", () => {
+  const botToken = "test-bot-token";
+  const channelId = "123456";
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function stubFetch(): { getCalls: () => { url: string; body: any }[] } {
+    const calls: { url: string; body: any }[] = [];
+    vi.stubGlobal("fetch", vi.fn(async (url: string, opts: any) => {
+      calls.push({ url, body: JSON.parse(opts.body) });
+      return { ok: true, status: 200 } as Response;
+    }));
+    return { getCalls: () => calls };
+  }
+
+  const basePayload: NotifyPayload = {
+    identifier: "API-42",
+    title: "Fix auth",
+    status: "dispatched",
+  };
+
+  it("formats dispatch message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("dispatch", basePayload);
+    expect(getCalls()).toHaveLength(1);
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("**API-42**");
+    expect(msg).toContain("dispatched");
+    expect(msg).toContain("Fix auth");
+  });
+
+  it("formats working message with attempt", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("working", { ...basePayload, status: "working", attempt: 1 });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("worker started");
+    expect(msg).toContain("attempt 1");
+  });
+
+  it("formats audit_pass message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("audit_pass", { ...basePayload, status: "done", verdict: { pass: true } });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("passed audit");
+    expect(msg).toContain("PR ready");
+  });
+
+  it("formats audit_fail message with gaps", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("audit_fail", {
+      ...basePayload,
+      status: "working",
+      attempt: 1,
+      verdict: { pass: false, gaps: ["no tests", "missing validation"] },
+    });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("failed audit");
+    expect(msg).toContain("no tests");
+    expect(msg).toContain("missing validation");
+  });
+
+  it("formats escalation message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("escalation", {
+      ...basePayload,
+      status: "stuck",
+      reason: "audit failed 3x",
+    });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("needs human review");
+    expect(msg).toContain("audit failed 3x");
+  });
+
+  it("formats watchdog_kill message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("watchdog_kill", {
+      ...basePayload,
+      status: "stuck",
+      attempt: 0,
+      reason: "no I/O for 120s",
+    });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("killed by watchdog");
+    expect(msg).toContain("no I/O for 120s");
+    expect(msg).toContain("attempt 0");
+  });
+
+  it("handles fetch failure gracefully", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => {
+      throw new Error("network error");
+    }));
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const notify = createDiscordNotifier(botToken, channelId);
+    // Should not throw
+    await expect(notify("dispatch", basePayload)).resolves.toBeUndefined();
+    consoleSpy.mockRestore();
+  });
+
+  it("sends to correct Discord API URL", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("dispatch", basePayload);
+    expect(getCalls()[0].url).toContain(`/channels/${channelId}/messages`);
+  });
+
+  it("formats auditing message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("auditing", { ...basePayload, status: "auditing" });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("audit in progress");
+  });
+
+  it("formats stuck message", async () => {
+    const { getCalls } = stubFetch();
+    const notify = createDiscordNotifier(botToken, channelId);
+    await notify("stuck", { ...basePayload, status: "stuck", reason: "stale 2h" });
+    const msg = getCalls()[0].body.content;
+    expect(msg).toContain("stuck");
+    expect(msg).toContain("stale 2h");
+  });
+
+  it("handles non-ok response gracefully", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => ({
+      ok: false,
+      status: 429,
+      text: async () => "rate limited",
+    })));
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const notify = createDiscordNotifier(botToken, channelId);
+    await expect(notify("dispatch", basePayload)).resolves.toBeUndefined();
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+});

package/src/{notify.ts → infra/notify.ts}

@@ -17,7 +17,8 @@ export type NotifyKind =
   | "audit_pass"     // audit passed → done
   | "audit_fail"     // audit failed → rework
   | "escalation"     // 2x fail or stale → stuck
-  | "stuck";         // stale detection
+  | "stuck"          // stale detection
+  | "watchdog_kill"; // agent killed by inactivity watchdog
 
 export interface NotifyPayload {
   identifier: string;
@@ -55,6 +56,10 @@ function formatDiscordMessage(kind: NotifyKind, payload: NotifyPayload): string
       return `🚨 ${prefix} needs human review — ${payload.reason ?? "audit failed 2x"}`;
     case "stuck":
       return `⏰ ${prefix} stuck — ${payload.reason ?? "stale 2h"}`;
+    case "watchdog_kill":
+      return `⚡ ${prefix} killed by watchdog (${payload.reason ?? "no I/O for 120s"}). ${
+        payload.attempt != null ? `Retrying (attempt ${payload.attempt}).` : "Will retry."
+      }`;
     default:
       return `${prefix} — ${kind}: ${payload.status}`;
   }

package/src/pipeline/active-session.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  setActiveSession,
+  clearActiveSession,
+  getActiveSession,
+  getActiveSessionByIdentifier,
+  getCurrentSession,
+  getSessionCount,
+  hydrateFromDispatchState,
+  type ActiveSession,
+} from "./active-session.js";
+
+function makeSession(overrides?: Partial<ActiveSession>): ActiveSession {
+  return {
+    agentSessionId: "sess-1",
+    issueIdentifier: "API-100",
+    issueId: "uuid-1",
+    startedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+// Clean up after each test to avoid cross-contamination
+afterEach(() => {
+  // Clear all known sessions
+  clearActiveSession("uuid-1");
+  clearActiveSession("uuid-2");
+  clearActiveSession("uuid-3");
+});
+
+describe("set + get", () => {
+  it("round-trip by issueId", () => {
+    const session = makeSession();
+    setActiveSession(session);
+    const found = getActiveSession("uuid-1");
+    expect(found).not.toBeNull();
+    expect(found!.issueIdentifier).toBe("API-100");
+    expect(found!.agentSessionId).toBe("sess-1");
+  });
+
+  it("returns null for unknown issueId", () => {
+    expect(getActiveSession("no-such-id")).toBeNull();
+  });
+});
+
+describe("clearActiveSession", () => {
+  it("removes session", () => {
+    setActiveSession(makeSession());
+    clearActiveSession("uuid-1");
+    expect(getActiveSession("uuid-1")).toBeNull();
+  });
+});
+
+describe("getActiveSessionByIdentifier", () => {
+  it("finds by identifier string", () => {
+    setActiveSession(makeSession({ issueIdentifier: "API-200", issueId: "uuid-2" }));
+    const found = getActiveSessionByIdentifier("API-200");
+    expect(found).not.toBeNull();
+    expect(found!.issueId).toBe("uuid-2");
+  });
+
+  it("returns null for unknown identifier", () => {
+    expect(getActiveSessionByIdentifier("NOPE-999")).toBeNull();
+  });
+});
+
+describe("getCurrentSession", () => {
+  it("returns session when exactly 1", () => {
+    setActiveSession(makeSession());
+    const current = getCurrentSession();
+    expect(current).not.toBeNull();
+    expect(current!.issueId).toBe("uuid-1");
+  });
+
+  it("returns null when 0 sessions", () => {
+    expect(getCurrentSession()).toBeNull();
+  });
+
+  it("returns null when >1 sessions", () => {
+    setActiveSession(makeSession({ issueId: "uuid-1" }));
+    setActiveSession(makeSession({ issueId: "uuid-2", issueIdentifier: "API-200" }));
+    expect(getCurrentSession()).toBeNull();
+  });
+});
+
+describe("getSessionCount", () => {
+  it("reflects current count", () => {
+    expect(getSessionCount()).toBe(0);
+    setActiveSession(makeSession());
+    expect(getSessionCount()).toBe(1);
+    setActiveSession(makeSession({ issueId: "uuid-2", issueIdentifier: "API-200" }));
+    expect(getSessionCount()).toBe(2);
+    clearActiveSession("uuid-1");
+    expect(getSessionCount()).toBe(1);
+  });
+});
+
+describe("hydrateFromDispatchState", () => {
+  it("restores working dispatches from state file", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-hydrate-"));
+    const statePath = join(dir, "state.json");
+    writeFileSync(statePath, JSON.stringify({
+      dispatches: {
+        active: {
+          "API-300": {
+            issueId: "uuid-300",
+            issueIdentifier: "API-300",
+            worktreePath: "/tmp/wt/API-300",
+            branch: "codex/API-300",
+            tier: "junior",
+            model: "test",
+            status: "working",
+            dispatchedAt: "2026-01-01T00:00:00Z",
+            attempt: 0,
+          },
+          "API-301": {
+            issueId: "uuid-301",
+            issueIdentifier: "API-301",
+            worktreePath: "/tmp/wt/API-301",
+            branch: "codex/API-301",
+            tier: "junior",
+            model: "test",
+            status: "done",
+            dispatchedAt: "2026-01-01T00:00:00Z",
+            attempt: 1,
+          },
+        },
+        completed: {},
+      },
+      sessionMap: {},
+      processedEvents: [],
+    }), "utf-8");
+
+    const restored = await hydrateFromDispatchState(statePath);
+    // Only "working" and "dispatched" are restored, not "done"
+    expect(restored).toBe(1);
+    expect(getActiveSession("uuid-300")).not.toBeNull();
+    expect(getActiveSession("uuid-300")!.issueIdentifier).toBe("API-300");
+    expect(getActiveSession("uuid-301")).toBeNull();
+
+    // Cleanup
+    clearActiveSession("uuid-300");
+  });
+
+  it("returns 0 when no active dispatches", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-hydrate-"));
+    const statePath = join(dir, "state.json");
+    const restored = await hydrateFromDispatchState(statePath);
+    expect(restored).toBe(0);
+  });
+});