@mintlify/cli 4.0.1510 → 4.0.1512

package/__test__/runHistory.test.ts

@@ -15,6 +15,8 @@ import type { CodeTestReport } from '../src/agent-harness/types.js';
 const temporaryDirectories: string[] = [];
 
 afterEach(async () => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
   await Promise.all(
     temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true }))
   );
@@ -119,6 +121,80 @@ it('keeps every run when history writes overlap', async () => {
   );
 }, 60_000);
 
+it('retries a temporarily unavailable Windows history lock', async () => {
+  vi.stubGlobal('process', { ...process, platform: 'win32' });
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, 'windows-retry', '2026-09-01T12:00:01.000Z');
+  const open = vi
+    .spyOn(fs, 'open')
+    .mockRejectedValueOnce(Object.assign(new Error('Lock deletion pending'), { code: 'EPERM' }));
+
+  await writeTestRunHistory(docsRoot, report);
+
+  expect(open).toHaveBeenCalledTimes(2);
+  expect(open).toHaveBeenNthCalledWith(
+    2,
+    path.join(docsRoot, '.mintlify/test/testRuns.lock'),
+    'wx'
+  );
+  expect(JSON.parse(await fs.readFile(testRunsIndexPath(docsRoot), 'utf8'))).toMatchObject({
+    runs: [{ runId: report.runId }],
+  });
+  await expect(
+    fs.access(path.join(docsRoot, '.mintlify/test/testRuns.lock'))
+  ).rejects.toMatchObject({
+    code: 'ENOENT',
+  });
+});
+
+it.each([
+  ['linux', 'EPERM'],
+  ['win32', 'EACCES'],
+])('propagates %s lock acquisition errors with code %s', async (platform, code) => {
+  vi.stubGlobal('process', { ...process, platform });
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, 'denied', '2026-09-01T12:00:01.000Z');
+  const error = Object.assign(new Error('Permission denied'), { code });
+  const open = vi.spyOn(fs, 'open').mockRejectedValue(error);
+
+  await expect(writeTestRunHistory(docsRoot, report)).rejects.toBe(error);
+  expect(open).toHaveBeenCalledTimes(1);
+});
+
+it('stops retrying a Windows lock at the acquisition deadline', async () => {
+  vi.stubGlobal('process', { ...process, platform: 'win32' });
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, 'timeout', '2026-09-01T12:00:01.000Z');
+  vi.spyOn(fs, 'open').mockRejectedValue(
+    Object.assign(new Error('Permission denied'), { code: 'EPERM' })
+  );
+  vi.spyOn(Date, 'now').mockReturnValueOnce(0).mockReturnValueOnce(0).mockReturnValue(40_000);
+
+  await expect(writeTestRunHistory(docsRoot, report)).rejects.toThrow(
+    'Timed out updating mint test run history'
+  );
+});
+
+it('does not retry a token write failure after acquiring the Windows lock', async () => {
+  vi.stubGlobal('process', { ...process, platform: 'win32' });
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, 'token-failure', '2026-09-01T12:00:01.000Z');
+  const error = Object.assign(new Error('Cannot write token'), { code: 'EPERM' });
+  const realOpen = fs.open;
+  const open = vi.spyOn(fs, 'open').mockImplementationOnce(async (...args) => {
+    const handle = await realOpen(...args);
+    vi.spyOn(handle, 'writeFile').mockRejectedValueOnce(error);
+    return handle;
+  });
+
+  await expect(writeTestRunHistory(docsRoot, report)).rejects.toBe(error);
+  expect(open).toHaveBeenCalledTimes(1);
+});
+
 it('recovers a stale history lock left by an interrupted process', async () => {
   const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
   temporaryDirectories.push(docsRoot);

package/bin/agent-harness/runHistory.js

@@ -144,30 +144,34 @@ function acquireIndexLock(docsRoot) {
         const token = `${process.pid}:${randomUUID()}`;
         const deadline = Date.now() + LOCK_TIMEOUT_MS;
         while (Date.now() < deadline) {
+            let lock;
             try {
-                const lock = yield fs.open(lockPath, 'wx');
-                try {
-                    yield lock.writeFile(token);
-                }
-                finally {
-                    yield lock.close();
-                }
-                return () => __awaiter(this, void 0, void 0, function* () {
-                    const owner = yield fs.readFile(lockPath, 'utf8').catch(() => undefined);
-                    if (owner === token)
-                        yield fs.unlink(lockPath).catch(() => undefined);
-                });
+                lock = yield fs.open(lockPath, 'wx');
             }
             catch (error) {
-                if (errorCode(error) !== 'EEXIST')
+                const code = errorCode(error);
+                // Windows can deny opening a lock while another writer's deletion is still pending.
+                if (code !== 'EEXIST' && !(process.platform === 'win32' && code === 'EPERM'))
                     throw error;
-            }
-            const stats = yield fs.stat(lockPath).catch(() => undefined);
-            if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
-                yield fs.unlink(lockPath).catch(() => undefined);
+                const stats = yield fs.stat(lockPath).catch(() => undefined);
+                if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+                    yield fs.unlink(lockPath).catch(() => undefined);
+                    continue;
+                }
+                yield delay(LOCK_RETRY_MS);
                 continue;
             }
-            yield delay(LOCK_RETRY_MS);
+            try {
+                yield lock.writeFile(token);
+            }
+            finally {
+                yield lock.close();
+            }
+            return () => __awaiter(this, void 0, void 0, function* () {
+                const owner = yield fs.readFile(lockPath, 'utf8').catch(() => undefined);
+                if (owner === token)
+                    yield fs.unlink(lockPath).catch(() => undefined);
+            });
         }
         throw new Error('Timed out updating mint test run history');
     });