@opengsd/gsd-core 1.6.1 → 1.7.0-rc.2

package/scripts/prompt-injection-scan.sh

@@ -94,6 +94,14 @@ ALLOWLIST=(
   # real injection payloads to prove the validator rejects them. See
   # DEFECT.PROMPT-INJECTION-SCAN-COLLISION in CONTEXT.md.
   'tests/windsurf-conversion.test.cjs'
+  # RuleTester fixtures for the local/no-unguarded-nonportable-exec ESLint rule
+  # contain shell-exec command strings (exec("sh -c …"), execFileSync('bash',['-c',…]))
+  # as test DATA the rule must lint — not attack vectors. ADR-1703 Phase 3 (#1720).
+  'tests/no-unguarded-nonportable-exec.rule.test.cjs'
+  # RuleTester fixtures for the local/no-bare-npm-exec ESLint rule contain npm
+  # exec command strings (execFileSync('npm', ['install'])) as test DATA the rule
+  # must lint — not attack vectors. ADR-1703 Phase 4 (#1726).
+  'tests/no-bare-npm-exec.rule.test.cjs'
 )
 
 is_allowlisted() {

package/scripts/run-tests.cjs

@@ -119,6 +119,51 @@ function ensureBuiltArtifacts(overrides = {}) {
     }
   }
 }
+
+// hooks/dist/ is gitignored (.gitignore) and NOT built by `prepare`
+// (npm run build:lib only) — only the full `build`/`prepublishOnly` scripts run
+// build:hooks. So on a clean checkout + `npm ci` (fresh CI, incl. the scoped
+// test lane) hooks/dist starts absent. Install tests (e.g.
+// bug-3683-workflow-colon-namespace-leak) spawn `install.js --<runtime> --local`
+// which copies hooks from hooks/dist/ and then verifyInstalled() hard-fails if
+// the target hooks dir is empty. build-hooks.js `build()` creates DIST_DIR
+// empty and fills it file-by-file, so the FIRST on-demand build (triggered by
+// whichever concurrent install test's before() hook runs first) exposes a
+// window where hooks/dist exists but is empty/partial. A concurrently-spawned
+// install reader observes zero hooks -> "Failed to install hooks: directory is
+// empty" -> intermittent scoped-lane failure (full lanes dodge it only by luck
+// of a hooks-builder finishing early). Building hooks/dist ONCE here — the same
+// upfront chokepoint as ensureBuiltArtifacts, single-process with no concurrent
+// readers — fully populates dist before any test runs, closing the first-build
+// empty window everywhere (CI scoped/unit shards + local). Subsequent on-demand
+// rebuilds only atomically replace individual files (per-file rename in
+// build-hooks.js) and never re-empty the dir, so they stay safe.
+function ensureBuiltHooks(overrides = {}) {
+  const { existsSync, statSync } = require('fs');
+  const root = overrides.root || join(__dirname, '..');
+  const distDir = overrides.distDir || join(root, 'hooks', 'dist');
+  const hookNames = overrides.hookNames || require('./build-hooks.js').HOOKS_TO_COPY;
+  const runBuild = overrides.runBuild || (() => {
+    execFileSync(process.execPath, [join(root, 'scripts', 'build-hooks.js')], {
+      cwd: root,
+      stdio: 'inherit',
+    });
+  });
+
+  // dist is "complete" only if every expected hook exists as a non-empty file.
+  // Absent dir, empty dir, or a missing/zero-byte hook all trigger a rebuild.
+  const complete = existsSync(distDir) && hookNames.every((hook) => {
+    const p = join(distDir, hook);
+    try {
+      return existsSync(p) && statSync(p).size > 0;
+    } catch {
+      return false;
+    }
+  });
+  if (!complete) {
+    runBuild();
+  }
+}
 const MARKED_SUITES = ['integration', 'install', 'security', 'slow'];
 
 // Recursively collect *.test.cjs files under dir, returning paths relative to dir.
@@ -454,6 +499,11 @@ function main() {
   // Build the gitignored bin/lib artifact if absent, before any test requires it.
   ensureBuiltArtifacts();
 
+  // Build the gitignored hooks/dist artifact once, before any concurrent install
+  // test spawns install.js and reads it — closes the first-build empty-dir race
+  // that intermittently failed the scoped CI lane (see ensureBuiltHooks above).
+  ensureBuiltHooks();
+
   // Hermeticity: in-process tests resolve `.planning` via planningDir(cwd), which
   // honours GSD_PROJECT/GSD_WORKSTREAM. A developer shell inside a GSD workstream
   // exports GSD_WORKSTREAM, which would redirect fixture STATE.md reads away from
@@ -600,4 +650,4 @@ if (require.main === module) {
   runMain(main);
 }
 
-module.exports = { suiteOf, ensureBuiltArtifacts, parseShardArg, selectShard };
+module.exports = { suiteOf, ensureBuiltArtifacts, ensureBuiltHooks, parseShardArg, selectShard };

package/scripts/sync-manifest-versions.cjs

@@ -21,18 +21,66 @@ 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.
+// Single source of truth: runtime-integration manifests whose `version` field
+// MUST track package.json. Each entry names the manifest path plus the dotted
+// path to the version field inside that JSON document. Top-level `version` is
+// the default (plugin.json, gemini-extension.json); the Claude plugin
+// marketplace manifest carries its canonical version at plugins[0].version
+// (the schema-canonical location runtimes read — issue #1855).
+//
+// 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',
+  { path: '.claude-plugin/plugin.json', versionKey: 'version' },
+  { path: 'gemini-extension.json', versionKey: 'version' },
+  { path: '.claude-plugin/marketplace.json', versionKey: 'plugins.0.version' },
+  { path: 'vscode/package.json', versionKey: 'version' },
 ];
 
+// Convenience: just the registered paths, for consumers that only need to
+// iterate files (e.g. the issue-844 regression-guard ALLOWED set).
+const VERSIONED_MANIFEST_PATHS = VERSIONED_MANIFESTS.map((e) => e.path);
+
 function readJson(p) {
   return JSON.parse(fs.readFileSync(p, 'utf8'));
 }
 
+// Property names that must never be traversed/assigned through a dotted path —
+// the prototype-pollution triple. Mirrors the _isSafePropKey CodeQL barrier used
+// elsewhere in the repo. Versions are hand-authored descriptors, but the helpers
+// are exported, so guard them before reuse across a trust boundary.
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function assertSafePath(dotPath) {
+  for (const seg of String(dotPath).split('.')) {
+    if (UNSAFE_KEYS.has(seg)) {
+      throw new Error(`refusing to traverse reserved property "${seg}" in version path "${dotPath}"`);
+    }
+  }
+}
+
+// Read a dotted path ('plugins.0.version') from a parsed JSON document.
+// Returns undefined if any intermediate is missing. Array indices are plain
+// numeric keys, so 'plugins.0.version' resolves obj.plugins[0].version.
+// Reserved properties (__proto__/constructor/prototype) are rejected.
+function getByPath(obj, dotPath) {
+  assertSafePath(dotPath);
+  return String(dotPath).split('.').reduce((cur, key) => (cur == null ? cur : cur[key]), obj);
+}
+
+// Write a value at a dotted path. Intermediate nodes must already exist (every
+// registered manifest is hand-authored with its version slot present, so this
+// never needs to materialize a path). Reserved properties are rejected. Kept
+// trivial — no eval, no creation.
+function setByPath(obj, dotPath, value) {
+  assertSafePath(dotPath);
+  const parts = String(dotPath).split('.');
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+
 function getPackageVersion(root) {
   const r = root || ROOT;
   return readJson(path.join(r, 'package.json')).version;
@@ -44,13 +92,13 @@ 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);
+  for (const entry of VERSIONED_MANIFESTS) {
+    const abs = path.join(root, entry.path);
     const manifest = readJson(abs);
-    if (manifest.version !== v) {
-      manifest.version = v;
+    if (getByPath(manifest, entry.versionKey) !== v) {
+      setByPath(manifest, entry.versionKey, v);
       fs.writeFileSync(abs, JSON.stringify(manifest, null, 2) + '\n');
-      changed.push(rel);
+      changed.push(entry.path);
     }
   }
   return changed;
@@ -61,9 +109,10 @@ 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 });
+  for (const entry of VERSIONED_MANIFESTS) {
+    const manifest = readJson(path.join(root, entry.path));
+    const found = getByPath(manifest, entry.versionKey);
+    if (found !== v) drift.push({ manifest: entry.path, found, expected: v });
   }
   return drift;
 }
@@ -143,7 +192,7 @@ function stageManifests(opts) {
     console.warn('sync-manifest-versions: not a git work tree; skipping staging.');
     return;
   }
-  const toStage = [...VERSIONED_MANIFESTS, ...listCapabilityManifests({ root })];
+  const toStage = [...VERSIONED_MANIFEST_PATHS, ...listCapabilityManifests({ root })];
   try {
     execFileSync('git', ['add', '--', ...toStage], { cwd: root, stdio: ['ignore', 'ignore', 'pipe'] });
   } catch (err) {
@@ -154,6 +203,9 @@ function stageManifests(opts) {
 
 module.exports = {
   VERSIONED_MANIFESTS,
+  VERSIONED_MANIFEST_PATHS,
+  getByPath,
+  setByPath,
   syncManifestVersions,
   findDrift,
   getPackageVersion,

package/skills/gsd-review/SKILL.md

@@ -35,6 +35,12 @@ Phase number: extracted from $ARGUMENTS (required)
 - `--cursor` — Include Cursor agent review
 - `--agy` / `--antigravity` — Include Antigravity CLI review
 - `--all` — Include all available CLIs
+
+**No flags** — if `review.default_reviewers` is set, review with only those configured
+reviewers that are detected; otherwise review with all available CLIs. Configured
+`review.reviewer_instances` names may appear in `review.default_reviewers`; each runs as an
+independent reviewer identity backed by its configured adapter+model (see
+`docs/CONFIGURATION.md`). Instance names are not valid as flags.
 </context>
 
 <process>

package/scripts/lint-windows-test-portability.cjs

@@ -1,178 +0,0 @@
-'use strict';
-
-/**
- * lint-windows-test-portability.cjs — flag tests that combine chmod exec-bit
- * with bare sh/bash -c without a platform guard.
- *
- * ## Why
- *
- * Windows Git Bash (msys2) does not honour Node's chmod exec bit for
- * PATH-executing extension-less scripts. A test that (a) makes a fixture
- * executable via chmodSync and (b) runs it with `sh -c`/`bash -c` will pass
- * on Mac/Linux but fail only in the CI `test (windows-latest, *)` /
- * `full test (windows-latest, *)` lanes, producing a hard-to-diagnose
- * false-negative gate. See CONTEXT.md → DEFECT.WINDOWS-TEST-PORTABILITY.
- *
- * ## What this enforces
- *
- * For every file in tests/**\/*.test.cjs (recursive, excluding node_modules):
- *   - makesExecutable: contains chmodSync?( with an exec-bit octal literal
- *   - shellDashC: contains a sh/bash -c invocation (array form or string literal)
- *   - guarded: contains a process.platform / os.platform() / win32 / isWindows guard
- *   - optOut: contains the literal `windows-portability-ok`
- *   VIOLATION = makesExecutable && shellDashC && !guarded && !optOut
- *
- * ## Remediation
- *
- * Gate the bare-command execution with `if (process.platform !== 'win32')`,
- * or invoke via an explicit interpreter (`sh <path>`), or annotate
- * `// windows-portability-ok: <reason>`.
- *
- * ## Export contract (for unit tests)
- *
- * When required as a module (`require.main !== module`) this file exports
- * `scanContent(source)` → { makesExecutable, shellDashC, guarded, optOut, violation }.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// ─── Detection regexes ──────────────────────────────────────────────────────
-
-/**
- * Match chmod/chmodSync( calls with an octal mode literal whose exec bits are
- * set, e.g. `fs.chmodSync(p, 0o755)` or `chmod(file, 0o111)`.
- */
-const CHMOD_RE = /chmod(?:Sync)?\s*\([^,;]+,\s*0o([0-7]{3})\b/g;
-
-/**
- * Array form: execFileSync/spawnSync/exec* with 'sh' or 'bash' (optionally
- * prefixed) as the first arg and '-c' as an element of the args array.
- * e.g. execFileSync('bash', ['-c', ...]) or spawnSync('/bin/sh', ['-c', ...])
- */
-const SHELL_ARRAY_RE =
-  /(?:execFile(?:Sync)?|spawnSync|spawn|exec)\s*\(\s*['"`](?:\/(?:usr\/)?bin\/)?(?:bash|sh)['"`]\s*,\s*\[[^\]]*['"]-c['"]/;
-
-/**
- * String-literal form: any string containing `bash -c` or `sh -c`.
- */
-const SHELL_STRING_RE = /['"`][^'"`\n]*(?:bash|sh)\s+-c[^'"`\n]*['"`]/;
-
-/** Platform guard presence. */
-const GUARD_RE = /process\.platform|os\.platform\s*\(|\bwin32\b|\bisWindows\b/;
-
-/** Opt-out annotation. */
-const OPT_OUT_RE = /windows-portability-ok/;
-
-// ─── Pure scanning function (exported for unit tests) ────────────────────────
-
-/**
- * Scan a single file's source text and return detection flags.
- *
- * @param {string} source - The file contents as a string.
- * @returns {{ makesExecutable: boolean, shellDashC: boolean, guarded: boolean, optOut: boolean, violation: boolean }}
- */
-function scanContent(source) {
-  // Reset stateful regex before use.
-  CHMOD_RE.lastIndex = 0;
-
-  let makesExecutable = false;
-  let match;
-  while ((match = CHMOD_RE.exec(source)) !== null) {
-    const oct = match[1];
-    if ((parseInt(oct, 8) & 0o111) !== 0) {
-      makesExecutable = true;
-      break;
-    }
-  }
-
-  const shellDashC = SHELL_ARRAY_RE.test(source) || SHELL_STRING_RE.test(source);
-  const guarded = GUARD_RE.test(source);
-  const optOut = OPT_OUT_RE.test(source);
-  const violation = makesExecutable && shellDashC && !guarded && !optOut;
-
-  return { makesExecutable, shellDashC, guarded, optOut, violation };
-}
-
-// ─── Filesystem walker ───────────────────────────────────────────────────────
-
-/**
- * Recursively collect all *.test.cjs files under `dir`, excluding node_modules.
- *
- * @param {string} dir
- * @param {string[]} [acc]
- * @returns {string[]}
- */
-function collectTestFiles(dir, acc) {
-  acc = acc || [];
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return acc;
-  }
-  for (const entry of entries) {
-    if (entry.name === 'node_modules') continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectTestFiles(full, acc);
-    } else if (entry.isFile() && entry.name.endsWith('.test.cjs')) {
-      acc.push(full);
-    }
-  }
-  return acc;
-}
-
-// ─── Main ────────────────────────────────────────────────────────────────────
-
-function main() {
-  const ROOT = path.join(__dirname, '..');
-  const TESTS_DIR = path.join(ROOT, 'tests');
-
-  const files = collectTestFiles(TESTS_DIR);
-  const violations = [];
-
-  for (const file of files) {
-    let source;
-    try {
-      source = fs.readFileSync(file, 'utf8');
-    } catch {
-      continue;
-    }
-    const { violation } = scanContent(source);
-    if (violation) {
-      const rel = path.relative(ROOT, file).replace(/\\/g, '/');
-      violations.push(rel);
-    }
-  }
-
-  if (violations.length > 0) {
-    for (const rel of violations) {
-      process.stderr.write(
-        `${rel}: chmod-executable + sh/bash -c with no platform guard\n`,
-      );
-    }
-    process.stderr.write(
-      '\nWindows Git Bash does not honor Node\'s chmod exec bit for ' +
-        'PATH-executing extension-less scripts ' +
-        '(CONTEXT.md → DEFECT.WINDOWS-TEST-PORTABILITY). ' +
-        'Gate the bare-command execution with ' +
-        '`if (process.platform !== \'win32\')`, or invoke via an explicit ' +
-        'interpreter (`sh <path>`), or annotate ' +
-        '`// windows-portability-ok: <reason>`.\n',
-    );
-    process.exitCode = 1;
-  } else {
-    console.log(
-      `ok lint-windows-test-portability: ${files.length} file(s) scanned, no violations`,
-    );
-  }
-}
-
-// ─── Module boundary ─────────────────────────────────────────────────────────
-
-if (require.main === module) {
-  main();
-} else {
-  module.exports = { scanContent };
-}