superpowers-mcp 6.4.1 → 6.4.3

package/scripts/setup.js

@@ -7,16 +7,109 @@
 const path = require("path");
 const fs = require("fs");
 
-const compiledRunner = path.join(__dirname, "..", "out", "setup-runner.js");
+const repoRoot = path.join(__dirname, "..");
+const compiledRunner = path.join(repoRoot, "out", "setup-runner.js");
+const lockPath = path.join(repoRoot, "out", ".setup-build.lock");
 
-if (!fs.existsSync(compiledRunner)) {
-    const { execSync } = require("child_process");
+const inputFiles = [
+    path.join(repoRoot, "src", "setup-runner.ts"),
+    path.join(repoRoot, "src", "setup-cli.ts"),
+    path.join(repoRoot, "esbuild.js"),
+    path.join(repoRoot, "package.json"),
+];
+
+function sleepSync(ms) {
+    // Portable synchronous sleep; blocks this thread while waiting on the lock.
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function newestInputMtime() {
+    let newest = 0;
+    for (const file of inputFiles) {
+        try {
+            newest = Math.max(newest, fs.statSync(file).mtimeMs);
+        } catch {
+            // Ignore missing inputs.
+        }
+    }
+    return newest;
+}
+
+// Rebuild when the output is missing OR any build input is newer, so edits to the
+// sources are never silently ignored (the old check only tested for existence).
+function needsBuild() {
+    if (!fs.existsSync(compiledRunner)) {
+        return true;
+    }
+    try {
+        return fs.statSync(compiledRunner).mtimeMs < newestInputMtime();
+    } catch {
+        return true;
+    }
+}
+
+function acquireLock() {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    try {
+        fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+    } catch (err) {
+        if (err && err.code === "EEXIST") {
+            return false; // another build holds the lock
+        }
+        // Unexpected lock error (e.g. permissions) — proceed without exclusion; the
+        // build itself will surface any real failure.
+        return true;
+    }
+}
+
+function releaseLock() {
     try {
-        execSync("node esbuild.js", { cwd: path.join(__dirname, ".."), stdio: "inherit" });
-    } catch (e) {
-        console.error("Failed to build out/setup-runner.js automatically:", e.message);
+        fs.unlinkSync(lockPath);
+    } catch {
+        // Ignore: we may not own it.
+    }
+}
+
+function lockIsStale() {
+    try {
+        return Date.now() - fs.statSync(lockPath).mtimeMs > 120000;
+    } catch {
+        return false; // already gone
+    }
+}
+
+if (needsBuild()) {
+    const { execSync } = require("child_process");
+
+    const deadline = Date.now() + 60000;
+    let owned = acquireLock();
+
+    // Wait for a concurrent build to finish (and release the lock) before building,
+    // so two invocations never run esbuild at once and interleave writes to out/*.
+    while (!owned && needsBuild() && Date.now() < deadline) {
+        if (lockIsStale()) {
+            releaseLock();
+            owned = acquireLock();
+            break;
+        }
+        sleepSync(250);
+    }
+
+    if (owned) {
+        try {
+            execSync("node esbuild.js", { cwd: repoRoot, stdio: "inherit" });
+        } catch (e) {
+            console.error("Failed to build out/setup-runner.js automatically:", e.message);
+            process.exit(1);
+        } finally {
+            releaseLock();
+        }
+    } else if (needsBuild()) {
+        console.error("Timed out waiting for a concurrent build of out/setup-runner.js.");
         process.exit(1);
     }
+    // If !owned but !needsBuild(), another process finished the build — reuse it.
 }
 
 const runner = require(compiledRunner);

package/scripts/upstream-drift.js

@@ -58,6 +58,7 @@ function parseArgs(argv) {
         else if (arg === "--ref" || arg === "--repo" || arg === "--ignore") {
             const value = argv[++i];
             if (!value) throw new Error(`Missing value for ${arg}`);
+            if (value.startsWith("--")) throw new Error(`Missing value for ${arg} (got "${value}")`);
             if (arg === "--ref") opts.ref = value;
             else if (arg === "--repo") opts.repo = value;
             else opts.ignore.push(value);
@@ -269,19 +270,46 @@ async function main() {
         }
         const upstreamSkills = [...new Set(Object.keys(tree.files).map(skillNameOf).filter(Boolean))].sort();
         const recorded = { repo, ref, commit: tree.commit, capturedAt: new Date().toISOString().slice(0, 10), files, upstreamSkills, ignoredUpstreamSkills: ignored };
-        fs.writeFileSync(BASELINE_PATH, JSON.stringify(recorded, null, 2) + "\n", "utf-8");
+        // Atomic write: temp file + rename so an interrupted --record can never
+        // truncate/corrupt the baseline (which a later run would then silently rebuild).
+        const tmpPath = `${BASELINE_PATH}.${process.pid}.tmp`;
+        try {
+            fs.writeFileSync(tmpPath, JSON.stringify(recorded, null, 2) + "\n", "utf-8");
+            fs.renameSync(tmpPath, BASELINE_PATH);
+        } catch (writeErr) {
+            try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+            throw writeErr;
+        }
+
+        const coverageAfter = classifyCoverage(recorded, localPaths);
+        const movedCount = previousDrift.changed.length + previousDrift.added.length + previousDrift.removed.length;
+        if (opts.json) {
+            console.log(JSON.stringify({
+                recorded: true,
+                repo,
+                ref,
+                commit: recorded.commit,
+                capturedAt: recorded.capturedAt,
+                source: tree.source,
+                tracked: Object.keys(files).length,
+                upstreamTotal: Object.keys(tree.files).length,
+                movedSincePrevious: movedCount,
+                ignored: opts.ignore,
+                coverage: coverageAfter,
+            }, null, 2));
+            return;
+        }
 
         console.log(`Baseline recorded from ${tree.source}: ${repo}@${ref} ${tree.commit.slice(0, 12)} — ${Object.keys(files).length} tracked files of ${Object.keys(tree.files).length} upstream skill files`);
         if (Object.keys(previousFiles).length > 0) {
-            const moved = previousDrift.changed.length + previousDrift.added.length + previousDrift.removed.length;
-            console.log(moved === 0
+            console.log(movedCount === 0
                 ? "No adopted skill file moved upstream since the previous baseline."
-                : `warning: ${moved} adopted skill file(s) moved upstream since the previous baseline — record only what you actually reviewed.`);
+                : `warning: ${movedCount} adopted skill file(s) moved upstream since the previous baseline — record only what you actually reviewed.`);
         }
         if (opts.ignore.length > 0) {
             console.log(`Recorded as deliberately not adopted: ${opts.ignore.join(", ")}`);
         }
-        reportCoverage(classifyCoverage(recorded, localPaths));
+        reportCoverage(coverageAfter);
         return;
     }
 
@@ -305,6 +333,13 @@ async function main() {
 
     const tree = await fetchUpstreamTree(repo, ref);
     const drift = classifyDrift(baseline.files, tree.files, ignored);
+    // A truncated upstream tree has files missing from the listing; those baseline
+    // files would be misclassified as "removed". Suppress the unreliable removals so
+    // the report does not invent drift (changed/added only cover files that ARE listed
+    // and remain trustworthy).
+    if (tree.truncated) {
+        drift.removed = [];
+    }
     const driftCount = drift.changed.length + drift.added.length + drift.removed.length;
     if (opts.json) {
         console.log(JSON.stringify({