@calltelemetry/openclaw-linear 0.7.0 → 0.8.0

package/src/infra/file-lock.ts

@@ -0,0 +1,49 @@
+/**
+ * file-lock.ts — Shared file-level locking for state files.
+ *
+ * Used by dispatch-state.ts and planning-state.ts to prevent
+ * concurrent read-modify-write races on JSON state files.
+ */
+import fs from "node:fs/promises";
+
+const LOCK_STALE_MS = 30_000;
+const LOCK_RETRY_MS = 50;
+const LOCK_TIMEOUT_MS = 10_000;
+
+function lockPath(statePath: string): string {
+  return statePath + ".lock";
+}
+
+export async function acquireLock(statePath: string): Promise<void> {
+  const lock = lockPath(statePath);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    try {
+      await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+      return;
+    } catch (err: any) {
+      if (err.code !== "EEXIST") throw err;
+
+      // Check for stale lock
+      try {
+        const content = await fs.readFile(lock, "utf-8");
+        const lockTime = Number(content);
+        if (Date.now() - lockTime > LOCK_STALE_MS) {
+          try { await fs.unlink(lock); } catch { /* race */ }
+          continue;
+        }
+      } catch { /* lock disappeared — retry */ }
+
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+
+  // Last resort: force remove potentially stale lock
+  try { await fs.unlink(lockPath(statePath)); } catch { /* ignore */ }
+  await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+}
+
+export async function releaseLock(statePath: string): Promise<void> {
+  try { await fs.unlink(lockPath(statePath)); } catch { /* already removed */ }
+}

package/src/infra/multi-repo.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { resolveRepos, isMultiRepo, validateRepoPath, type RepoResolution } from "./multi-repo.ts";
+
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    existsSync: vi.fn(),
+    statSync: vi.fn(),
+  };
+});
+
+import { existsSync, statSync } from "node:fs";
+const mockExistsSync = existsSync as ReturnType<typeof vi.fn>;
+const mockStatSync = statSync as ReturnType<typeof vi.fn>;
+
+describe("resolveRepos", () => {
+  it("parses <!-- repos: api, frontend --> from description", () => {
+    const result = resolveRepos(
+      "Fix the bug\n<!-- repos: api, frontend -->",
+      [],
+    );
+    expect(result.source).toBe("issue_body");
+    expect(result.repos).toHaveLength(2);
+    expect(result.repos[0].name).toBe("api");
+    expect(result.repos[1].name).toBe("frontend");
+  });
+
+  it("parses [repos: web, worker] from description", () => {
+    const result = resolveRepos(
+      "Some issue\n[repos: web, worker]",
+      [],
+    );
+    expect(result.source).toBe("issue_body");
+    expect(result.repos).toHaveLength(2);
+    expect(result.repos[0].name).toBe("web");
+    expect(result.repos[1].name).toBe("worker");
+  });
+
+  it("extracts from repo:api and repo:frontend labels", () => {
+    const result = resolveRepos("No markers here", ["repo:api", "repo:frontend"]);
+    expect(result.source).toBe("labels");
+    expect(result.repos).toHaveLength(2);
+    expect(result.repos[0].name).toBe("api");
+    expect(result.repos[1].name).toBe("frontend");
+  });
+
+  it("falls back to config repos when no markers/labels", () => {
+    const config = { codexBaseRepo: "/home/claw/myproject" };
+    const result = resolveRepos("Plain description", [], config);
+    expect(result.source).toBe("config_default");
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0].name).toBe("default");
+    expect(result.repos[0].path).toBe("/home/claw/myproject");
+  });
+
+  it("body markers take priority over labels", () => {
+    const result = resolveRepos(
+      "<!-- repos: api -->",
+      ["repo:frontend"],
+    );
+    expect(result.source).toBe("issue_body");
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0].name).toBe("api");
+  });
+
+  it("returns single repo from codexBaseRepo when no repos config", () => {
+    const result = resolveRepos("Nothing special", []);
+    expect(result.source).toBe("config_default");
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0].name).toBe("default");
+    expect(result.repos[0].path).toBe("/home/claw/ai-workspace");
+  });
+
+  it("handles empty description + no labels (single repo fallback)", () => {
+    const result = resolveRepos("", []);
+    expect(result.source).toBe("config_default");
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0].name).toBe("default");
+  });
+
+  it("trims whitespace in repo names from markers", () => {
+    const result = resolveRepos(
+      "<!-- repos:  api ,  frontend  -->",
+      [],
+    );
+    expect(result.source).toBe("issue_body");
+    expect(result.repos[0].name).toBe("api");
+    expect(result.repos[1].name).toBe("frontend");
+  });
+
+  it("handles null/undefined description", () => {
+    const resultNull = resolveRepos(null, []);
+    expect(resultNull.source).toBe("config_default");
+    expect(resultNull.repos).toHaveLength(1);
+
+    const resultUndefined = resolveRepos(undefined, []);
+    expect(resultUndefined.source).toBe("config_default");
+    expect(resultUndefined.repos).toHaveLength(1);
+  });
+});
+
+describe("isMultiRepo", () => {
+  it("returns true for 2+ repos", () => {
+    const resolution: RepoResolution = {
+      repos: [
+        { name: "api", path: "/home/claw/api" },
+        { name: "frontend", path: "/home/claw/frontend" },
+      ],
+      source: "issue_body",
+    };
+    expect(isMultiRepo(resolution)).toBe(true);
+  });
+
+  it("returns false for 1 repo", () => {
+    const resolution: RepoResolution = {
+      repos: [{ name: "default", path: "/home/claw/ai-workspace" }],
+      source: "config_default",
+    };
+    expect(isMultiRepo(resolution)).toBe(false);
+  });
+
+  it("returns false for empty result", () => {
+    const resolution: RepoResolution = {
+      repos: [],
+      source: "config_default",
+    };
+    expect(isMultiRepo(resolution)).toBe(false);
+  });
+});
+
+describe("validateRepoPath", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns exists:false for missing path", () => {
+    mockExistsSync.mockReturnValue(false);
+    const result = validateRepoPath("/no/such/path");
+    expect(result).toEqual({ exists: false, isGitRepo: false, isSubmodule: false });
+  });
+
+  it("returns isGitRepo:true, isSubmodule:false for normal repo (.git is directory)", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockStatSync.mockReturnValue({ isFile: () => false, isDirectory: () => true });
+    const result = validateRepoPath("/home/claw/repos/api");
+    expect(result).toEqual({ exists: true, isGitRepo: true, isSubmodule: false });
+  });
+
+  it("returns isGitRepo:true, isSubmodule:true for submodule (.git is file)", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockStatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
+    const result = validateRepoPath("/home/claw/workspace/submod");
+    expect(result).toEqual({ exists: true, isGitRepo: true, isSubmodule: true });
+  });
+
+  it("returns isGitRepo:false for directory without .git", () => {
+    // First call: path exists. Second call: .git does not exist
+    mockExistsSync.mockImplementation((p: string) => !String(p).endsWith(".git"));
+    const result = validateRepoPath("/home/claw/not-a-repo");
+    expect(result).toEqual({ exists: true, isGitRepo: false, isSubmodule: false });
+  });
+});

package/src/infra/multi-repo.ts

@@ -0,0 +1,114 @@
+/**
+ * multi-repo.ts — Multi-repo resolution for dispatches spanning multiple git repos.
+ *
+ * Three-tier resolution:
+ * 1. Issue body markers: <!-- repos: api, frontend --> or [repos: api, frontend]
+ * 2. Linear labels: repo:api, repo:frontend
+ * 3. Config default: Falls back to single codexBaseRepo
+ */
+
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+
+export interface RepoConfig {
+  name: string;
+  path: string;
+}
+
+export interface RepoResolution {
+  repos: RepoConfig[];
+  source: "issue_body" | "labels" | "config_default";
+}
+
+/**
+ * Resolve which repos a dispatch should work with.
+ */
+export function resolveRepos(
+  description: string | null | undefined,
+  labels: string[],
+  pluginConfig?: Record<string, unknown>,
+): RepoResolution {
+  // 1. Check issue body for repo markers
+  // Match: <!-- repos: name1, name2 --> or [repos: name1, name2]
+  const htmlComment = description?.match(/<!--\s*repos:\s*([^>]+?)\s*-->/i);
+  const bracketMatch = description?.match(/\[repos:\s*([^\]]+)\]/i);
+  const bodyMatch = htmlComment?.[1] ?? bracketMatch?.[1];
+
+  if (bodyMatch) {
+    const names = bodyMatch.split(",").map(s => s.trim()).filter(Boolean);
+    if (names.length > 0) {
+      const repoMap = getRepoMap(pluginConfig);
+      const repos = names.map(name => ({
+        name,
+        path: repoMap[name] ?? resolveRepoPath(name, pluginConfig),
+      }));
+      return { repos, source: "issue_body" };
+    }
+  }
+
+  // 2. Check labels for repo: prefix
+  const repoLabels = labels
+    .filter(l => l.startsWith("repo:"))
+    .map(l => l.slice(5).trim())
+    .filter(Boolean);
+
+  if (repoLabels.length > 0) {
+    const repoMap = getRepoMap(pluginConfig);
+    const repos = repoLabels.map(name => ({
+      name,
+      path: repoMap[name] ?? resolveRepoPath(name, pluginConfig),
+    }));
+    return { repos, source: "labels" };
+  }
+
+  // 3. Config default: single repo
+  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  return {
+    repos: [{ name: "default", path: baseRepo }],
+    source: "config_default",
+  };
+}
+
+function getRepoMap(pluginConfig?: Record<string, unknown>): Record<string, string> {
+  const repos = pluginConfig?.repos as Record<string, string> | undefined;
+  return repos ?? {};
+}
+
+function resolveRepoPath(name: string, pluginConfig?: Record<string, unknown>): string {
+  // Convention: {parentDir}/{name}
+  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  const parentDir = path.dirname(baseRepo);
+  return path.join(parentDir, name);
+}
+
+export function isMultiRepo(resolution: RepoResolution): boolean {
+  return resolution.repos.length > 1;
+}
+
+/**
+ * Validate a repo path: exists, is a git repo, and whether it's a submodule.
+ * Submodules have a `.git` *file* (not directory) that points to the parent's
+ * `.git/modules/` — `git worktree add` won't work on them.
+ */
+export function validateRepoPath(repoPath: string): {
+  exists: boolean;
+  isGitRepo: boolean;
+  isSubmodule: boolean;
+} {
+  if (!existsSync(repoPath)) {
+    return { exists: false, isGitRepo: false, isSubmodule: false };
+  }
+
+  const gitPath = path.join(repoPath, ".git");
+  if (!existsSync(gitPath)) {
+    return { exists: true, isGitRepo: false, isSubmodule: false };
+  }
+
+  const stat = statSync(gitPath);
+  if (stat.isFile()) {
+    // .git is a file → submodule (points to parent's .git/modules/)
+    return { exists: true, isGitRepo: true, isSubmodule: true };
+  }
+
+  return { exists: true, isGitRepo: true, isSubmodule: false };
+}

package/src/infra/notify.test.ts

@@ -3,6 +3,7 @@ import {
   createNoopNotifier,
   createNotifierFromConfig,
   formatMessage,
+  formatRichMessage,
   sendToTarget,
   parseNotificationsConfig,
   type NotifyKind,
@@ -23,24 +24,24 @@ describe("formatMessage", () => {
 
   it("formats dispatch message", () => {
     const msg = formatMessage("dispatch", basePayload);
-    expect(msg).toBe("API-42 dispatched — Fix auth");
+    expect(msg).toBe("API-42 started — Fix auth");
   });
 
   it("formats working message with attempt", () => {
     const msg = formatMessage("working", { ...basePayload, attempt: 1 });
-    expect(msg).toContain("worker started");
-    expect(msg).toContain("attempt 1");
+    expect(msg).toContain("working on it");
+    expect(msg).toContain("attempt 2"); // 1-based for humans
   });
 
   it("formats auditing message", () => {
     const msg = formatMessage("auditing", basePayload);
-    expect(msg).toContain("audit in progress");
+    expect(msg).toContain("checking the work");
   });
 
   it("formats audit_pass message", () => {
     const msg = formatMessage("audit_pass", basePayload);
-    expect(msg).toContain("passed audit");
-    expect(msg).toContain("PR ready");
+    expect(msg).toContain("done!");
+    expect(msg).toContain("Ready for review");
   });
 
   it("formats audit_fail message with gaps", () => {
@@ -49,8 +50,8 @@ describe("formatMessage", () => {
       attempt: 1,
       verdict: { pass: false, gaps: ["no tests", "missing validation"] },
     });
-    expect(msg).toContain("failed audit");
-    expect(msg).toContain("attempt 1");
+    expect(msg).toContain("needs more work");
+    expect(msg).toContain("attempt 2"); // 1-based for humans
     expect(msg).toContain("no tests");
     expect(msg).toContain("missing validation");
   });
@@ -67,10 +68,10 @@ describe("formatMessage", () => {
   it("formats escalation message with reason", () => {
     const msg = formatMessage("escalation", {
       ...basePayload,
-      reason: "audit failed 3x",
+      attempt: 2,
     });
-    expect(msg).toContain("needs human review");
-    expect(msg).toContain("audit failed 3x");
+    expect(msg).toContain("needs your help");
+    expect(msg).toContain("3 tries"); // 1-based
   });
 
   it("formats stuck message", () => {
@@ -86,11 +87,11 @@ describe("formatMessage", () => {
     const msg = formatMessage("watchdog_kill", {
       ...basePayload,
       attempt: 0,
-      reason: "no I/O for 120s",
+      reason: "no activity for 120s",
     });
-    expect(msg).toContain("killed by watchdog");
-    expect(msg).toContain("no I/O for 120s");
-    expect(msg).toContain("Retrying (attempt 0)");
+    expect(msg).toContain("timed out");
+    expect(msg).toContain("no activity for 120s");
+    expect(msg).toContain("Retrying (attempt 1)"); // 1-based
   });
 
   it("formats watchdog_kill without attempt", () => {
@@ -325,7 +326,7 @@ describe("createNotifierFromConfig", () => {
     expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledOnce();
     expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledWith(
       "-100388",
-      expect.stringContaining("worker started"),
+      expect.stringContaining("working on it"),
       { silent: true },
     );
   });
@@ -402,6 +403,144 @@ describe("createNotifierFromConfig", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// formatRichMessage
+// ---------------------------------------------------------------------------
+
+describe("formatRichMessage", () => {
+  const basePayload: NotifyPayload = {
+    identifier: "CT-10",
+    title: "Add caching",
+    status: "dispatched",
+  };
+
+  it("returns Discord embed with correct color for dispatch (blue)", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.discord?.embeds).toHaveLength(1);
+    expect(msg.discord!.embeds[0].color).toBe(0x3498db);
+  });
+
+  it("returns Discord embed with green for audit_pass", () => {
+    const msg = formatRichMessage("audit_pass", basePayload);
+    expect(msg.discord!.embeds[0].color).toBe(0x2ecc71);
+  });
+
+  it("returns Discord embed with red for audit_fail", () => {
+    const msg = formatRichMessage("audit_fail", { ...basePayload, attempt: 1, verdict: { pass: false, gaps: ["no tests"] } });
+    expect(msg.discord!.embeds[0].color).toBe(0xe74c3c);
+    expect(msg.discord!.embeds[0].fields).toEqual(
+      expect.arrayContaining([expect.objectContaining({ name: "Issues to fix", value: "no tests" })]),
+    );
+  });
+
+  it("returns Discord embed with orange for stuck", () => {
+    const msg = formatRichMessage("stuck", { ...basePayload, reason: "stale 2h" });
+    expect(msg.discord!.embeds[0].color).toBe(0xe67e22);
+  });
+
+  it("returns Telegram HTML with bold identifier", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.telegram?.html).toContain("<b>CT-10</b>");
+    expect(msg.telegram?.html).toContain("<i>Add caching</i>");
+  });
+
+  it("includes plain text fallback", () => {
+    const msg = formatRichMessage("dispatch", basePayload);
+    expect(msg.text).toBe("CT-10 started — Add caching");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sendToTarget with RichMessage
+// ---------------------------------------------------------------------------
+
+describe("sendToTarget (RichMessage)", () => {
+  function mockRuntime(): any {
+    return {
+      channel: {
+        discord: { sendMessageDiscord: vi.fn(async () => {}) },
+        slack: { sendMessageSlack: vi.fn(async () => ({})) },
+        telegram: { sendMessageTelegram: vi.fn(async () => {}) },
+        signal: { sendMessageSignal: vi.fn(async () => {}) },
+      },
+    };
+  }
+
+  afterEach(() => { vi.restoreAllMocks(); });
+
+  it("passes embeds to Discord when RichMessage provided", async () => {
+    const runtime = mockRuntime();
+    const target: NotifyTarget = { channel: "discord", target: "D-1" };
+    const rich = {
+      text: "plain",
+      discord: { embeds: [{ title: "test", color: 0x3498db }] },
+    };
+    await sendToTarget(target, rich, runtime);
+    expect(runtime.channel.discord.sendMessageDiscord).toHaveBeenCalledWith(
+      "D-1", "plain", { embeds: [{ title: "test", color: 0x3498db }] },
+    );
+  });
+
+  it("passes textMode html to Telegram when RichMessage provided", async () => {
+    const runtime = mockRuntime();
+    const target: NotifyTarget = { channel: "telegram", target: "-999" };
+    const rich = {
+      text: "plain",
+      telegram: { html: "<b>CT-10</b> dispatched" },
+    };
+    await sendToTarget(target, rich, runtime);
+    expect(runtime.channel.telegram.sendMessageTelegram).toHaveBeenCalledWith(
+      "-999", "<b>CT-10</b> dispatched", { silent: true, textMode: "html" },
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createNotifierFromConfig (richFormat)
+// ---------------------------------------------------------------------------
+
+describe("createNotifierFromConfig (richFormat)", () => {
+  function mockRuntime(): any {
+    return {
+      channel: {
+        discord: { sendMessageDiscord: vi.fn(async () => {}) },
+        slack: { sendMessageSlack: vi.fn(async () => ({})) },
+        telegram: { sendMessageTelegram: vi.fn(async () => {}) },
+        signal: { sendMessageSignal: vi.fn(async () => {}) },
+      },
+    };
+  }
+
+  afterEach(() => { vi.restoreAllMocks(); });
+
+  it("sends Discord embeds when richFormat is true", async () => {
+    const runtime = mockRuntime();
+    const notify = createNotifierFromConfig({
+      notifications: {
+        richFormat: true,
+        targets: [{ channel: "discord", target: "D-1" }],
+      },
+    }, runtime);
+    await notify("dispatch", { identifier: "CT-1", title: "Test", status: "dispatched" });
+    const [, , opts] = runtime.channel.discord.sendMessageDiscord.mock.calls[0];
+    expect(opts?.embeds).toBeDefined();
+    expect(opts.embeds).toHaveLength(1);
+  });
+
+  it("sends plain text when richFormat is false", async () => {
+    const runtime = mockRuntime();
+    const notify = createNotifierFromConfig({
+      notifications: {
+        richFormat: false,
+        targets: [{ channel: "discord", target: "D-1" }],
+      },
+    }, runtime);
+    await notify("dispatch", { identifier: "CT-1", title: "Test", status: "dispatched" });
+    const call = runtime.channel.discord.sendMessageDiscord.mock.calls[0];
+    expect(call).toHaveLength(2); // no third arg with embeds
+  });
+});
+
 // ---------------------------------------------------------------------------
 // createNoopNotifier
 // ---------------------------------------------------------------------------