@calltelemetry/openclaw-linear 0.5.2 → 0.6.0

package/src/agent/watchdog.ts

@@ -0,0 +1,176 @@
+/**
+ * watchdog.ts — I/O inactivity watchdog for agent sessions.
+ *
+ * Resets a countdown timer on every tick(). If no tick arrives within
+ * the inactivity threshold, fires onKill(). Also provides a config
+ * resolver that reads per-agent timeouts from agent-profiles.json.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Defaults (seconds — matches config units)
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_INACTIVITY_SEC = 120;     // 2 min
+export const DEFAULT_MAX_TOTAL_SEC = 7200;     // 2 hrs
+export const DEFAULT_TOOL_TIMEOUT_SEC = 600;   // 10 min
+
+// ---------------------------------------------------------------------------
+// Watchdog
+// ---------------------------------------------------------------------------
+
+export type WatchdogKillReason = "inactivity";
+
+export interface WatchdogOptions {
+  /** Inactivity threshold in ms. */
+  inactivityMs: number;
+  /** Label for logging (e.g. "embedded:zoe:session-123"). */
+  label: string;
+  /** Logger interface. */
+  logger: { info(msg: string): void; warn(msg: string): void };
+  /** Called when inactivity timeout fires. Must kill the process/abort. */
+  onKill: (reason: WatchdogKillReason) => void | Promise<void>;
+}
+
+export class InactivityWatchdog {
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly inactivityMs: number;
+  private readonly label: string;
+  private readonly logger: WatchdogOptions["logger"];
+  private readonly onKill: WatchdogOptions["onKill"];
+  private lastActivityAt: number = Date.now();
+  private killed = false;
+  private started = false;
+
+  constructor(opts: WatchdogOptions) {
+    this.inactivityMs = opts.inactivityMs;
+    this.label = opts.label;
+    this.logger = opts.logger;
+    this.onKill = opts.onKill;
+  }
+
+  /** Start the watchdog. Call after the process/run is launched. */
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+    this.lastActivityAt = Date.now();
+    this.scheduleCheck();
+    this.logger.info(`Watchdog started: ${this.label} (inactivity=${this.inactivityMs}ms)`);
+  }
+
+  /** Record an I/O activity tick. Resets the inactivity countdown. */
+  tick(): void {
+    this.lastActivityAt = Date.now();
+  }
+
+  /** Stop the watchdog (normal completion). */
+  stop(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.started = false;
+  }
+
+  /** Whether the watchdog triggered a kill. */
+  get wasKilled(): boolean {
+    return this.killed;
+  }
+
+  /** Milliseconds since last activity. */
+  get silenceMs(): number {
+    return Date.now() - this.lastActivityAt;
+  }
+
+  private scheduleCheck(): void {
+    const remaining = Math.max(1000, this.inactivityMs - (Date.now() - this.lastActivityAt));
+    this.timer = setTimeout(() => {
+      if (this.killed || !this.started) return;
+
+      const silence = Date.now() - this.lastActivityAt;
+      if (silence >= this.inactivityMs) {
+        this.killed = true;
+        this.logger.warn(
+          `Watchdog KILL: ${this.label} — no I/O for ${Math.round(silence / 1000)}s ` +
+          `(threshold: ${this.inactivityMs / 1000}s)`,
+        );
+        try {
+          const result = this.onKill("inactivity");
+          if (result && typeof (result as Promise<void>).catch === "function") {
+            (result as Promise<void>).catch((err) => {
+              this.logger.warn(`Watchdog onKill error: ${err}`);
+            });
+          }
+        } catch (err) {
+          this.logger.warn(`Watchdog onKill error: ${err}`);
+        }
+      } else {
+        // Activity happened during the wait — reschedule for remaining time
+        this.scheduleCheck();
+      }
+    }, remaining);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Config resolution
+// ---------------------------------------------------------------------------
+
+export interface WatchdogConfig {
+  inactivityMs: number;
+  maxTotalMs: number;
+  toolTimeoutMs: number;
+}
+
+interface AgentProfileWatchdog {
+  inactivitySec?: number;
+  maxTotalSec?: number;
+  toolTimeoutSec?: number;
+}
+
+const PROFILES_PATH = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+
+function loadProfileWatchdog(agentId: string): AgentProfileWatchdog | null {
+  try {
+    const raw = readFileSync(PROFILES_PATH, "utf8");
+    const profiles = JSON.parse(raw).agents ?? {};
+    return profiles[agentId]?.watchdog ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve watchdog config for an agent.
+ *
+ * Priority: agent-profiles.json → plugin config → hardcoded defaults.
+ * All config values are in seconds; output is in ms.
+ */
+export function resolveWatchdogConfig(
+  agentId: string,
+  pluginConfig?: Record<string, unknown>,
+): WatchdogConfig {
+  const profile = loadProfileWatchdog(agentId);
+
+  const inactivitySec =
+    profile?.inactivitySec ??
+    (pluginConfig?.inactivitySec as number | undefined) ??
+    DEFAULT_INACTIVITY_SEC;
+
+  const maxTotalSec =
+    profile?.maxTotalSec ??
+    (pluginConfig?.maxTotalSec as number | undefined) ??
+    DEFAULT_MAX_TOTAL_SEC;
+
+  const toolTimeoutSec =
+    profile?.toolTimeoutSec ??
+    (pluginConfig?.toolTimeoutSec as number | undefined) ??
+    DEFAULT_TOOL_TIMEOUT_SEC;
+
+  return {
+    inactivityMs: inactivitySec * 1000,
+    maxTotalMs: maxTotalSec * 1000,
+    toolTimeoutMs: toolTimeoutSec * 1000,
+  };
+}

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

@@ -9,10 +9,10 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { readFileSync as readFileSyncFs, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "./linear-api.js";
-import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "./auth.js";
+import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
+import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "../api/auth.js";
 import { listWorktrees } from "./codex-worktree.js";
-import { loadPrompts, clearPromptCache } from "./pipeline.js";
+import { loadPrompts, clearPromptCache } from "../pipeline/pipeline.js";
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -262,7 +262,7 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
           ? customPath.replace("~", process.env.HOME ?? "")
           : customPath;
       } else {
-        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
         resolvedPath = join(pluginRoot, "prompts.yaml");
       }
 
@@ -293,7 +293,7 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
           ? customPath.replace("~", process.env.HOME ?? "")
           : customPath;
       } else {
-        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
         resolvedPath = join(pluginRoot, "prompts.yaml");
       }
 

package/src/{codex-worktree.ts → infra/codex-worktree.ts}

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, statSync, readdirSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { ensureGitignore } from "./artifacts.js";
+import { ensureGitignore } from "../pipeline/artifacts.js";
 
 const DEFAULT_BASE_REPO = "/home/claw/ai-workspace";
 const DEFAULT_WORKTREE_BASE_DIR = path.join(homedir(), ".openclaw", "worktrees");

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);
+  });
+});