@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/refresh-lock.test.ts

@@ -9,119 +9,119 @@ const DEFAULT_LOCK_TIMEOUT_MS = 15_000;
 const DEFAULT_STALE_LOCK_MS = 90_000;
 
 vi.mock("./storage.js", () => ({
-  getStoragePath: () => storagePath,
+    getStoragePath: () => storagePath,
 }));
 
 import { acquireRefreshLock, releaseRefreshLock } from "./refresh-lock.js";
 
 describe("refresh-lock", () => {
-  beforeEach(async () => {
-    await fs.rm(baseDir, { recursive: true, force: true });
-    await fs.mkdir(baseDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(baseDir, { recursive: true, force: true });
-  });
-
-  it("does not release lock with mismatched owner", async () => {
-    const lock = await acquireRefreshLock("acc-1");
-    expect(lock.acquired).toBe(true);
-    expect(lock.lockPath).toBeTruthy();
-    const lockPath = lock.lockPath!;
-
-    await releaseRefreshLock({ lockPath, owner: "wrong-owner" });
-
-    await expect(fs.stat(lockPath)).resolves.toBeTruthy();
-
-    await releaseRefreshLock(lock);
-    await expect(fs.stat(lockPath)).rejects.toMatchObject({
-      code: "ENOENT",
+    beforeEach(async () => {
+        await fs.rm(baseDir, { recursive: true, force: true });
+        await fs.mkdir(baseDir, { recursive: true });
     });
-  });
 
-  it("acquires a new lock after stale lock timeout", async () => {
-    const first = await acquireRefreshLock("acc-2", {
-      timeoutMs: 50,
-      staleMs: 10_000,
+    afterEach(async () => {
+        await fs.rm(baseDir, { recursive: true, force: true });
     });
-    expect(first.acquired).toBe(true);
-    const firstLockPath = first.lockPath!;
-
-    const old = Date.now() / 1000 - 120;
-    await fs.utimes(firstLockPath, old, old);
 
-    const second = await acquireRefreshLock("acc-2", {
-      timeoutMs: 200,
-      backoffMs: 5,
-      staleMs: 20,
-    });
-    expect(second.acquired).toBe(true);
-    expect(second.owner).not.toBe(first.owner);
+    it("does not release lock with mismatched owner", async () => {
+        const lock = await acquireRefreshLock("acc-1");
+        expect(lock.acquired).toBe(true);
+        expect(lock.lockPath).toBeTruthy();
+        const lockPath = lock.lockPath!;
 
-    await releaseRefreshLock(second);
-  });
+        await releaseRefreshLock({ lockPath, owner: "wrong-owner" });
 
-  it("returns not acquired when lock remains busy", async () => {
-    const first = await acquireRefreshLock("acc-3", { timeoutMs: 50 });
-    expect(first.acquired).toBe(true);
+        await expect(fs.stat(lockPath)).resolves.toBeTruthy();
 
-    const second = await acquireRefreshLock("acc-3", {
-      timeoutMs: 30,
-      backoffMs: 5,
-      staleMs: DEFAULT_STALE_LOCK_MS,
+        await releaseRefreshLock(lock);
+        await expect(fs.stat(lockPath)).rejects.toMatchObject({
+            code: "ENOENT",
+        });
     });
-    expect(second.acquired).toBe(false);
-
-    await releaseRefreshLock(first);
-  });
 
-  it("stale reaper does NOT steal a lock held for 60s", async () => {
-    const first = await acquireRefreshLock("acc-stable-refresh", {
-      timeoutMs: DEFAULT_LOCK_TIMEOUT_MS,
+    it("acquires a new lock after stale lock timeout", async () => {
+        const first = await acquireRefreshLock("acc-2", {
+            timeoutMs: 50,
+            staleMs: 10_000,
+        });
+        expect(first.acquired).toBe(true);
+        const firstLockPath = first.lockPath!;
+
+        const old = Date.now() / 1000 - 120;
+        await fs.utimes(firstLockPath, old, old);
+
+        const second = await acquireRefreshLock("acc-2", {
+            timeoutMs: 200,
+            backoffMs: 5,
+            staleMs: 20,
+        });
+        expect(second.acquired).toBe(true);
+        expect(second.owner).not.toBe(first.owner);
+
+        await releaseRefreshLock(second);
     });
-    expect(first.acquired).toBe(true);
-    expect(first.lockPath).toBeTruthy();
-    const firstLockPath = first.lockPath!;
 
-    const sixtySecondsAgo = Date.now() / 1000 - 60;
-    await fs.utimes(firstLockPath, sixtySecondsAgo, sixtySecondsAgo);
+    it("returns not acquired when lock remains busy", async () => {
+        const first = await acquireRefreshLock("acc-3", { timeoutMs: 50 });
+        expect(first.acquired).toBe(true);
 
-    const second = await acquireRefreshLock("acc-stable-refresh", {
-      timeoutMs: 30,
-      backoffMs: 5,
-      staleMs: DEFAULT_STALE_LOCK_MS,
-    });
-    expect(second.acquired).toBe(false);
-
-    await expect(fs.stat(firstLockPath)).resolves.toBeTruthy();
-    await releaseRefreshLock(first);
-  });
-
-  it("does not release when inode changed even if owner matches", async () => {
-    const first = await acquireRefreshLock("acc-4");
-    expect(first.acquired).toBe(true);
-    const firstLockPath = first.lockPath!;
-    const originalLockInode = first.lockInode;
-    expect(originalLockInode).not.toBeNull();
-
-    // Keep the same owner text but pass a deliberately mismatched inode. This
-    // tests the safety check directly without relying on filesystem-specific
-    // inode allocation behavior, which can aggressively recycle inode numbers
-    // on Linux CI runners.
-    await fs.writeFile(firstLockPath, JSON.stringify({ owner: first.owner, createdAt: Date.now() }), {
-      encoding: "utf-8",
-      mode: 0o600,
-    });
+        const second = await acquireRefreshLock("acc-3", {
+            timeoutMs: 30,
+            backoffMs: 5,
+            staleMs: DEFAULT_STALE_LOCK_MS,
+        });
+        expect(second.acquired).toBe(false);
 
-    await releaseRefreshLock({
-      lockPath: firstLockPath,
-      owner: first.owner,
-      lockInode: originalLockInode! + 1n,
+        await releaseRefreshLock(first);
     });
 
-    await expect(fs.stat(firstLockPath)).resolves.toBeTruthy();
+    it("stale reaper does NOT steal a lock held for 60s", async () => {
+        const first = await acquireRefreshLock("acc-stable-refresh", {
+            timeoutMs: DEFAULT_LOCK_TIMEOUT_MS,
+        });
+        expect(first.acquired).toBe(true);
+        expect(first.lockPath).toBeTruthy();
+        const firstLockPath = first.lockPath!;
+
+        const sixtySecondsAgo = Date.now() / 1000 - 60;
+        await fs.utimes(firstLockPath, sixtySecondsAgo, sixtySecondsAgo);
+
+        const second = await acquireRefreshLock("acc-stable-refresh", {
+            timeoutMs: 30,
+            backoffMs: 5,
+            staleMs: DEFAULT_STALE_LOCK_MS,
+        });
+        expect(second.acquired).toBe(false);
+
+        await expect(fs.stat(firstLockPath)).resolves.toBeTruthy();
+        await releaseRefreshLock(first);
+    });
 
-    await fs.unlink(firstLockPath);
-  });
+    it("does not release when inode changed even if owner matches", async () => {
+        const first = await acquireRefreshLock("acc-4");
+        expect(first.acquired).toBe(true);
+        const firstLockPath = first.lockPath!;
+        const originalLockInode = first.lockInode;
+        expect(originalLockInode).not.toBeNull();
+
+        // Keep the same owner text but pass a deliberately mismatched inode. This
+        // tests the safety check directly without relying on filesystem-specific
+        // inode allocation behavior, which can aggressively recycle inode numbers
+        // on Linux CI runners.
+        await fs.writeFile(firstLockPath, JSON.stringify({ owner: first.owner, createdAt: Date.now() }), {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+
+        await releaseRefreshLock({
+            lockPath: firstLockPath,
+            owner: first.owner,
+            lockInode: originalLockInode! + 1n,
+        });
+
+        await expect(fs.stat(firstLockPath)).resolves.toBeTruthy();
+
+        await fs.unlink(firstLockPath);
+    });
 });

package/src/refresh-lock.ts

@@ -8,128 +8,128 @@ const DEFAULT_LOCK_BACKOFF_MS = 50;
 const DEFAULT_STALE_LOCK_MS = 90_000;
 
 function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 function getLockPath(accountId: string): string {
-  const hash = createHash("sha1").update(accountId).digest("hex").slice(0, 24);
-  return join(dirname(getStoragePath()), "locks", `refresh-${hash}.lock`);
+    const hash = createHash("sha1").update(accountId).digest("hex").slice(0, 24);
+    return join(dirname(getStoragePath()), "locks", `refresh-${hash}.lock`);
 }
 
 export interface RefreshLockResult {
-  acquired: boolean;
-  lockPath: string | null;
-  owner: string | null;
-  lockInode: bigint | null;
+    acquired: boolean;
+    lockPath: string | null;
+    owner: string | null;
+    lockInode: bigint | null;
 }
 
 export interface AcquireLockOptions {
-  timeoutMs?: number;
-  backoffMs?: number;
-  staleMs?: number;
+    timeoutMs?: number;
+    backoffMs?: number;
+    staleMs?: number;
 }
 
 /**
  * Try to acquire a per-account cross-process lock.
  */
 export async function acquireRefreshLock(
-  accountId: string,
-  options: AcquireLockOptions = {},
+    accountId: string,
+    options: AcquireLockOptions = {},
 ): Promise<RefreshLockResult> {
-  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-  const backoffMs = options.backoffMs ?? DEFAULT_LOCK_BACKOFF_MS;
-  const staleMs = options.staleMs ?? DEFAULT_STALE_LOCK_MS;
-  const lockPath = getLockPath(accountId);
-  const lockDir = dirname(lockPath);
-  const deadline = Date.now() + Math.max(0, timeoutMs);
-  const owner = randomBytes(12).toString("hex");
-
-  await fs.mkdir(lockDir, { recursive: true });
-
-  while (Date.now() <= deadline) {
-    try {
-      const handle = await fs.open(lockPath, "wx", 0o600);
-      try {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: Date.now(), owner }), "utf-8");
-        const stat = await handle.stat({ bigint: true });
-        return { acquired: true, lockPath, owner, lockInode: stat.ino };
-      } finally {
-        await handle.close();
-      }
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException).code;
-      if (code !== "EEXIST") {
-        throw error;
-      }
-
-      try {
-        const stat = await fs.stat(lockPath, { bigint: true });
-        if (Date.now() - Number(stat.mtimeMs) > staleMs) {
-          await fs.unlink(lockPath);
-          continue;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+    const backoffMs = options.backoffMs ?? DEFAULT_LOCK_BACKOFF_MS;
+    const staleMs = options.staleMs ?? DEFAULT_STALE_LOCK_MS;
+    const lockPath = getLockPath(accountId);
+    const lockDir = dirname(lockPath);
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    const owner = randomBytes(12).toString("hex");
+
+    await fs.mkdir(lockDir, { recursive: true });
+
+    while (Date.now() <= deadline) {
+        try {
+            const handle = await fs.open(lockPath, "wx", 0o600);
+            try {
+                await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: Date.now(), owner }), "utf-8");
+                const stat = await handle.stat({ bigint: true });
+                return { acquired: true, lockPath, owner, lockInode: stat.ino };
+            } finally {
+                await handle.close();
+            }
+        } catch (error) {
+            const code = (error as NodeJS.ErrnoException).code;
+            if (code !== "EEXIST") {
+                throw error;
+            }
+
+            try {
+                const stat = await fs.stat(lockPath, { bigint: true });
+                if (Date.now() - Number(stat.mtimeMs) > staleMs) {
+                    await fs.unlink(lockPath);
+                    continue;
+                }
+            } catch {
+                // Lock may have been released concurrently; retry.
+            }
+
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) break;
+            const jitter = Math.floor(Math.random() * 25);
+            await delay(Math.min(remaining, backoffMs + jitter));
         }
-      } catch {
-        // Lock may have been released concurrently; retry.
-      }
-
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) break;
-      const jitter = Math.floor(Math.random() * 25);
-      await delay(Math.min(remaining, backoffMs + jitter));
     }
-  }
 
-  return { acquired: false, lockPath: null, owner: null, lockInode: null };
+    return { acquired: false, lockPath: null, owner: null, lockInode: null };
 }
 
 export type ReleaseLockInput =
-  | {
-      lockPath: string | null;
-      owner?: string | null;
-      lockInode?: bigint | null;
-    }
-  | string
-  | null;
+    | {
+          lockPath: string | null;
+          owner?: string | null;
+          lockInode?: bigint | null;
+      }
+    | string
+    | null;
 
 /**
  * Release a lock acquired by acquireRefreshLock.
  */
 export async function releaseRefreshLock(lock: ReleaseLockInput): Promise<void> {
-  const lockPath = typeof lock === "string" || lock === null ? lock : lock.lockPath;
-  const owner = typeof lock === "object" && lock ? lock.owner || null : null;
-  const lockInode = typeof lock === "object" && lock ? (lock.lockInode ?? null) : null;
-
-  if (!lockPath) return;
+    const lockPath = typeof lock === "string" || lock === null ? lock : lock.lockPath;
+    const owner = typeof lock === "object" && lock ? lock.owner || null : null;
+    const lockInode = typeof lock === "object" && lock ? (lock.lockInode ?? null) : null;
+
+    if (!lockPath) return;
+
+    // Ownership-safe release: avoid deleting a lock that another process
+    // acquired after ours became stale.
+    if (owner) {
+        try {
+            const content = await fs.readFile(lockPath, "utf-8");
+            const parsed = JSON.parse(content);
+            if (!parsed || typeof parsed !== "object" || parsed.owner !== owner) {
+                return;
+            }
+
+            if (lockInode) {
+                const stat = await fs.stat(lockPath, { bigint: true });
+                if (stat.ino !== lockInode) {
+                    return;
+                }
+            }
+        } catch (error) {
+            const code = (error as NodeJS.ErrnoException).code;
+            if (code === "ENOENT") return;
+            // If unreadable/corrupt, fail closed to avoid deleting another
+            // process's lock when ownership cannot be verified.
+            return;
+        }
+    }
 
-  // Ownership-safe release: avoid deleting a lock that another process
-  // acquired after ours became stale.
-  if (owner) {
     try {
-      const content = await fs.readFile(lockPath, "utf-8");
-      const parsed = JSON.parse(content);
-      if (!parsed || typeof parsed !== "object" || parsed.owner !== owner) {
-        return;
-      }
-
-      if (lockInode) {
-        const stat = await fs.stat(lockPath, { bigint: true });
-        if (stat.ino !== lockInode) {
-          return;
-        }
-      }
+        await fs.unlink(lockPath);
     } catch (error) {
-      const code = (error as NodeJS.ErrnoException).code;
-      if (code === "ENOENT") return;
-      // If unreadable/corrupt, fail closed to avoid deleting another
-      // process's lock when ownership cannot be verified.
-      return;
+        const code = (error as NodeJS.ErrnoException).code;
+        if (code !== "ENOENT") throw error;
     }
-  }
-
-  try {
-    await fs.unlink(lockPath);
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code !== "ENOENT") throw error;
-  }
 }