@opengsd/gsd-core 1.3.1 → 1.4.0-rc.2

package/scripts/run-tests.cjs

@@ -23,6 +23,7 @@
 const { readdirSync, existsSync } = require('fs');
 const { join } = require('path');
 const { execFileSync } = require('child_process');
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
 
 const SUITES = ['all', 'unit', 'integration', 'install', 'security', 'slow'];
 
@@ -189,13 +190,13 @@ function main() {
   if (parsed.error) {
     console.error(`run-tests: ${parsed.error}`);
     console.error(`Valid suites: ${SUITES.join(', ')}`);
-    process.exit(2);
+    throw new ExitError(2);
   }
   const suite = parsed.suite;
   if (suite !== null && !SUITES.includes(suite)) {
     console.error(`run-tests: unknown suite "${suite}"`);
     console.error(`Valid suites: ${SUITES.join(', ')}`);
-    process.exit(2);
+    throw new ExitError(2);
   }
 
   const testDir = process.env.GSD_TEST_DIR
@@ -208,7 +209,7 @@ function main() {
 
   if (allFiles.length === 0) {
     console.error(`No test files found in ${testDir}`);
-    process.exit(1);
+    throw new ExitError(1);
   }
 
   let selectedNames;
@@ -216,7 +217,7 @@ function main() {
     const explicit = selectExplicitFiles(allFiles, parsed.files, parsed.filesFrom);
     if (explicit.error) {
       console.error(`run-tests: ${explicit.error}`);
-      process.exit(2);
+      throw new ExitError(2);
     }
     selectedNames = explicit.files;
   } else {
@@ -229,7 +230,7 @@ function main() {
     // adversarial tests land) don't gate CI. CI consumers wanting strictness
     // can grep stderr for "no tests in suite".
     console.error(`run-tests: no tests in suite "${suite || 'all'}"`);
-    process.exit(0);
+    return 0;
   }
 
   // Build the gitignored bin/lib artifact if absent, before any test requires it.
@@ -304,11 +305,11 @@ function main() {
       if (firstFailureExit === 0) firstFailureExit = code;
     }
   }
-  if (firstFailureExit !== 0) process.exit(firstFailureExit);
+  if (firstFailureExit !== 0) return firstFailureExit;
 }
 
 if (require.main === module) {
-  main();
+  runMain(main);
 }
 
 module.exports = { suiteOf };

package/scripts/strip-prose-atrefs.cjs

@@ -30,7 +30,7 @@ const DRY_RUN      = process.argv.includes('--dry-run');
 const ROOT         = path.join(__dirname, '..');
 const COMMANDS_DIR = path.join(ROOT, 'commands', 'gsd');
 
-const AT_PATH_PATTERN = /@(?:~|\$HOME)\/.+?gsd-core\/[^\s`\)]+/;
+const AT_PATH_PATTERN = /@(?:~|\$HOME)\/.+?gsd-core\/[^\s`)]+/;
 const mkAtRe = () => new RegExp(AT_PATH_PATTERN.source, 'g');
 
 function transformLine(line) {

package/scripts/sync-manifest-versions.cjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sync-manifest-versions.cjs
+ *
+ * Stamps the package.json version into every runtime-integration manifest whose
+ * top-level `version` field MUST track the package version.  Called automatically
+ * by the `version` npm lifecycle script so that `npm version X.Y.Z` keeps all
+ * registered manifests in sync.
+ *
+ * Usage:
+ *   node scripts/sync-manifest-versions.cjs           # stamp + report
+ *   node scripts/sync-manifest-versions.cjs --stage   # stamp + git-stage manifests
+ *   node scripts/sync-manifest-versions.cjs --check   # report drift, exit 1 if any
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Single source of truth: runtime-integration manifests whose top-level `version`
+// MUST track package.json. Add a new manifest here so `npm version` keeps it in
+// sync — the regression guard test (issue 844) fails if you forget.
+const VERSIONED_MANIFESTS = [
+  '.claude-plugin/plugin.json',
+  'gemini-extension.json',
+];
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+function getPackageVersion(root) {
+  const r = root || ROOT;
+  return readJson(path.join(r, 'package.json')).version;
+}
+
+// Stamp `version` into each registered manifest, preserving field order and
+// 2-space + trailing-newline formatting. Returns the list of changed rel paths.
+function syncManifestVersions(opts) {
+  const root = (opts && opts.root) || ROOT;
+  const v = (opts && opts.version) != null ? opts.version : getPackageVersion(root);
+  const changed = [];
+  for (const rel of VERSIONED_MANIFESTS) {
+    const abs = path.join(root, rel);
+    const manifest = readJson(abs);
+    if (manifest.version !== v) {
+      manifest.version = v;
+      fs.writeFileSync(abs, JSON.stringify(manifest, null, 2) + '\n');
+      changed.push(rel);
+    }
+  }
+  return changed;
+}
+
+// Registered manifests whose version != package version.
+function findDrift(opts) {
+  const root = (opts && opts.root) || ROOT;
+  const v = (opts && opts.version) != null ? opts.version : getPackageVersion(root);
+  const drift = [];
+  for (const rel of VERSIONED_MANIFESTS) {
+    const found = readJson(path.join(root, rel)).version;
+    if (found !== v) drift.push({ manifest: rel, found, expected: v });
+  }
+  return drift;
+}
+
+// Best-effort outside git; fail-closed inside a work tree so a release never
+// ships a stale manifest that the working-tree test already accepted.
+function stageManifests(opts) {
+  const root = (opts && opts.root) || ROOT;
+  let insideWorkTree = false;
+  try {
+    insideWorkTree = execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString().trim() === 'true';
+  } catch {}
+  if (!insideWorkTree) {
+    console.warn('sync-manifest-versions: not a git work tree; skipping staging.');
+    return;
+  }
+  try {
+    execFileSync('git', ['add', '--', ...VERSIONED_MANIFESTS], { cwd: root, stdio: ['ignore', 'ignore', 'pipe'] });
+  } catch (err) {
+    const detail = err && err.stderr ? err.stderr.toString().trim() : (err && err.message) || 'unknown error';
+    throw new Error(`sync-manifest-versions: failed to git-add manifests inside a work tree: ${detail}`);
+  }
+}
+
+module.exports = { VERSIONED_MANIFESTS, syncManifestVersions, findDrift, getPackageVersion, stageManifests };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const version = getPackageVersion();
+  if (args.includes('--check')) {
+    const drift = findDrift({ version });
+    if (drift.length) {
+      for (const d of drift) {
+        console.error('Manifest ' + d.manifest + ' version ' + d.found + ' != package.json ' + d.expected);
+      }
+      console.error('Run `node scripts/sync-manifest-versions.cjs` to fix.');
+      process.exitCode = 1;
+    } else {
+      console.log('All ' + VERSIONED_MANIFESTS.length + ' versioned manifests in sync at ' + version + '.');
+    }
+  } else {
+    const changed = syncManifestVersions({ version });
+    if (changed.length) {
+      console.log('Stamped ' + version + ' into: ' + changed.join(', '));
+    } else {
+      console.log('Versioned manifests already at ' + version + '.');
+    }
+    if (args.includes('--stage')) stageManifests();
+  }
+}

package/scripts/sync-runtime-launcher.cjs

@@ -96,9 +96,6 @@ function removeResolverLines(lines, preamble) {
   const result = [];
   let i = 0;
 
-  // Build a set of preamble lines for fast lookup (to strip previously-inserted preambles)
-  const preambleLineSet = new Set(preamble);
-
   while (i < lines.length) {
     const line = lines[i];
     const trimmed = line.trim();

package/scripts/verify-npm-publish.cjs

@@ -8,6 +8,7 @@
  */
 
 const cp = require('node:child_process');
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
 
 // ---- Constants ---------------------------------------------------------------
 
@@ -137,67 +138,57 @@ function parseArgs(argv) {
         '  --json              emit structured JSON output\n' +
         '  --help, -h          show this help\n'
       );
-      process.exit(0);
+      throw new ExitError(0);
     } else if (arg === '--package') {
       const val = args.shift();
       if (!val || val.startsWith('-')) {
-        process.stderr.write('error: --package requires a value\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --package requires a value');
       }
       opts.pkg = val;
     } else if (arg === '--version') {
       const val = args.shift();
       if (!val || val.startsWith('-')) {
-        process.stderr.write('error: --version requires a value\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --version requires a value');
       }
       opts.version = val;
     } else if (arg === '--dist-tag') {
       const val = args.shift();
       if (!val || val.startsWith('-')) {
-        process.stderr.write('error: --dist-tag requires a value\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --dist-tag requires a value');
       }
       opts.distTag = val;
     } else if (arg === '--max-attempts') {
       const val = args.shift();
       if (!val || val.startsWith('-')) {
-        process.stderr.write('error: --max-attempts requires a value\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --max-attempts requires a value');
       }
       const n = parseInt(val, 10);
       if (isNaN(n) || n < 1) {
-        process.stderr.write('error: --max-attempts must be a positive integer\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --max-attempts must be a positive integer');
       }
       opts.maxAttempts = n;
     } else if (arg === '--interval-ms') {
       const val = args.shift();
       if (!val || val.startsWith('-')) {
-        process.stderr.write('error: --interval-ms requires a value\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --interval-ms requires a value');
       }
       const n = parseInt(val, 10);
       if (isNaN(n) || n < 0) {
-        process.stderr.write('error: --interval-ms must be a non-negative integer\n');
-        process.exit(2);
+        throw new ExitError(2, 'error: --interval-ms must be a non-negative integer');
       }
       opts.intervalMs = n;
     } else if (arg === '--json') {
       opts.json = true;
     } else {
-      process.stderr.write(`unknown argument: ${arg}\n`);
-      process.exit(2);
+      throw new ExitError(2, `unknown argument: ${arg}`);
     }
   }
 
   if (!opts.pkg) {
-    process.stderr.write('error: --package is required\n');
-    process.exit(2);
+    throw new ExitError(2, 'error: --package is required');
   }
   if (!opts.version) {
-    process.stderr.write('error: --version is required\n');
-    process.exit(2);
+    throw new ExitError(2, 'error: --version is required');
   }
 
   return opts;
@@ -237,16 +228,13 @@ async function main() {
     }
   }
 
-  process.exit(result.ok ? 0 : 1);
+  return result.ok ? 0 : 1;
 }
 
 // ---- Guard -------------------------------------------------------------------
 
 if (require.main === module) {
-  main().catch((err) => {
-    process.stderr.write(String((err && err.stack) || err) + '\n');
-    process.exit(1);
-  });
+  runMain(main);
 }
 
 module.exports = { verifyPublish, parseArgs, REASON, defaultFetchVersion, defaultFetchDistTag };