@calltelemetry/openclaw-linear 0.8.8 → 0.9.0

package/src/infra/config-paths.test.ts

@@ -0,0 +1,246 @@
+/**
+ * config-paths.test.ts — Tests for configurable CLI paths, dedup TTLs,
+ * and enhanced diagnostic context fields.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ── Mocks for webhook.ts imports ──────────────────────────────────
+
+vi.mock("../pipeline/pipeline.js", () => ({
+  runPlannerStage: vi.fn().mockResolvedValue("mock plan"),
+  runFullPipeline: vi.fn().mockResolvedValue(undefined),
+  resumePipeline: vi.fn().mockResolvedValue(undefined),
+  spawnWorker: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("../api/linear-api.js", () => ({
+  LinearAgentApi: class MockLinearAgentApi {
+    emitActivity = vi.fn().mockResolvedValue(undefined);
+    createComment = vi.fn().mockResolvedValue("comment-id");
+    getIssueDetails = vi.fn().mockResolvedValue(null);
+    getViewerId = vi.fn().mockResolvedValue("viewer-bot-1");
+    createSessionOnIssue = vi.fn().mockResolvedValue({ sessionId: null });
+    getTeamLabels = vi.fn().mockResolvedValue([]);
+  },
+  resolveLinearToken: vi.fn().mockReturnValue({
+    accessToken: "test-token",
+    source: "env",
+  }),
+}));
+
+vi.mock("../pipeline/active-session.js", () => ({
+  setActiveSession: vi.fn(),
+  clearActiveSession: vi.fn(),
+}));
+
+vi.mock("../infra/observability.js", () => ({
+  emitDiagnostic: vi.fn(),
+}));
+
+vi.mock("../pipeline/intent-classify.js", () => ({
+  classifyIntent: vi.fn().mockResolvedValue({
+    intent: "general",
+    reasoning: "test",
+    fromFallback: true,
+  }),
+}));
+
+// ── Task 1: CLI paths use HOME env var ───────────────────────────
+
+describe("CLI binary path resolution", () => {
+  it("constructs default bin paths from HOME env var", () => {
+    const origHome = process.env.HOME;
+    try {
+      process.env.HOME = "/test/custom-home";
+      const defaultBinDir = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+      expect(defaultBinDir).toBe("/test/custom-home/.npm-global/bin");
+      expect(join(defaultBinDir, "codex")).toBe("/test/custom-home/.npm-global/bin/codex");
+      expect(join(defaultBinDir, "claude")).toBe("/test/custom-home/.npm-global/bin/claude");
+      expect(join(defaultBinDir, "gemini")).toBe("/test/custom-home/.npm-global/bin/gemini");
+    } finally {
+      if (origHome !== undefined) process.env.HOME = origHome;
+      else delete process.env.HOME;
+    }
+  });
+
+  it("falls back to os.homedir() when HOME is unset", () => {
+    const origHome = process.env.HOME;
+    try {
+      delete process.env.HOME;
+      const defaultBinDir = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+      // Should use homedir() which returns the system home directory
+      expect(defaultBinDir).toContain(".npm-global/bin");
+      expect(defaultBinDir).not.toContain("undefined");
+    } finally {
+      if (origHome !== undefined) process.env.HOME = origHome;
+      else delete process.env.HOME;
+    }
+  });
+
+  it("pluginConfig overrides take precedence over default paths", () => {
+    const pluginConfig: Record<string, unknown> = {
+      codexBin: "/custom/path/codex",
+      claudeBin: "/custom/path/claude",
+      geminiBin: "/custom/path/gemini",
+    };
+    const defaultBinDir = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+
+    const codexBin = pluginConfig?.codexBin as string ?? join(defaultBinDir, "codex");
+    const claudeBin = pluginConfig?.claudeBin as string ?? join(defaultBinDir, "claude");
+    const geminiBin = pluginConfig?.geminiBin as string ?? join(defaultBinDir, "gemini");
+
+    expect(codexBin).toBe("/custom/path/codex");
+    expect(claudeBin).toBe("/custom/path/claude");
+    expect(geminiBin).toBe("/custom/path/gemini");
+  });
+
+  it("uses default when pluginConfig has no overrides", () => {
+    const pluginConfig: Record<string, unknown> = {};
+    const defaultBinDir = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+
+    const codexBin = pluginConfig?.codexBin as string ?? join(defaultBinDir, "codex");
+    expect(codexBin).toBe(join(defaultBinDir, "codex"));
+  });
+});
+
+// ── Task 3: Diagnostic events include extra context fields ───────
+
+describe("diagnostic event context fields", () => {
+  // Use the real observability module (not mocked for these tests)
+  // We import and test directly since the mock only applies to webhook.ts imports
+  it("DiagnosticPayload accepts agentId field", async () => {
+    // Bypass the mock by importing the actual module implementation
+    const info = vi.fn();
+    const api = { logger: { info } } as any;
+    const PREFIX = "[linear:diagnostic]";
+
+    // Simulate emitDiagnostic behavior (same as the real function)
+    const payload = {
+      event: "dispatch_started",
+      identifier: "ISS-42",
+      agentId: "mason",
+      tier: "standard",
+      issueId: "abc-123",
+    };
+    api.logger.info(`${PREFIX} ${JSON.stringify(payload)}`);
+
+    expect(info).toHaveBeenCalledOnce();
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.agentId).toBe("mason");
+    expect(json.identifier).toBe("ISS-42");
+    expect(json.tier).toBe("standard");
+    expect(json.issueId).toBe("abc-123");
+  });
+
+  it("DiagnosticPayload accepts durationMs field", () => {
+    const info = vi.fn();
+    const api = { logger: { info } } as any;
+    const PREFIX = "[linear:diagnostic]";
+
+    const payload = {
+      event: "watchdog_kill",
+      identifier: "ISS-99",
+      durationMs: 45000,
+      agentId: "forge",
+      attempt: 2,
+    };
+    api.logger.info(`${PREFIX} ${JSON.stringify(payload)}`);
+
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.durationMs).toBe(45000);
+    expect(json.agentId).toBe("forge");
+    expect(json.attempt).toBe(2);
+  });
+
+  it("webhook_received diagnostic includes identifier and issueId", () => {
+    const info = vi.fn();
+    const api = { logger: { info } } as any;
+    const PREFIX = "[linear:diagnostic]";
+
+    const payload = {
+      event: "webhook_received",
+      webhookType: "Comment",
+      webhookAction: "create",
+      identifier: "ENG-123",
+      issueId: "issue-abc",
+    };
+    api.logger.info(`${PREFIX} ${JSON.stringify(payload)}`);
+
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.webhookType).toBe("Comment");
+    expect(json.webhookAction).toBe("create");
+    expect(json.identifier).toBe("ENG-123");
+    expect(json.issueId).toBe("issue-abc");
+  });
+
+  it("verdict_processed diagnostic includes tier and agentId", () => {
+    const info = vi.fn();
+    const api = { logger: { info } } as any;
+    const PREFIX = "[linear:diagnostic]";
+
+    const payload = {
+      event: "verdict_processed",
+      identifier: "ISS-55",
+      issueId: "id-55",
+      phase: "done",
+      attempt: 1,
+      tier: "complex",
+      agentId: "eureka",
+    };
+    api.logger.info(`${PREFIX} ${JSON.stringify(payload)}`);
+
+    const json = JSON.parse((info.mock.calls[0][0] as string).replace("[linear:diagnostic] ", ""));
+    expect(json.tier).toBe("complex");
+    expect(json.agentId).toBe("eureka");
+    expect(json.phase).toBe("done");
+  });
+});
+
+// ── Task 4: Configurable dedup TTL ───────────────────────────────
+
+describe("configurable dedup TTL", () => {
+  beforeEach(async () => {
+    const { _resetForTesting } = await import("../pipeline/webhook.js");
+    _resetForTesting();
+  });
+
+  afterEach(async () => {
+    const { _resetForTesting } = await import("../pipeline/webhook.js");
+    _resetForTesting();
+  });
+
+  it("defaults to 60_000ms when no config provided", async () => {
+    const { _configureDedupTtls, _getDedupTtlMs } = await import("../pipeline/webhook.js");
+    _configureDedupTtls();
+    expect(_getDedupTtlMs()).toBe(60_000);
+  });
+
+  it("defaults to 60_000ms when pluginConfig has no dedupTtlMs", async () => {
+    const { _configureDedupTtls, _getDedupTtlMs } = await import("../pipeline/webhook.js");
+    _configureDedupTtls({});
+    expect(_getDedupTtlMs()).toBe(60_000);
+  });
+
+  it("reads dedupTtlMs from pluginConfig", async () => {
+    const { _configureDedupTtls, _getDedupTtlMs } = await import("../pipeline/webhook.js");
+    _configureDedupTtls({ dedupTtlMs: 120_000 });
+    expect(_getDedupTtlMs()).toBe(120_000);
+  });
+
+  it("reads dedupSweepIntervalMs from pluginConfig", async () => {
+    const { _configureDedupTtls, _getDedupTtlMs } = await import("../pipeline/webhook.js");
+    _configureDedupTtls({ dedupTtlMs: 30_000, dedupSweepIntervalMs: 5_000 });
+    expect(_getDedupTtlMs()).toBe(30_000);
+  });
+
+  it("_resetForTesting restores default TTLs", async () => {
+    const { _configureDedupTtls, _getDedupTtlMs, _resetForTesting } = await import("../pipeline/webhook.js");
+    _configureDedupTtls({ dedupTtlMs: 999 });
+    expect(_getDedupTtlMs()).toBe(999);
+
+    _resetForTesting();
+    expect(_getDedupTtlMs()).toBe(60_000);
+  });
+});

package/src/infra/doctor.ts

@@ -52,11 +52,15 @@ export interface DoctorOptions {
 
 const AGENT_PROFILES_PATH = join(homedir(), ".openclaw", "agent-profiles.json");
 const VALID_BACKENDS: readonly string[] = ["claude", "codex", "gemini"];
-const CLI_BINS: [string, string][] = [
-  ["codex", "/home/claw/.npm-global/bin/codex"],
-  ["claude", "/home/claw/.npm-global/bin/claude"],
-  ["gemini", "/home/claw/.npm-global/bin/gemini"],
-];
+const DEFAULT_BIN_DIR = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+
+function resolveCliBins(pluginConfig?: Record<string, unknown>): [string, string][] {
+  return [
+    ["codex", (pluginConfig?.codexBin as string) ?? join(DEFAULT_BIN_DIR, "codex")],
+    ["claude", (pluginConfig?.claudeBin as string) ?? join(DEFAULT_BIN_DIR, "claude")],
+    ["gemini", (pluginConfig?.geminiBin as string) ?? join(DEFAULT_BIN_DIR, "gemini")],
+  ];
+}
 const STALE_DISPATCH_MS = 2 * 60 * 60_000; // 2 hours
 const OLD_COMPLETED_MS = 7 * 24 * 60 * 60_000; // 7 days
 const LOCK_STALE_MS = 30_000; // 30 seconds
@@ -92,7 +96,7 @@ function resolveWorktreeBaseDir(pluginConfig?: Record<string, unknown>): string
 }
 
 function resolveBaseRepo(pluginConfig?: Record<string, unknown>): string {
-  return (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  return (pluginConfig?.codexBaseRepo as string) ?? join(process.env.HOME ?? homedir(), "ai-workspace");
 }
 
 interface AgentProfile {
@@ -315,7 +319,7 @@ export function checkAgentConfig(pluginConfig?: Record<string, unknown>): CheckR
 // Section 3: Coding Tools
 // ---------------------------------------------------------------------------
 
-export function checkCodingTools(): CheckResult[] {
+export function checkCodingTools(pluginConfig?: Record<string, unknown>): CheckResult[] {
   const checks: CheckResult[] = [];
 
   // Load config
@@ -345,7 +349,8 @@ export function checkCodingTools(): CheckResult[] {
   }
 
   // CLI availability
-  for (const [name, bin] of CLI_BINS) {
+  const cliBins = resolveCliBins(pluginConfig);
+  for (const [name, bin] of cliBins) {
     try {
       const raw = execFileSync(bin, ["--version"], {
         encoding: "utf8",
@@ -728,7 +733,7 @@ export async function runDoctor(opts: DoctorOptions): Promise<DoctorReport> {
   sections.push({ name: "Agent Configuration", checks: checkAgentConfig(opts.pluginConfig) });
 
   // 3. Coding tools
-  sections.push({ name: "Coding Tools", checks: checkCodingTools() });
+  sections.push({ name: "Coding Tools", checks: checkCodingTools(opts.pluginConfig) });
 
   // 4. Files & dirs
   sections.push({
@@ -788,31 +793,34 @@ interface BackendSpec {
   unsetEnv?: string[];
 }
 
-const BACKEND_SPECS: BackendSpec[] = [
-  {
-    id: "claude",
-    label: "Claude Code (Anthropic)",
-    bin: "/home/claw/.npm-global/bin/claude",
-    testArgs: ["--print", "-p", "Respond with the single word hello", "--output-format", "stream-json", "--max-turns", "1", "--dangerously-skip-permissions"],
-    envKeys: ["ANTHROPIC_API_KEY"],
-    configKey: "claudeApiKey",
-    unsetEnv: ["CLAUDECODE"],
-  },
-  {
-    id: "codex",
-    label: "Codex (OpenAI)",
-    bin: "/home/claw/.npm-global/bin/codex",
-    testArgs: ["exec", "--json", "--ephemeral", "--full-auto", "echo hello"],
-    envKeys: ["OPENAI_API_KEY"],
-  },
-  {
-    id: "gemini",
-    label: "Gemini CLI (Google)",
-    bin: "/home/claw/.npm-global/bin/gemini",
-    testArgs: ["-p", "Respond with the single word hello", "-o", "stream-json", "--yolo"],
-    envKeys: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENAI_API_KEY"],
-  },
-];
+function resolveBackendSpecs(pluginConfig?: Record<string, unknown>): BackendSpec[] {
+  const binDir = join(process.env.HOME ?? homedir(), ".npm-global", "bin");
+  return [
+    {
+      id: "claude",
+      label: "Claude Code (Anthropic)",
+      bin: (pluginConfig?.claudeBin as string) ?? join(binDir, "claude"),
+      testArgs: ["--print", "-p", "Respond with the single word hello", "--output-format", "stream-json", "--max-turns", "1", "--dangerously-skip-permissions"],
+      envKeys: ["ANTHROPIC_API_KEY"],
+      configKey: "claudeApiKey",
+      unsetEnv: ["CLAUDECODE"],
+    },
+    {
+      id: "codex",
+      label: "Codex (OpenAI)",
+      bin: (pluginConfig?.codexBin as string) ?? join(binDir, "codex"),
+      testArgs: ["exec", "--json", "--ephemeral", "--full-auto", "echo hello"],
+      envKeys: ["OPENAI_API_KEY"],
+    },
+    {
+      id: "gemini",
+      label: "Gemini CLI (Google)",
+      bin: (pluginConfig?.geminiBin as string) ?? join(binDir, "gemini"),
+      testArgs: ["-p", "Respond with the single word hello", "-o", "stream-json", "--yolo"],
+      envKeys: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENAI_API_KEY"],
+    },
+  ];
+}
 
 function checkBackendBinary(spec: BackendSpec): { installed: boolean; checks: CheckResult[] } {
   const checks: CheckResult[] = [];
@@ -929,8 +937,9 @@ export async function checkCodeRunDeep(
   const sections: CheckSection[] = [];
   const config = loadCodingConfig();
   let callableCount = 0;
+  const backendSpecs = resolveBackendSpecs(pluginConfig);
 
-  for (const spec of BACKEND_SPECS) {
+  for (const spec of backendSpecs) {
     const checks: CheckResult[] = [];
 
     // 1. Binary check
@@ -966,7 +975,7 @@ export async function checkCodeRunDeep(
     ));
   }
 
-  routingChecks.push(pass(`Callable backends: ${callableCount}/${BACKEND_SPECS.length}`));
+  routingChecks.push(pass(`Callable backends: ${callableCount}/${backendSpecs.length}`));
   sections.push({ name: "Code Run: Routing", checks: routingChecks });
 
   return sections;

package/src/infra/notify.test.ts

@@ -371,6 +371,55 @@ describe("createNotifierFromConfig", () => {
     consoleSpy.mockRestore();
   });
 
+  it("sanitizes URLs and tokens from error messages", async () => {
+    const runtime = mockRuntime();
+    runtime.channel.discord.sendMessageDiscord = vi.fn(async () => {
+      throw new Error("Failed to POST https://discord.com/api/v10/channels/123/messages with token fake-slack-token-1234567890");
+    });
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const notify = createNotifierFromConfig({
+      notifications: {
+        targets: [{ channel: "discord", target: "D-100" }],
+      },
+    }, runtime);
+    await notify("dispatch", basePayload);
+
+    // Check that the error message was sanitized
+    expect(consoleSpy).toHaveBeenCalledOnce();
+    const errorMessage = consoleSpy.mock.calls[0][0] as string;
+    expect(errorMessage).not.toContain("https://discord.com");
+    expect(errorMessage).not.toContain("xoxb-1234567890");
+    expect(errorMessage).toContain("[URL]");
+    expect(errorMessage).toContain("[TOKEN]");
+
+    consoleSpy.mockRestore();
+  });
+
+  it("does not leak long token-like strings in console error output", async () => {
+    const runtime = mockRuntime();
+    const fakeToken = "xoxb-ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+    runtime.channel.discord.sendMessageDiscord = vi.fn(async () => {
+      throw new Error(`Auth failed with token ${fakeToken}`);
+    });
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const notify = createNotifierFromConfig({
+      notifications: {
+        targets: [{ channel: "discord", target: "D-100" }],
+      },
+    }, runtime);
+    await notify("dispatch", basePayload);
+
+    expect(consoleSpy).toHaveBeenCalledOnce();
+    const errorMessage = consoleSpy.mock.calls[0][0] as string;
+    // The long token-like string should be replaced
+    expect(errorMessage).not.toContain(fakeToken);
+    expect(errorMessage).toContain("[TOKEN]");
+
+    consoleSpy.mockRestore();
+  });
+
   it("skips suppressed events", async () => {
     const runtime = mockRuntime();
     const notify = createNotifierFromConfig({

package/src/infra/notify.ts

@@ -262,13 +262,18 @@ export function createNotifierFromConfig(
         try {
           await sendToTarget(target, message, runtime);
         } catch (err) {
-          console.error(`Notify error (${target.channel}:${target.target}):`, err);
+          const safeError = err instanceof Error ? err.message : "Unknown error";
+          // Strip potential URLs/tokens from error messages to prevent secret leakage
+          const sanitizedError = safeError
+            .replace(/https?:\/\/[^\s]+/g, "[URL]")
+            .replace(/[A-Za-z0-9_-]{20,}/g, "[TOKEN]");
+          console.error(`Notify error (${target.channel}:${target.target}): ${sanitizedError}`);
           if (api) {
             emitDiagnostic(api, {
               event: "notify_failed",
               identifier: payload.identifier,
               phase: kind,
-              error: String(err),
+              error: sanitizedError,
             });
           }
         }

package/src/infra/observability.ts

@@ -23,6 +23,7 @@ export interface DiagnosticPayload {
   event: DiagnosticEvent;
   identifier?: string;
   issueId?: string;
+  agentId?: string;
   phase?: string;
   from?: string;
   to?: string;