@calltelemetry/openclaw-linear 0.8.2 → 0.8.4

package/src/infra/webhook-provision.test.ts

@@ -0,0 +1,162 @@
+/**
+ * webhook-provision.test.ts — Unit tests for webhook auto-provisioning.
+ *
+ * Tests getWebhookStatus() and provisionWebhook() with inline mock objects.
+ * No vi.mock needed — both functions accept linearApi as a parameter.
+ */
+import { describe, expect, it, vi } from "vitest";
+import {
+  getWebhookStatus,
+  provisionWebhook,
+  REQUIRED_RESOURCE_TYPES,
+  WEBHOOK_LABEL,
+} from "./webhook-provision.js";
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+const TEST_URL = "https://example.com/linear/webhook";
+
+function makeWebhook(overrides?: Record<string, unknown>) {
+  return {
+    id: "wh-1",
+    label: WEBHOOK_LABEL,
+    url: TEST_URL,
+    enabled: true,
+    resourceTypes: ["Comment", "Issue"],
+    allPublicTeams: true,
+    team: null,
+    createdAt: "2026-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeMockApi(overrides?: Record<string, unknown>) {
+  return {
+    listWebhooks: vi.fn().mockResolvedValue([]),
+    createWebhook: vi.fn().mockResolvedValue({ id: "new-wh", enabled: true }),
+    updateWebhook: vi.fn().mockResolvedValue(true),
+    deleteWebhook: vi.fn().mockResolvedValue(true),
+    ...overrides,
+  } as any;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe("REQUIRED_RESOURCE_TYPES", () => {
+  it("contains exactly Comment and Issue", () => {
+    expect([...REQUIRED_RESOURCE_TYPES]).toEqual(["Comment", "Issue"]);
+  });
+});
+
+describe("getWebhookStatus", () => {
+  it("returns null when no webhook matches URL", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([
+        makeWebhook({ url: "https://other.com/webhook" }),
+      ]),
+    });
+    const status = await getWebhookStatus(api, TEST_URL);
+    expect(status).toBeNull();
+  });
+
+  it("returns status with no issues when webhook is correctly configured", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([makeWebhook()]),
+    });
+    const status = await getWebhookStatus(api, TEST_URL);
+    expect(status).not.toBeNull();
+    expect(status!.id).toBe("wh-1");
+    expect(status!.issues).toEqual([]);
+  });
+
+  it("reports disabled webhook", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([
+        makeWebhook({ enabled: false }),
+      ]),
+    });
+    const status = await getWebhookStatus(api, TEST_URL);
+    expect(status!.issues).toContain("disabled");
+  });
+
+  it("reports missing event types", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([
+        makeWebhook({ resourceTypes: ["Comment"] }),
+      ]),
+    });
+    const status = await getWebhookStatus(api, TEST_URL);
+    expect(status!.issues.some((i) => i.includes("missing event type: Issue"))).toBe(true);
+  });
+
+  it("reports unnecessary event types", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([
+        makeWebhook({ resourceTypes: ["Comment", "Issue", "User"] }),
+      ]),
+    });
+    const status = await getWebhookStatus(api, TEST_URL);
+    expect(status!.issues.some((i) => i.includes("unnecessary event types: User"))).toBe(true);
+  });
+});
+
+describe("provisionWebhook", () => {
+  it("creates new webhook when none exists", async () => {
+    const api = makeMockApi();
+    const result = await provisionWebhook(api, TEST_URL);
+
+    expect(result.action).toBe("created");
+    expect(result.webhookId).toBe("new-wh");
+    expect(result.changes).toContain("created new webhook");
+    expect(api.createWebhook).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: TEST_URL,
+        resourceTypes: [...REQUIRED_RESOURCE_TYPES],
+        enabled: true,
+      }),
+    );
+  });
+
+  it("returns already_ok when webhook is correct", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([makeWebhook()]),
+    });
+    const result = await provisionWebhook(api, TEST_URL);
+
+    expect(result.action).toBe("already_ok");
+    expect(result.webhookId).toBe("wh-1");
+    expect(api.createWebhook).not.toHaveBeenCalled();
+    expect(api.updateWebhook).not.toHaveBeenCalled();
+  });
+
+  it("updates webhook to fix issues", async () => {
+    const api = makeMockApi({
+      listWebhooks: vi.fn().mockResolvedValue([
+        makeWebhook({
+          enabled: false,
+          resourceTypes: ["Comment", "Issue", "User", "Customer"],
+        }),
+      ]),
+    });
+    const result = await provisionWebhook(api, TEST_URL);
+
+    expect(result.action).toBe("updated");
+    expect(result.webhookId).toBe("wh-1");
+    expect(result.changes).toBeDefined();
+    expect(result.changes!.some((c) => c.includes("enabled"))).toBe(true);
+    expect(result.changes!.some((c) => c.includes("removed event types"))).toBe(true);
+    expect(api.updateWebhook).toHaveBeenCalledWith("wh-1", expect.objectContaining({
+      enabled: true,
+      resourceTypes: [...REQUIRED_RESOURCE_TYPES],
+    }));
+  });
+
+  it("passes teamId option to createWebhook", async () => {
+    const api = makeMockApi();
+    await provisionWebhook(api, TEST_URL, { teamId: "team-1" });
+
+    expect(api.createWebhook).toHaveBeenCalledWith(
+      expect.objectContaining({ teamId: "team-1" }),
+    );
+  });
+});

package/src/infra/webhook-provision.ts

@@ -0,0 +1,152 @@
+/**
+ * webhook-provision.ts — Auto-provision and validate Linear webhooks.
+ *
+ * Ensures the workspace webhook exists with the correct URL, event types,
+ * and enabled state. Can be run during onboarding, from the CLI, or as
+ * part of the doctor checks.
+ *
+ * Required event types:
+ *   - "Comment"  — user @mentions, follow-ups, feedback
+ *   - "Issue"    — assignment, state changes, triage
+ *
+ * Excluded (noise):
+ *   - "User", "Customer", "CustomerNeed" — never handled, generate log noise
+ */
+import { LinearAgentApi } from "../api/linear-api.js";
+
+// The exact set of resource types our webhook handler processes.
+export const REQUIRED_RESOURCE_TYPES = ["Comment", "Issue"] as const;
+
+export const WEBHOOK_LABEL = "OpenClaw Integration";
+
+export interface WebhookStatus {
+  id: string;
+  url: string;
+  enabled: boolean;
+  resourceTypes: string[];
+  label: string | null;
+  issues: string[];
+}
+
+export interface ProvisionResult {
+  action: "created" | "updated" | "already_ok";
+  webhookId: string;
+  changes?: string[];
+}
+
+/**
+ * Inspect all webhooks and find the one(s) matching our URL pattern.
+ */
+export async function getWebhookStatus(
+  linearApi: LinearAgentApi,
+  webhookUrl: string,
+): Promise<WebhookStatus | null> {
+  const webhooks = await linearApi.listWebhooks();
+  const ours = webhooks.find((w) => w.url === webhookUrl);
+  if (!ours) return null;
+
+  const issues: string[] = [];
+  if (!ours.enabled) issues.push("disabled");
+
+  const currentTypes = new Set(ours.resourceTypes);
+  const requiredTypes = new Set<string>(REQUIRED_RESOURCE_TYPES);
+
+  for (const t of requiredTypes) {
+    if (!currentTypes.has(t)) issues.push(`missing event type: ${t}`);
+  }
+
+  const noiseTypes = [...currentTypes].filter((t) => !requiredTypes.has(t));
+  if (noiseTypes.length > 0) {
+    issues.push(`unnecessary event types: ${noiseTypes.join(", ")}`);
+  }
+
+  return {
+    id: ours.id,
+    url: ours.url,
+    enabled: ours.enabled,
+    resourceTypes: ours.resourceTypes,
+    label: ours.label,
+    issues,
+  };
+}
+
+/**
+ * Provision (create or fix) the workspace webhook.
+ *
+ * - If no webhook with our URL exists → create one
+ * - If one exists but has wrong config → update it
+ * - If it's already correct → no-op
+ */
+export async function provisionWebhook(
+  linearApi: LinearAgentApi,
+  webhookUrl: string,
+  opts?: { teamId?: string; allPublicTeams?: boolean },
+): Promise<ProvisionResult> {
+  const status = await getWebhookStatus(linearApi, webhookUrl);
+
+  if (!status) {
+    // No webhook found — create one
+    const result = await linearApi.createWebhook({
+      url: webhookUrl,
+      resourceTypes: [...REQUIRED_RESOURCE_TYPES],
+      label: WEBHOOK_LABEL,
+      enabled: true,
+      teamId: opts?.teamId,
+      allPublicTeams: opts?.allPublicTeams ?? true,
+    });
+
+    return {
+      action: "created",
+      webhookId: result.id,
+      changes: ["created new webhook"],
+    };
+  }
+
+  // Webhook exists — check if it needs updates
+  if (status.issues.length === 0) {
+    return { action: "already_ok", webhookId: status.id };
+  }
+
+  // Build update payload
+  const update: {
+    resourceTypes?: string[];
+    enabled?: boolean;
+    label?: string;
+  } = {};
+  const changes: string[] = [];
+
+  // Fix resource types
+  const currentTypes = new Set(status.resourceTypes);
+  const requiredTypes = new Set<string>(REQUIRED_RESOURCE_TYPES);
+  const typesNeedUpdate =
+    [...requiredTypes].some((t) => !currentTypes.has(t)) ||
+    [...currentTypes].some((t) => !requiredTypes.has(t));
+
+  if (typesNeedUpdate) {
+    update.resourceTypes = [...REQUIRED_RESOURCE_TYPES];
+    const removed = [...currentTypes].filter((t) => !requiredTypes.has(t));
+    const added = [...requiredTypes].filter((t) => !currentTypes.has(t));
+    if (removed.length) changes.push(`removed event types: ${removed.join(", ")}`);
+    if (added.length) changes.push(`added event types: ${added.join(", ")}`);
+  }
+
+  // Fix enabled state
+  if (!status.enabled) {
+    update.enabled = true;
+    changes.push("enabled webhook");
+  }
+
+  // Fix label if missing
+  if (!status.label) {
+    update.label = WEBHOOK_LABEL;
+    changes.push("set label");
+  }
+
+  await linearApi.updateWebhook(status.id, update);
+
+  return {
+    action: "updated",
+    webhookId: status.id,
+    changes,
+  };
+}

package/src/pipeline/intent-classify.test.ts

@@ -195,6 +195,19 @@ describe("classifyIntent", () => {
     const call = runAgentMock.mock.calls[0][0];
     expect(call.message).not.toContain("x".repeat(501));
   });
+
+  it("parses close_issue intent from LLM response", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"close_issue","reasoning":"user wants to close the issue"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx({ commentBody: "close this" }));
+
+    expect(result.intent).toBe("close_issue");
+    expect(result.reasoning).toBe("user wants to close the issue");
+    expect(result.fromFallback).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -281,5 +294,35 @@ describe("regexFallback", () => {
       expect(result.intent).toBe("general");
       expect(result.fromFallback).toBe(true);
     });
+
+    it("detects close_issue for 'close this' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "close this issue",
+      }));
+      expect(result.intent).toBe("close_issue");
+      expect(result.fromFallback).toBe(true);
+    });
+
+    it("detects close_issue for 'mark as done' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "mark as done",
+      }));
+      expect(result.intent).toBe("close_issue");
+    });
+
+    it("detects close_issue for 'this is resolved' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "this is resolved",
+      }));
+      expect(result.intent).toBe("close_issue");
+    });
+
+    it("does NOT detect close_issue for ambiguous text", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "I think this might be resolved soon",
+        agentNames: [],
+      }));
+      expect(result.intent).toBe("general");
+    });
   });
 });

package/src/pipeline/intent-classify.ts

@@ -23,6 +23,7 @@ export type Intent =
   | "ask_agent"
   | "request_work"
   | "question"
+  | "close_issue"
   | "general";
 
 export interface IntentResult {
@@ -55,6 +56,7 @@ const VALID_INTENTS: Set<string> = new Set([
   "ask_agent",
   "request_work",
   "question",
+  "close_issue",
   "general",
 ]);
 
@@ -72,12 +74,14 @@ Intents:
 - ask_agent: user is addressing a specific agent by name
 - request_work: user wants something built, fixed, or implemented
 - question: user asking for information or help
+- close_issue: user wants to close/complete/resolve the issue (e.g. "close this", "mark as done", "resolved")
 - general: none of the above, automated messages, or noise
 
 Rules:
 - plan_start ONLY if the issue belongs to a project (hasProject=true)
 - If planning mode is active and no clear finalize/abandon intent, default to plan_continue
 - For ask_agent, set agentId to the matching name from Available agents
+- close_issue only for explicit closure requests, NOT ambiguous comments about resolution
 - One sentence reasoning`;
 
 // ---------------------------------------------------------------------------
@@ -188,6 +192,7 @@ function parseIntentResponse(raw: string, ctx: IntentContext): IntentResult | nu
 const PLAN_START_PATTERN = /\b(plan|planning)\s+(this\s+)(project|out)\b|\bplan\s+this\s+out\b/i;
 const FINALIZE_PATTERN = /\b(finalize\s+(the\s+)?plan\b|done\s+planning\b(?!\s+\w)|approve\s+(the\s+)?plan\b|plan\s+looks\s+good\b|ready\s+to\s+finalize\b|let'?s\s+finalize\b)/i;
 const ABANDON_PATTERN = /\b(abandon\s+plan(ning)?|cancel\s+plan(ning)?|stop\s+planning|exit\s+planning|quit\s+planning)\b/i;
+const CLOSE_ISSUE_PATTERN = /\b(close\s+(this|the\s+issue)|mark\s+(as\s+)?(done|completed?|resolved)|this\s+is\s+(done|resolved|completed?)|resolve\s+(this|the\s+issue))\b/i;
 
 export function regexFallback(ctx: IntentContext): IntentResult {
   const text = ctx.commentBody;
@@ -209,6 +214,11 @@ export function regexFallback(ctx: IntentContext): IntentResult {
     return { intent: "plan_start", reasoning: "regex: plan start pattern matched", fromFallback: true };
   }
 
+  // Close issue detection
+  if (CLOSE_ISSUE_PATTERN.test(text)) {
+    return { intent: "close_issue", reasoning: "regex: close issue pattern matched", fromFallback: true };
+  }
+
   // Agent name detection
   if (ctx.agentNames.length > 0) {
     const lower = text.toLowerCase();