@pygmalionjs/pygmalion 0.2.25 → 0.2.26

package/node/dev-mirror.mjs

@@ -47,6 +47,74 @@ export function devMirrorRefSlug(ref) {
   return createHash('sha256').update(raw).digest('hex').slice(0, 12);
 }
 
+/**
+ * Identity of the project a mirror checkout belongs to.
+ *
+ * Two worktrees of one repository configure the same mirror path, and each
+ * generates its own inventory into it. Sharing one checkout made each server see
+ * the other's generated files as unexpected changes and refuse to sync, so a
+ * checkout is claimed by the project that syncs it.
+ */
+export function devMirrorOwnerToken(repoRoot, appDirectory = '') {
+  const identity = `${path.resolve(repoRoot)}\u0000${appDirectory}`;
+  return createHash('sha256').update(identity).digest('hex').slice(0, 10);
+}
+
+// The claim lives beside the repository's other Pygmalion state, not inside the
+// checkout: a file in the worktree would itself be an unexpected change.
+async function mirrorClaimFile(repoRoot, mirrorRoot) {
+  const directory = path.join(await pygmalionStateDirectory(repoRoot), 'mirror-claims');
+  const key = createHash('sha256').update(path.resolve(mirrorRoot)).digest('hex').slice(0, 16);
+  return path.join(directory, `${key}.json`);
+}
+
+function isPlainMirrorStamp(value) {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    typeof value.owner === 'string' &&
+    value.owner.length > 0
+  );
+}
+
+/**
+ * Whether this project may sync the checkout at `mirrorRoot`.
+ *
+ * An unclaimed or self-claimed checkout is ours. One claimed by another project is
+ * not, and the caller moves to its own path rather than fighting over this one —
+ * which is what two worktrees of one repository were doing every time they
+ * regenerated their own inventory into the same directory.
+ */
+export async function devMirrorClaim(repoRoot, mirrorRoot, owner) {
+  let stamp = null;
+  try {
+    const raw = await fsp.readFile(await mirrorClaimFile(repoRoot, mirrorRoot), 'utf8');
+    const parsed = JSON.parse(raw);
+    stamp = isPlainMirrorStamp(parsed) ? parsed : null;
+  } catch {
+    stamp = null;
+  }
+  if (!stamp) return { owned: true, previousOwner: null };
+  return { owned: stamp.owner === owner, previousOwner: stamp.owner };
+}
+
+export async function claimDevMirror(repoRoot, mirrorRoot, owner) {
+  const file = await mirrorClaimFile(repoRoot, mirrorRoot);
+  await fsp.mkdir(path.dirname(file), { recursive: true });
+  await fsp
+    .writeFile(
+      file,
+      `${JSON.stringify({
+        owner,
+        repoRoot: path.resolve(repoRoot),
+        mirrorRoot: path.resolve(mirrorRoot),
+        claimedAt: new Date().toISOString(),
+      })}\n`,
+    )
+    .catch(() => undefined);
+}
+
 /**
  * One checkout per ref. Two editor servers pointed at different refs used to
  * share a single mirror directory and take turns running `git switch` in it, so
@@ -59,16 +127,17 @@ export function resolveDevMirrorWorktreePaths({
   mirrorAppRoot,
   appDirectory = '',
   ref = null,
+  owner = null,
 }) {
   const base = path.resolve(mirrorRoot);
-  const slug = devMirrorRefSlug(ref);
-  if (!slug) {
+  const parts = [devMirrorRefSlug(ref), owner ? String(owner) : ''].filter(Boolean);
+  if (!parts.length) {
     return {
       mirrorRoot: base,
       mirrorAppRoot: path.resolve(mirrorAppRoot ?? path.join(base, appDirectory)),
     };
   }
-  const scoped = `${base}-${slug}`;
+  const scoped = `${base}-${parts.join('-')}`;
   return {
     mirrorRoot: scoped,
     mirrorAppRoot: path.resolve(path.join(scoped, appDirectory)),
@@ -582,6 +651,9 @@ export function pygmalionDevMirrorPlugin(options) {
   );
   // The ref is repointable at runtime and each ref owns its own checkout, so the
   // active paths are recomputed per sync instead of frozen at plugin creation.
+  const ownerToken = devMirrorOwnerToken(repoRoot, appDirectory);
+  // Set once the base checkout turns out to belong to another project.
+  let mirrorOwnerScope = null;
   let mirrorRoot = mirrorBaseRoot;
   let mirrorAppRoot = mirrorAppOverride ?? path.join(mirrorBaseRoot, appDirectory);
   let viteConfig = viteConfigOverride ?? path.join(mirrorAppRoot, 'vite.config.ts');
@@ -598,6 +670,7 @@ export function pygmalionDevMirrorPlugin(options) {
       mirrorAppRoot: mirrorAppOverride,
       appDirectory,
       ref: activeRef,
+      owner: mirrorOwnerScope,
     });
     mirrorRoot = resolved.mirrorRoot;
     mirrorAppRoot = resolved.mirrorAppRoot;
@@ -729,6 +802,24 @@ export function pygmalionDevMirrorPlugin(options) {
     const lockHash = await fileHash(lockFile);
     const stamp = await fsp.readFile(stampFile, 'utf8').catch(() => '');
     if ((await exists(nodeModules)) && stamp.trim() === lockHash) return false;
+    // An owner-scoped checkout is a second copy of the same source. Borrowing the
+    // base checkout's modules when the lock file agrees keeps that isolation from
+    // costing a full install per project.
+    if (!(await exists(nodeModules)) && mirrorOwnerScope) {
+      const baseModules = path.join(
+        mirrorAppOverride ?? path.join(mirrorBaseRoot, appDirectory),
+        dependencies.modulesDirectory ?? 'node_modules',
+      );
+      const baseLock = path.join(
+        mirrorAppOverride ?? path.join(mirrorBaseRoot, appDirectory),
+        dependencies.lockFile ?? 'package-lock.json',
+      );
+      const baseLockHash = await fileHash(baseLock).catch(() => null);
+      if ((await exists(baseModules)) && baseLockHash === lockHash) {
+        await fsp.symlink(baseModules, nodeModules, 'dir').catch(() => undefined);
+        if (await exists(nodeModules)) return false;
+      }
+    }
     await run(
       dependencies.installCommand ?? 'npm',
       dependencies.installArgs ?? ['install', '--no-audit', '--no-fund'],
@@ -840,6 +931,13 @@ export function pygmalionDevMirrorPlugin(options) {
     if (syncPromise) return syncPromise;
     applyMirrorPathsForRef(ref);
     syncPromise = (async () => {
+      // A checkout another project claimed is not ours to regenerate into. Moving
+      // to our own path is what ends the tug of war between two worktrees.
+      const claim = await devMirrorClaim(repoRoot, mirrorRoot, ownerToken);
+      if (!claim.owned && mirrorOwnerScope !== ownerToken) {
+        mirrorOwnerScope = ownerToken;
+        applyMirrorPathsForRef(ref);
+      }
       status = { ...status, state: 'syncing', error: null, warning: null };
       let warning = null;
       try {
@@ -859,6 +957,7 @@ export function pygmalionDevMirrorPlugin(options) {
           });
           warning = mirrorState.warning;
           const { previous, commit, shortCommit } = mirrorState;
+          await claimDevMirror(repoRoot, mirrorRoot, ownerToken);
           const dependenciesChanged = await syncDependencies();
           await generateInventory(commit);
           await startPreview(dependenciesChanged);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pygmalionjs/pygmalion",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Code-backed DOM design sandbox and visual QA editor",
   "license": "UNLICENSED",
   "publishConfig": {