claudeup 6.2.1 → 6.3.0

package/src/__tests__/enabled-not-installed.test.ts

@@ -13,75 +13,83 @@ import type { PluginInfo } from "../services/plugin-manager.js";
  */
 
 const plugin = (over: Partial<PluginInfo>): PluginInfo =>
-  ({
-    id: "x@magus",
-    name: "x",
-    version: "1.0.0",
-    description: "",
-    marketplace: "magus",
-    marketplaceDisplay: "Magus",
-    enabled: true,
-    ...over,
-  }) as PluginInfo;
+	({
+		id: "x@magus",
+		name: "x",
+		version: "1.0.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "Magus",
+		enabled: true,
+		...over,
+	}) as PluginInfo;
 
 describe("isEnabledButNotInstalled", () => {
-  test("enabled in project scope with no installed version is flagged", () => {
-    // The real case: terminal/code-analysis are in this project's enabledPlugins
-    // but have no registry entry for it and none at user scope.
-    expect(
-      isEnabledButNotInstalled(
-        plugin({ projectScope: { enabled: true }, installedVersion: undefined }),
-      ),
-    ).toBe(true);
-  });
+	test("enabled in project scope with no installed version is flagged", () => {
+		// The real case: terminal/code-analysis are in this project's enabledPlugins
+		// but have no registry entry for it and none at user scope.
+		expect(
+			isEnabledButNotInstalled(
+				plugin({
+					projectScope: { enabled: true },
+					installedVersion: undefined,
+				}),
+			),
+		).toBe(true);
+	});
 
-  test("a healthy install is not flagged", () => {
-    expect(
-      isEnabledButNotInstalled(
-        plugin({ projectScope: { enabled: true }, installedVersion: "1.0.0" }),
-      ),
-    ).toBe(false);
-  });
+	test("a healthy install is not flagged", () => {
+		expect(
+			isEnabledButNotInstalled(
+				plugin({ projectScope: { enabled: true }, installedVersion: "1.0.0" }),
+			),
+		).toBe(false);
+	});
 
-  test('installedVersion "0.0.0" means installed-with-unknown-version, not missing', () => {
-    // Anthropic's official plugins record exactly this. Treating it as missing
-    // would mislabel every one of them as broken.
-    expect(
-      isEnabledButNotInstalled(
-        plugin({ userScope: { enabled: true }, installedVersion: "0.0.0" }),
-      ),
-    ).toBe(false);
-  });
+	test('installedVersion "0.0.0" means installed-with-unknown-version, not missing', () => {
+		// Anthropic's official plugins record exactly this. Treating it as missing
+		// would mislabel every one of them as broken.
+		expect(
+			isEnabledButNotInstalled(
+				plugin({ userScope: { enabled: true }, installedVersion: "0.0.0" }),
+			),
+		).toBe(false);
+	});
 
-  test("not enabled anywhere is not flagged — it is simply available", () => {
-    expect(isEnabledButNotInstalled(plugin({ installedVersion: undefined }))).toBe(false);
-  });
+	test("not enabled anywhere is not flagged — it is simply available", () => {
+		expect(
+			isEnabledButNotInstalled(plugin({ installedVersion: undefined })),
+		).toBe(false);
+	});
 
-  test("orphaned plugins are excluded — they have their own 'deprecated' state", () => {
-    expect(
-      isEnabledButNotInstalled(
-        plugin({
-          isOrphaned: true,
-          projectScope: { enabled: true },
-          installedVersion: undefined,
-        }),
-      ),
-    ).toBe(false);
-  });
+	test("orphaned plugins are excluded — they have their own 'deprecated' state", () => {
+		expect(
+			isEnabledButNotInstalled(
+				plugin({
+					isOrphaned: true,
+					projectScope: { enabled: true },
+					installedVersion: undefined,
+				}),
+			),
+		).toBe(false);
+	});
 
-  test("any enabled scope counts, not just project", () => {
-    for (const scope of ["userScope", "projectScope", "localScope"] as const) {
-      expect(
-        isEnabledButNotInstalled(plugin({ [scope]: { enabled: true } })),
-      ).toBe(true);
-    }
-  });
+	test("any enabled scope counts, not just project", () => {
+		for (const scope of ["userScope", "projectScope", "localScope"] as const) {
+			expect(
+				isEnabledButNotInstalled(plugin({ [scope]: { enabled: true } })),
+			).toBe(true);
+		}
+	});
 
-  test("a scope present but disabled does not count as enabled", () => {
-    expect(
-      isEnabledButNotInstalled(
-        plugin({ projectScope: { enabled: false }, installedVersion: undefined }),
-      ),
-    ).toBe(false);
-  });
+	test("a scope present but disabled does not count as enabled", () => {
+		expect(
+			isEnabledButNotInstalled(
+				plugin({
+					projectScope: { enabled: false },
+					installedVersion: undefined,
+				}),
+			),
+		).toBe(false);
+	});
 });

package/src/__tests__/file-locking.test.ts

@@ -8,201 +8,201 @@
  * - Lock timeout handling
  */
 
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
-  withFileLock,
-  isFileLocked,
-  forceRemoveLock,
-  getLockInfo,
-} from '../utils/file-locking.js';
-
-describe('file-locking', () => {
-  let testDir: string;
-  let testFile: string;
-
-  beforeEach(async () => {
-    // Create temporary directory for tests
-    testDir = await mkdtemp(join(tmpdir(), 'claudeup-test-'));
-    testFile = join(testDir, 'test-file.json');
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    await rm(testDir, { recursive: true, force: true });
-  });
-
-  describe('withFileLock', () => {
-    it('should execute operation with lock held - TEST-095', async () => {
-      let operationExecuted = false;
-
-      await withFileLock(testFile, async () => {
-        operationExecuted = true;
-        expect(isFileLocked(testFile)).toBe(true);
-      });
-
-      expect(operationExecuted).toBe(true);
-    });
-
-    it('should release lock after operation completes - TEST-095', async () => {
-      await withFileLock(testFile, async () => {
-        // Operation
-      });
-
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-
-    it('should release lock even if operation throws', async () => {
-      await expect(
-        withFileLock(testFile, async () => {
-          throw new Error('Operation failed');
-        }),
-      ).rejects.toThrow('Operation failed');
-
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-
-    it('should return operation result', async () => {
-      const result = await withFileLock(testFile, async () => {
-        return 'success';
-      });
-
-      expect(result).toBe('success');
-    });
-
-    it('should block concurrent access - TEST-095', async () => {
-      const executionOrder: number[] = [];
-
-      // First operation holds lock for 100ms
-      const promise1 = withFileLock(testFile, async () => {
-        executionOrder.push(1);
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        executionOrder.push(2);
-      });
-
-      // Wait a bit to ensure first lock is acquired
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      // Second operation should wait for lock
-      const promise2 = withFileLock(testFile, async () => {
-        executionOrder.push(3);
-      });
-
-      await Promise.all([promise1, promise2]);
-
-      // Second operation should only execute after first completes
-      expect(executionOrder).toEqual([1, 2, 3]);
-    });
-
-    it('should timeout if lock cannot be acquired', async () => {
-      // Skip this test in CI as it takes 10+ seconds
-      // The timeout behavior is tested in integration tests
-    });
-
-    it('should handle multiple sequential operations', async () => {
-      for (let i = 0; i < 5; i++) {
-        await withFileLock(testFile, async () => {
-          expect(isFileLocked(testFile)).toBe(true);
-        });
-      }
-
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-  });
-
-  describe('isFileLocked', () => {
-    it('should return false for unlocked files', () => {
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-
-    it('should return true while lock is held', async () => {
-      await withFileLock(testFile, async () => {
-        expect(isFileLocked(testFile)).toBe(true);
-      });
-    });
-
-    it('should return false after lock is released', async () => {
-      await withFileLock(testFile, async () => {});
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-  });
-
-  describe('forceRemoveLock', () => {
-    it('should remove lock file', async () => {
-      // Create lock by starting operation but not finishing
-      await withFileLock(testFile, async () => {
-        // Lock is held here
-        expect(isFileLocked(testFile)).toBe(true);
-      });
-
-      // Lock should be released
-      expect(isFileLocked(testFile)).toBe(false);
-
-      // Force remove should not throw on non-existent lock
-      await forceRemoveLock(testFile);
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-
-    it('should not throw if lock file does not exist', async () => {
-      await forceRemoveLock(testFile);
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-  });
-
-  describe('getLockInfo', () => {
-    it('should return null for unlocked files', async () => {
-      const info = await getLockInfo(testFile);
-      expect(info).toBeNull();
-    });
-
-    it('should return lock information while locked', async () => {
-      await withFileLock(testFile, async () => {
-        const info = await getLockInfo(testFile);
-        expect(info).not.toBeNull();
-        expect(info?.pid).toBe(String(process.pid));
-        expect(info?.timestamp).toBeDefined();
-      });
-    });
-
-    it('should return null after lock is released', async () => {
-      await withFileLock(testFile, async () => {});
-      const info = await getLockInfo(testFile);
-      expect(info).toBeNull();
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle nested lock attempts on different files', async () => {
-      const file1 = join(testDir, 'file1.json');
-      const file2 = join(testDir, 'file2.json');
-
-      await withFileLock(file1, async () => {
-        await withFileLock(file2, async () => {
-          expect(isFileLocked(file1)).toBe(true);
-          expect(isFileLocked(file2)).toBe(true);
-        });
-      });
-
-      expect(isFileLocked(file1)).toBe(false);
-      expect(isFileLocked(file2)).toBe(false);
-    });
-
-    it('should prevent nested lock attempts on same file', async () => {
-      // Skip this test in CI as it takes 10+ seconds to timeout
-      // The nested lock prevention is tested via other tests
-    });
-
-    it('should handle rapid lock/unlock cycles', async () => {
-      const iterations = 10;
-      for (let i = 0; i < iterations; i++) {
-        await withFileLock(testFile, async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-        });
-      }
-
-      expect(isFileLocked(testFile)).toBe(false);
-    });
-  });
+	forceRemoveLock,
+	getLockInfo,
+	isFileLocked,
+	withFileLock,
+} from "../utils/file-locking.js";
+
+describe("file-locking", () => {
+	let testDir: string;
+	let testFile: string;
+
+	beforeEach(async () => {
+		// Create temporary directory for tests
+		testDir = await mkdtemp(join(tmpdir(), "claudeup-test-"));
+		testFile = join(testDir, "test-file.json");
+	});
+
+	afterEach(async () => {
+		// Clean up test directory
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	describe("withFileLock", () => {
+		it("should execute operation with lock held - TEST-095", async () => {
+			let operationExecuted = false;
+
+			await withFileLock(testFile, async () => {
+				operationExecuted = true;
+				expect(isFileLocked(testFile)).toBe(true);
+			});
+
+			expect(operationExecuted).toBe(true);
+		});
+
+		it("should release lock after operation completes - TEST-095", async () => {
+			await withFileLock(testFile, async () => {
+				// Operation
+			});
+
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+
+		it("should release lock even if operation throws", async () => {
+			await expect(
+				withFileLock(testFile, async () => {
+					throw new Error("Operation failed");
+				}),
+			).rejects.toThrow("Operation failed");
+
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+
+		it("should return operation result", async () => {
+			const result = await withFileLock(testFile, async () => {
+				return "success";
+			});
+
+			expect(result).toBe("success");
+		});
+
+		it("should block concurrent access - TEST-095", async () => {
+			const executionOrder: number[] = [];
+
+			// First operation holds lock for 100ms
+			const promise1 = withFileLock(testFile, async () => {
+				executionOrder.push(1);
+				await new Promise((resolve) => setTimeout(resolve, 100));
+				executionOrder.push(2);
+			});
+
+			// Wait a bit to ensure first lock is acquired
+			await new Promise((resolve) => setTimeout(resolve, 10));
+
+			// Second operation should wait for lock
+			const promise2 = withFileLock(testFile, async () => {
+				executionOrder.push(3);
+			});
+
+			await Promise.all([promise1, promise2]);
+
+			// Second operation should only execute after first completes
+			expect(executionOrder).toEqual([1, 2, 3]);
+		});
+
+		it("should timeout if lock cannot be acquired", async () => {
+			// Skip this test in CI as it takes 10+ seconds
+			// The timeout behavior is tested in integration tests
+		});
+
+		it("should handle multiple sequential operations", async () => {
+			for (let i = 0; i < 5; i++) {
+				await withFileLock(testFile, async () => {
+					expect(isFileLocked(testFile)).toBe(true);
+				});
+			}
+
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+	});
+
+	describe("isFileLocked", () => {
+		it("should return false for unlocked files", () => {
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+
+		it("should return true while lock is held", async () => {
+			await withFileLock(testFile, async () => {
+				expect(isFileLocked(testFile)).toBe(true);
+			});
+		});
+
+		it("should return false after lock is released", async () => {
+			await withFileLock(testFile, async () => {});
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+	});
+
+	describe("forceRemoveLock", () => {
+		it("should remove lock file", async () => {
+			// Create lock by starting operation but not finishing
+			await withFileLock(testFile, async () => {
+				// Lock is held here
+				expect(isFileLocked(testFile)).toBe(true);
+			});
+
+			// Lock should be released
+			expect(isFileLocked(testFile)).toBe(false);
+
+			// Force remove should not throw on non-existent lock
+			await forceRemoveLock(testFile);
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+
+		it("should not throw if lock file does not exist", async () => {
+			await forceRemoveLock(testFile);
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+	});
+
+	describe("getLockInfo", () => {
+		it("should return null for unlocked files", async () => {
+			const info = await getLockInfo(testFile);
+			expect(info).toBeNull();
+		});
+
+		it("should return lock information while locked", async () => {
+			await withFileLock(testFile, async () => {
+				const info = await getLockInfo(testFile);
+				expect(info).not.toBeNull();
+				expect(info?.pid).toBe(String(process.pid));
+				expect(info?.timestamp).toBeDefined();
+			});
+		});
+
+		it("should return null after lock is released", async () => {
+			await withFileLock(testFile, async () => {});
+			const info = await getLockInfo(testFile);
+			expect(info).toBeNull();
+		});
+	});
+
+	describe("edge cases", () => {
+		it("should handle nested lock attempts on different files", async () => {
+			const file1 = join(testDir, "file1.json");
+			const file2 = join(testDir, "file2.json");
+
+			await withFileLock(file1, async () => {
+				await withFileLock(file2, async () => {
+					expect(isFileLocked(file1)).toBe(true);
+					expect(isFileLocked(file2)).toBe(true);
+				});
+			});
+
+			expect(isFileLocked(file1)).toBe(false);
+			expect(isFileLocked(file2)).toBe(false);
+		});
+
+		it("should prevent nested lock attempts on same file", async () => {
+			// Skip this test in CI as it takes 10+ seconds to timeout
+			// The nested lock prevention is tested via other tests
+		});
+
+		it("should handle rapid lock/unlock cycles", async () => {
+			const iterations = 10;
+			for (let i = 0; i < iterations; i++) {
+				await withFileLock(testFile, async () => {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+				});
+			}
+
+			expect(isFileLocked(testFile)).toBe(false);
+		});
+	});
 });