@calltelemetry/openclaw-linear 0.5.2 → 0.6.1

package/index.ts

@@ -1,15 +1,15 @@
 import { execFileSync } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { registerLinearProvider } from "./src/auth.js";
-import { registerCli } from "./src/cli.js";
-import { createLinearTools } from "./src/tools.js";
-import { handleLinearWebhook } from "./src/webhook.js";
-import { handleOAuthCallback } from "./src/oauth-callback.js";
-import { LinearAgentApi, resolveLinearToken } from "./src/linear-api.js";
-import { createDispatchService } from "./src/dispatch-service.js";
-import { readDispatchState, lookupSessionMapping, getActiveDispatch } from "./src/dispatch-state.js";
-import { triggerAudit, processVerdict, type HookContext } from "./src/pipeline.js";
-import { createDiscordNotifier, createNoopNotifier, type NotifyFn } from "./src/notify.js";
+import { registerLinearProvider } from "./src/api/auth.js";
+import { registerCli } from "./src/infra/cli.js";
+import { createLinearTools } from "./src/tools/tools.js";
+import { handleLinearWebhook } from "./src/pipeline/webhook.js";
+import { handleOAuthCallback } from "./src/api/oauth-callback.js";
+import { LinearAgentApi, resolveLinearToken } from "./src/api/linear-api.js";
+import { createDispatchService } from "./src/pipeline/dispatch-service.js";
+import { readDispatchState, lookupSessionMapping, getActiveDispatch } from "./src/pipeline/dispatch-state.js";
+import { triggerAudit, processVerdict, type HookContext } from "./src/pipeline/pipeline.js";
+import { createDiscordNotifier, createNoopNotifier, type NotifyFn } from "./src/infra/notify.js";
 
 export default function register(api: OpenClawPluginApi) {
   const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;

package/openclaw.plugin.json

@@ -22,7 +22,10 @@
       "dispatchStatePath": { "type": "string", "description": "Path to dispatch state JSON file (default: ~/.openclaw/linear-dispatch-state.json)" },
       "flowDiscordChannel": { "type": "string", "description": "Discord channel ID for dispatch lifecycle notifications (omit to disable)" },
       "promptsPath": { "type": "string", "description": "Override path for prompts.yaml (default: ships with plugin)" },
-      "maxReworkAttempts": { "type": "number", "description": "Max audit failures before escalation", "default": 2 }
+      "maxReworkAttempts": { "type": "number", "description": "Max audit failures before escalation", "default": 2 },
+      "inactivitySec": { "type": "number", "description": "Kill sessions with no I/O for this many seconds (default: 120)", "default": 120 },
+      "maxTotalSec": { "type": "number", "description": "Max total runtime for agent sessions in seconds (default: 7200)", "default": 7200 },
+      "toolTimeoutSec": { "type": "number", "description": "Max runtime for a single code_run CLI invocation in seconds (default: 600)", "default": 600 }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",
@@ -25,12 +25,19 @@
     "prompts.yaml",
     "README.md"
   ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
     "openclaw": "^2026.2.13",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "openclaw": {
     "extensions": [

package/src/agent/agent.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+// Mock dependencies so we can control runAgentOnce behavior
+const mockRunEmbedded = vi.fn();
+const mockRunSubprocess = vi.fn();
+const mockGetExtensionAPI = vi.fn();
+const mockResolveWatchdogConfig = vi.fn().mockReturnValue({
+  inactivityMs: 120_000,
+  maxTotalMs: 7_200_000,
+  toolTimeoutMs: 600_000,
+});
+
+vi.mock("./watchdog.js", () => ({
+  InactivityWatchdog: class {
+    wasKilled = false;
+    silenceMs = 0;
+    start() {}
+    tick() {}
+    stop() {}
+  },
+  resolveWatchdogConfig: (...args: any[]) => mockResolveWatchdogConfig(...args),
+}));
+
+// We need to test the runAgent retry wrapper. Since runAgentOnce is internal,
+// we test through runAgent by controlling the embedded/subprocess behavior.
+// The simplest approach: mock the entire module internals via the extension API.
+
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    readFileSync: vi.fn().mockReturnValue("{}"),
+    mkdirSync: vi.fn(),
+  };
+});
+
+import { runAgent } from "./agent.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+function createApi(): OpenClawPluginApi {
+  return {
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    },
+    runtime: {
+      config: {
+        loadConfig: vi.fn().mockReturnValue({ agents: { list: [] } }),
+      },
+      system: {
+        runCommandWithTimeout: vi.fn().mockResolvedValue({
+          code: 0,
+          stdout: JSON.stringify({ result: { payloads: [{ text: "subprocess output" }] } }),
+          stderr: "",
+        }),
+      },
+    },
+    pluginConfig: {},
+  } as unknown as OpenClawPluginApi;
+}
+
+describe("runAgent retry wrapper", () => {
+  it("returns success on first attempt when no watchdog kill", async () => {
+    const api = createApi();
+    // Mock subprocess fallback (no streaming → uses subprocess)
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: JSON.stringify({ result: { payloads: [{ text: "done" }] } }),
+      stderr: "",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain("done");
+    // Should only call once
+    expect((api.runtime.system as any).runCommandWithTimeout).toHaveBeenCalledOnce();
+  });
+
+  it("returns failure without retry on normal (non-watchdog) failure", async () => {
+    const api = createApi();
+    (api.runtime.system as any).runCommandWithTimeout = vi.fn().mockResolvedValue({
+      code: 1,
+      stdout: "",
+      stderr: "some error",
+    });
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.watchdogKilled).toBeUndefined();
+    // Only one attempt — no retry for non-watchdog failures
+    expect((api.runtime.system as any).runCommandWithTimeout).toHaveBeenCalledOnce();
+  });
+
+  it("does not retry on success", async () => {
+    const api = createApi();
+    const runCmd = vi.fn().mockResolvedValue({
+      code: 0,
+      stdout: JSON.stringify({ result: { payloads: [{ text: "all good" }] } }),
+      stderr: "",
+    });
+    (api.runtime.system as any).runCommandWithTimeout = runCmd;
+
+    const result = await runAgent({
+      api,
+      agentId: "test-agent",
+      sessionId: "session-1",
+      message: "do something",
+    });
+
+    expect(result.success).toBe(true);
+    expect(runCmd).toHaveBeenCalledOnce();
+  });
+});

package/src/{agent.ts → agent/agent.ts}

@@ -2,7 +2,8 @@ import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { mkdirSync, readFileSync } from "node:fs";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type { LinearAgentApi, ActivityContent } from "./linear-api.js";
+import type { LinearAgentApi, ActivityContent } from "../api/linear-api.js";
+import { InactivityWatchdog, resolveWatchdogConfig } from "./watchdog.js";
 
 // ---------------------------------------------------------------------------
 // Agent directory resolution (config-based, not ext API which ignores agentId)
@@ -46,6 +47,7 @@ async function getExtensionAPI() {
 export interface AgentRunResult {
   success: boolean;
   output: string;
+  watchdogKilled?: boolean;
 }
 
 export interface AgentStreamCallbacks {
@@ -54,8 +56,10 @@ export interface AgentStreamCallbacks {
 }
 
 /**
- * Run an agent using the embedded runner with streaming callbacks.
- * Falls back to subprocess if the embedded runner is unavailable.
+ * Run an agent with automatic retry on watchdog kill.
+ *
+ * Tries embedded runner first (if streaming callbacks provided), falls back
+ * to subprocess. If the inactivity watchdog kills the run, retries once.
  */
 export async function runAgent(params: {
   api: OpenClawPluginApi;
@@ -65,14 +69,54 @@ export async function runAgent(params: {
   timeoutMs?: number;
   streaming?: AgentStreamCallbacks;
 }): Promise<AgentRunResult> {
-  const { api, agentId, sessionId, message, timeoutMs = 5 * 60_000, streaming } = params;
+  const maxAttempts = 2;
 
-  api.logger.info(`Dispatching agent ${agentId} for session ${sessionId}`);
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const result = await runAgentOnce(params);
+
+    if (result.success || !result.watchdogKilled || attempt === maxAttempts - 1) {
+      return result;
+    }
+
+    params.api.logger.warn(
+      `Agent ${params.agentId} killed by watchdog, retrying (attempt ${attempt + 1}/${maxAttempts})`,
+    );
+
+    // Emit Linear activity about the retry if streaming
+    if (params.streaming) {
+      params.streaming.linearApi.emitActivity(params.streaming.agentSessionId, {
+        type: "error",
+        body: `Agent killed by inactivity watchdog — no I/O for the configured threshold. Retrying...`,
+      }).catch(() => {});
+    }
+  }
+
+  // Unreachable, but TypeScript needs it
+  return { success: false, output: "Watchdog retry exhausted" };
+}
+
+/**
+ * Single attempt to run an agent (no retry logic).
+ */
+async function runAgentOnce(params: {
+  api: OpenClawPluginApi;
+  agentId: string;
+  sessionId: string;
+  message: string;
+  timeoutMs?: number;
+  streaming?: AgentStreamCallbacks;
+}): Promise<AgentRunResult> {
+  const { api, agentId, sessionId, message, streaming } = params;
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const wdConfig = resolveWatchdogConfig(agentId, pluginConfig);
+  const timeoutMs = params.timeoutMs ?? wdConfig.maxTotalMs;
+
+  api.logger.info(`Dispatching agent ${agentId} for session ${sessionId} (timeout=${Math.round(timeoutMs / 1000)}s, inactivity=${Math.round(wdConfig.inactivityMs / 1000)}s)`);
 
   // Try embedded runner first (has streaming callbacks)
   if (streaming) {
     try {
-      return await runEmbedded(api, agentId, sessionId, message, timeoutMs, streaming);
+      return await runEmbedded(api, agentId, sessionId, message, timeoutMs, streaming, wdConfig.inactivityMs);
     } catch (err) {
       api.logger.warn(`Embedded runner failed, falling back to subprocess: ${err}`);
     }
@@ -83,7 +127,7 @@ export async function runAgent(params: {
 }
 
 /**
- * Embedded agent runner with real-time streaming to Linear.
+ * Embedded agent runner with real-time streaming to Linear and inactivity watchdog.
  */
 async function runEmbedded(
   api: OpenClawPluginApi,
@@ -92,6 +136,7 @@ async function runEmbedded(
   message: string,
   timeoutMs: number,
   streaming: AgentStreamCallbacks,
+  inactivityMs: number,
 ): Promise<AgentRunResult> {
   const ext = await getExtensionAPI();
 
@@ -131,9 +176,23 @@ async function runEmbedded(
     });
   };
 
+  // --- Inactivity watchdog ---
+  const controller = new AbortController();
+  const watchdog = new InactivityWatchdog({
+    inactivityMs,
+    label: `embedded:${agentId}:${sessionId}`,
+    logger: api.logger,
+    onKill: () => {
+      controller.abort();
+      try { ext.abortEmbeddedPiRun(sessionId); } catch {}
+    },
+  });
+
   // Track last emitted tool to avoid duplicates
   let lastToolAction = "";
 
+  watchdog.start();
+
   const result = await ext.runEmbeddedPiAgent({
     sessionId,
     sessionFile,
@@ -146,11 +205,13 @@ async function runEmbedded(
     config,
     provider,
     model,
+    abortSignal: controller.signal,
     shouldEmitToolResult: () => true,
     shouldEmitToolOutput: () => true,
 
     // Stream reasoning/thinking to Linear
     onReasoningStream: (payload) => {
+      watchdog.tick();
       const text = payload.text?.trim();
       if (text && text.length > 10) {
         emit({ type: "thought", body: text.slice(0, 500) });
@@ -159,6 +220,7 @@ async function runEmbedded(
 
     // Stream tool results to Linear
     onToolResult: (payload) => {
+      watchdog.tick();
       const text = payload.text?.trim();
       if (text) {
         // Truncate tool results for activity display
@@ -169,6 +231,7 @@ async function runEmbedded(
 
     // Raw agent events — capture tool starts/ends
     onAgentEvent: (evt) => {
+      watchdog.tick();
       const { stream, data } = evt;
 
       if (stream !== "tool") return;
@@ -191,11 +254,14 @@ async function runEmbedded(
 
     // Partial assistant text (for long responses)
     onPartialReply: (payload) => {
+      watchdog.tick();
       // We don't emit every partial chunk to avoid flooding Linear
       // The final response will be posted as a comment
     },
   });
 
+  watchdog.stop();
+
   // Extract output text from payloads
   const payloads = result.payloads ?? [];
   const outputText = payloads
@@ -203,6 +269,17 @@ async function runEmbedded(
     .filter(Boolean)
     .join("\n\n");
 
+  // Check if watchdog killed the run
+  if (watchdog.wasKilled) {
+    const silenceSec = Math.round(watchdog.silenceMs / 1000);
+    api.logger.warn(`Embedded agent killed by watchdog: agent=${agentId} session=${sessionId} silence=${silenceSec}s`);
+    return {
+      success: false,
+      output: outputText || `Agent killed by inactivity watchdog after ${silenceSec}s of silence.`,
+      watchdogKilled: true,
+    };
+  }
+
   if (result.meta?.error) {
     api.logger.error(`Embedded agent error: ${result.meta.error.kind}: ${result.meta.error.message}`);
     return { success: false, output: outputText || result.meta.error.message };

package/src/agent/watchdog.test.ts

@@ -0,0 +1,266 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Hoist the mock for readFileSync so resolveWatchdogConfig tests can control it
+const { mockReadFileSync } = vi.hoisted(() => ({
+  mockReadFileSync: vi.fn(),
+}));
+
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    readFileSync: (...args: any[]) => mockReadFileSync(...args),
+  };
+});
+
+import { InactivityWatchdog, resolveWatchdogConfig, DEFAULT_INACTIVITY_SEC, DEFAULT_MAX_TOTAL_SEC, DEFAULT_TOOL_TIMEOUT_SEC } from "./watchdog.js";
+
+// ---------------------------------------------------------------------------
+// InactivityWatchdog
+// ---------------------------------------------------------------------------
+
+describe("InactivityWatchdog", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  const makeLogger = () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+  });
+
+  it("fires onKill after inactivity threshold", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 5_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    vi.advanceTimersByTime(6_000);
+
+    expect(onKill).toHaveBeenCalledOnce();
+    expect(onKill).toHaveBeenCalledWith("inactivity");
+    expect(wd.wasKilled).toBe(true);
+
+    wd.stop();
+  });
+
+  it("tick() resets the timer", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 5_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    vi.advanceTimersByTime(4_000);
+    expect(onKill).not.toHaveBeenCalled();
+
+    wd.tick(); // reset at 4s
+
+    vi.advanceTimersByTime(4_000); // now at 8s total, 4s since tick
+    expect(onKill).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(2_000); // now 6s since tick → should fire
+    expect(onKill).toHaveBeenCalledOnce();
+
+    wd.stop();
+  });
+
+  it("stop() prevents kill", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 5_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    vi.advanceTimersByTime(2_000);
+    wd.stop();
+
+    vi.advanceTimersByTime(10_000);
+    expect(onKill).not.toHaveBeenCalled();
+    expect(wd.wasKilled).toBe(false);
+  });
+
+  it("wasKilled is true after kill", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 2_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    expect(wd.wasKilled).toBe(false);
+
+    vi.advanceTimersByTime(3_000);
+    expect(wd.wasKilled).toBe(true);
+
+    wd.stop();
+  });
+
+  it("silenceMs tracks time since last activity", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 60_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    vi.advanceTimersByTime(3_000);
+
+    // silenceMs should be roughly 3000 (fake timers keep Date.now in sync)
+    expect(wd.silenceMs).toBeGreaterThanOrEqual(3_000);
+
+    wd.tick();
+    expect(wd.silenceMs).toBeLessThan(100); // just ticked
+
+    wd.stop();
+  });
+
+  it("start() is idempotent", () => {
+    const onKill = vi.fn();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 5_000,
+      label: "test",
+      logger: makeLogger(),
+      onKill,
+    });
+
+    wd.start();
+    wd.start(); // second call should be no-op
+    wd.start(); // third call
+
+    vi.advanceTimersByTime(6_000);
+    // Should only fire once, not multiple times from duplicate timers
+    expect(onKill).toHaveBeenCalledOnce();
+
+    wd.stop();
+  });
+
+  it("handles async onKill errors gracefully", () => {
+    const onKill = vi.fn().mockRejectedValue(new Error("kill failed"));
+    const logger = makeLogger();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 2_000,
+      label: "test",
+      logger,
+      onKill,
+    });
+
+    wd.start();
+    vi.advanceTimersByTime(3_000);
+
+    expect(onKill).toHaveBeenCalledOnce();
+    expect(wd.wasKilled).toBe(true);
+    // Error is caught and logged, not thrown
+    expect(logger.warn).toHaveBeenCalled();
+
+    wd.stop();
+  });
+
+  it("handles sync onKill errors gracefully", () => {
+    const onKill = vi.fn().mockImplementation(() => {
+      throw new Error("sync kill error");
+    });
+    const logger = makeLogger();
+    const wd = new InactivityWatchdog({
+      inactivityMs: 2_000,
+      label: "test",
+      logger,
+      onKill,
+    });
+
+    wd.start();
+    // Should not throw
+    vi.advanceTimersByTime(3_000);
+
+    expect(onKill).toHaveBeenCalledOnce();
+    expect(wd.wasKilled).toBe(true);
+    expect(logger.warn).toHaveBeenCalled();
+
+    wd.stop();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveWatchdogConfig
+// ---------------------------------------------------------------------------
+
+describe("resolveWatchdogConfig", () => {
+  afterEach(() => {
+    mockReadFileSync.mockReset();
+  });
+
+  it("reads from agent-profiles.json", () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      agents: {
+        zoe: {
+          watchdog: { inactivitySec: 180, maxTotalSec: 7200, toolTimeoutSec: 900 },
+        },
+      },
+    }));
+
+    const config = resolveWatchdogConfig("zoe");
+    expect(config.inactivityMs).toBe(180_000);
+    expect(config.maxTotalMs).toBe(7_200_000);
+    expect(config.toolTimeoutMs).toBe(900_000);
+  });
+
+  it("falls back to plugin config when agent profile not found", () => {
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error("file not found");
+    });
+
+    const config = resolveWatchdogConfig("unknown-agent", {
+      inactivitySec: 60,
+      maxTotalSec: 3600,
+      toolTimeoutSec: 300,
+    });
+
+    expect(config.inactivityMs).toBe(60_000);
+    expect(config.maxTotalMs).toBe(3_600_000);
+    expect(config.toolTimeoutMs).toBe(300_000);
+  });
+
+  it("falls back to defaults when no config available", () => {
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error("file not found");
+    });
+
+    const config = resolveWatchdogConfig("nonexistent");
+    expect(config.inactivityMs).toBe(DEFAULT_INACTIVITY_SEC * 1000);
+    expect(config.maxTotalMs).toBe(DEFAULT_MAX_TOTAL_SEC * 1000);
+    expect(config.toolTimeoutMs).toBe(DEFAULT_TOOL_TIMEOUT_SEC * 1000);
+  });
+
+  it("converts seconds to ms", () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({
+      agents: {
+        mal: {
+          watchdog: { inactivitySec: 60, maxTotalSec: 600, toolTimeoutSec: 300 },
+        },
+      },
+    }));
+
+    const config = resolveWatchdogConfig("mal");
+    expect(config.inactivityMs).toBe(60 * 1000);
+    expect(config.maxTotalMs).toBe(600 * 1000);
+    expect(config.toolTimeoutMs).toBe(300 * 1000);
+  });
+});