@pygmalionjs/pygmalion 0.5.13 → 0.5.14

package/node/dev-mirror.mjs

@@ -25,6 +25,9 @@ const SHARED_LOCK_STALE_MS = 30_000;
 const STATUS_VERIFY_TTL_MS = 1_000;
 const LEASE_STALE_MS = 30_000;
 const LEASE_HEARTBEAT_MS = 2_000;
+// A mirror younger than this is left alone even with no lease on it. Building one
+// costs a checkout and a dependency install, so the reaper errs toward keeping.
+const DEFAULT_MIRROR_GRACE_MS = 6 * 60 * 60 * 1_000;
 const LEASE_WAIT_TIMEOUT_MS = 180_000;
 
 export function resolveDevMirrorInventoryOutputRoot(inventory, mirrorAppRoot) {
@@ -285,6 +288,87 @@ export async function listSourceRefs(repoRoot, remote = 'origin') {
   });
 }
 
+/**
+ * Removes mirror checkouts nobody is using any more.
+ *
+ * Every revision the editor is pointed at gets its own checkout, and until now
+ * nothing ever took one away — the only worktree verb in this module was `add`.
+ * A day of switching branches leaves a row of full checkouts (measured: 4 of
+ * them at ~500MB each, and a machine that had accumulated 35).
+ *
+ * Three things protect a checkout from being reaped, because "unused" is not
+ * something a single server can see on its own:
+ *   the active one — this server is rendering from it right now
+ *   a live lease   — a capture is reading it, or another editor is serving it
+ *                    (the serve lease is what makes a concurrent editor visible)
+ *   the grace window — a checkout younger than `graceMs`, so a mirror that was
+ *                    just built for a ref nobody has leased yet survives
+ *
+ * Removal is best effort: a checkout with local edits, or one git refuses for
+ * any other reason, is left alone and reported rather than forced away.
+ */
+export async function reapDevMirrorWorktrees({
+  repoRoot,
+  mirrorBaseRoot,
+  keep = [],
+  graceMs = DEFAULT_MIRROR_GRACE_MS,
+  now = Date.now(),
+}) {
+  // git reports worktrees by their real path, so a configured path that crosses a
+  // symlink (macOS `/tmp` and `/var` both do) would never match by string alone.
+  // The base itself is a naming prefix, not necessarily a directory that exists,
+  // so fall back to resolving it inside its parent — otherwise the prefix stays
+  // in `/var` while every listed worktree comes back as `/private/var`.
+  const real = async (target) => {
+    const resolved = path.resolve(target);
+    const direct = await fsp.realpath(resolved).catch(() => null);
+    if (direct) return direct;
+    const parent = await fsp.realpath(path.dirname(resolved)).catch(() => null);
+    return parent ? path.join(parent, path.basename(resolved)) : resolved;
+  };
+  const base = await real(mirrorBaseRoot);
+  const kept = new Set(await Promise.all(keep.filter(Boolean).map(real)));
+  const raw = await git(repoRoot, 'worktree', 'list', '--porcelain').catch(() => '');
+  const candidates = (
+    await Promise.all(
+      raw
+        .split('\n')
+        .filter((line) => line.startsWith('worktree '))
+        .map((line) => real(line.slice('worktree '.length).trim())),
+    )
+  )
+    // Only this project's mirrors. A sibling directory that merely starts with
+    // the same characters would need the separator to match too.
+    .filter((entry) => entry === base || entry.startsWith(`${base}-`))
+    .filter((entry) => !kept.has(entry));
+
+  const removed = [];
+  const skipped = [];
+  for (const candidate of candidates) {
+    const leases = await freshLeases(repoRoot, candidate);
+    if (leases.length > 0) {
+      skipped.push({ path: candidate, reason: 'leased', labels: leases.map((l) => l.label) });
+      continue;
+    }
+    const stat = await fsp.stat(candidate).catch(() => null);
+    if (stat && now - stat.mtimeMs < graceMs) {
+      skipped.push({ path: candidate, reason: 'recent' });
+      continue;
+    }
+    try {
+      await git(repoRoot, 'worktree', 'remove', '--force', candidate);
+      removed.push(candidate);
+    } catch (error) {
+      skipped.push({
+        path: candidate,
+        reason: 'remove-failed',
+        error: error instanceof Error ? error.message.split('\n')[0] : String(error),
+      });
+    }
+  }
+  return { removed, skipped };
+}
+
 async function pygmalionStateDirectory(repoRoot) {
   const rawCommonGitDir = await git(repoRoot, 'rev-parse', '--git-common-dir');
   return path.join(path.resolve(repoRoot, rawCommonGitDir), 'pygmalion');
@@ -748,6 +832,28 @@ export function pygmalionDevMirrorPlugin(options) {
   const preferredPreviewPort =
     Number(process.env.PYGMALION_DEV_PREVIEW_PORT) || options.previewPort || DEFAULT_PREVIEW_PORT;
 
+  // Held for as long as this server renders from a mirror, so a reaper — ours or
+  // another editor's — can tell a live checkout from an abandoned one. Capture
+  // leases are short and come and go; this one spans the session.
+  let serveLease = null;
+  const holdServeLease = async (activeRoot) => {
+    if (serveLease?.mirrorRoot === activeRoot) return;
+    const previous = serveLease;
+    serveLease = null;
+    await previous?.lease.release().catch(() => undefined);
+    const lease = await acquireDevMirrorLease({
+      repoRoot,
+      mirrorRoot: activeRoot,
+      label: 'serve',
+    }).catch(() => null);
+    if (lease) serveLease = { mirrorRoot: activeRoot, lease };
+  };
+  const releaseServeLease = async () => {
+    const held = serveLease;
+    serveLease = null;
+    await held?.lease.release().catch(() => undefined);
+  };
+
   let previewChild = null;
   let previewPort = null;
   let syncPromise = null;
@@ -954,6 +1060,8 @@ export function pygmalionDevMirrorPlugin(options) {
         env: {
           ...process.env,
           PYGMALION_PREVIEW_MODE: '1',
+          // The child outlives a killed parent otherwise — it watches this pid.
+          PYGMALION_PREVIEW_PARENT_PID: String(process.pid),
           PYGMALION_APP_ROOT: mirrorAppRoot,
           PYGMALION_VITE_CONFIG: viteConfig,
           PYGMALION_PREVIEW_BASE: `${prefix}/`,
@@ -1003,6 +1111,8 @@ export function pygmalionDevMirrorPlugin(options) {
         mirrorOwnerScope = ownerToken;
         applyMirrorPathsForRef(ref);
       }
+      // After the path is settled, not before — the claim above can move it.
+      await holdServeLease(mirrorRoot);
       status = { ...status, state: 'syncing', error: null, warning: null };
       let warning = null;
       try {
@@ -1069,9 +1179,40 @@ export function pygmalionDevMirrorPlugin(options) {
     configureServer(server) {
       server.httpServer?.once('close', () => {
         void stopPreview();
+        void releaseServeLease();
+      });
+      // A killed editor never reaches the close hook, and the preview is a
+      // detached-enough child that it keeps serving a checkout nobody owns —
+      // measured: three of them still listening on a directory already removed.
+      // Signals cover the ordinary exits; the child watches its parent for the
+      // rest (see PYGMALION_PREVIEW_PARENT_PID in dev-view.vite.mjs).
+      for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => {
+          void stopPreview();
+          void releaseServeLease();
+        });
+      }
+      process.once('exit', () => {
+        previewChild?.kill('SIGTERM');
       });
       // Synchronizes once when the editor server runs. Screen mount and manual refresh requests reuse the same Promise.
-      void syncMirror();
+      void syncMirror().then(() =>
+        reapDevMirrorWorktrees({
+          repoRoot,
+          mirrorBaseRoot,
+          keep: [mirrorRoot],
+        })
+          .then(({ removed }) => {
+            if (removed.length > 0) {
+              console.log(
+                `[pygmalion] released ${removed.length} unused dev screen checkout(s): ${removed
+                  .map((entry) => path.basename(entry))
+                  .join(', ')}`,
+              );
+            }
+          })
+          .catch(() => undefined),
+      );
 
       server.middlewares.use(async (req, res, next) => {
         const url = new URL(req.url ?? '/', 'http://localhost');

package/node/dev-view.vite.mjs

@@ -23,6 +23,43 @@ const previewCacheDir = process.env.PYGMALION_VITE_CACHE_DIR
   : undefined;
 export const PREVIEW_RUNTIME_DEDUPE = ['react', 'react-dom'];
 
+const PARENT_WATCH_INTERVAL_MS = 5_000;
+
+/**
+ * Exits when the editor that spawned this preview is gone.
+ *
+ * The parent stops the preview on close and on the usual signals, but a killed
+ * editor (`pkill`, a crash) never runs any of that, and this process keeps
+ * serving a checkout nobody owns — measured: three previews still listening on a
+ * mirror directory that had already been removed. Signal 0 only asks whether the
+ * pid is still there; it sends nothing.
+ */
+export function watchParentProcess({
+  parentPid = Number(process.env.PYGMALION_PREVIEW_PARENT_PID) || null,
+  intervalMs = PARENT_WATCH_INTERVAL_MS,
+  isAlive = (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      // A live process owned by another user answers EPERM, not ESRCH.
+      return error?.code === 'EPERM';
+    }
+  },
+  onOrphaned = () => process.exit(0),
+} = {}) {
+  if (!parentPid) return null;
+  const timer = setInterval(() => {
+    if (isAlive(parentPid)) return;
+    clearInterval(timer);
+    onOrphaned();
+  }, intervalMs);
+  timer.unref();
+  return timer;
+}
+
+watchParentProcess();
+
 function previewRuntimePlugin() {
   return {
     name: 'pygmalion-dev-preview-runtime',

package/package.json

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