@calltelemetry/openclaw-linear 0.6.1 → 0.7.1

package/src/infra/file-lock.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { acquireLock, releaseLock } from "./file-lock.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+const tmpDir = os.tmpdir();
+const testState = path.join(tmpDir, `file-lock-test-${process.pid}.json`);
+const lockFile = testState + ".lock";
+
+afterEach(async () => {
+  try { await fs.unlink(lockFile); } catch {}
+  try { await fs.unlink(testState); } catch {}
+});
+
+describe("acquireLock / releaseLock", () => {
+  it("creates and removes a lock file", async () => {
+    await acquireLock(testState);
+    const stat = await fs.stat(lockFile);
+    expect(stat.isFile()).toBe(true);
+
+    await releaseLock(testState);
+    await expect(fs.stat(lockFile)).rejects.toThrow();
+  });
+
+  it("blocks concurrent acquires until released", async () => {
+    await acquireLock(testState);
+
+    let secondAcquired = false;
+    const secondLock = acquireLock(testState).then(() => {
+      secondAcquired = true;
+    });
+
+    // Give the second acquire a moment to spin
+    await new Promise((r) => setTimeout(r, 120));
+    expect(secondAcquired).toBe(false);
+
+    await releaseLock(testState);
+    await secondLock;
+    expect(secondAcquired).toBe(true);
+
+    await releaseLock(testState);
+  });
+
+  it("releaseLock is safe to call when no lock exists", async () => {
+    await expect(releaseLock(testState)).resolves.toBeUndefined();
+  });
+
+  it("recovers from stale lock", async () => {
+    // Write a lock file with an old timestamp (> 30s ago)
+    await fs.writeFile(lockFile, String(Date.now() - 60_000), { flag: "w" });
+
+    // Should succeed by detecting stale lock
+    await acquireLock(testState);
+    const content = await fs.readFile(lockFile, "utf-8");
+    const lockTime = Number(content);
+    expect(Date.now() - lockTime).toBeLessThan(5000);
+
+    await releaseLock(testState);
+  });
+});

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.ts

@@ -0,0 +1,85 @@
+/**
+ * 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 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;
+}