session-orchestrator 3.16.0

package/scripts/lib/ecosystem-health.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+/**
+ * ecosystem-health.mjs — Plugin-monitor watcher for ecosystem-health skill.
+ *
+ * Runs as a persistent background process for the lifetime of the session
+ * (registered via .claude-plugin/plugin.json -> experimental.monitors path).
+ * Each NDJSON line written to stdout becomes a `<task_notification>` event
+ * Claude sees mid-session.
+ *
+ * Behaviour:
+ *   - Watches .orchestrator/metrics/ecosystem-health.jsonl for state changes
+ *     (line-count growth + last-line change detection).
+ *   - If the state file does not exist yet, emits one `no-state-yet` event
+ *     at startup and idles until it appears.
+ *   - Coverage rule LM-002: stdout emits cover both progress AND failure
+ *     cases. Errors during the watch loop are surfaced as `error` events,
+ *     never silently swallowed (silence != success).
+ *
+ * Line-buffering contract:
+ *   Every emit uses `process.stdout.write(line + '\n')` — one line per
+ *   notification. Never console.log multi-line strings.
+ *
+ * Flags:
+ *   --watch        Run the watcher loop (required; no other mode supported).
+ *   --interval=N   Probe cadence in seconds (default 900 = 15min). Cron-style
+ *                  pre-warming pattern: keep cadence below any cache-related TTLs.
+ *   --help         Print usage to stderr and exit 0.
+ *
+ * Exit codes:
+ *   0 — clean shutdown (SIGTERM/SIGINT received).
+ *   1 — user/input error (unknown flag, --watch missing).
+ *   2 — system error (unexpected failure outside the watch loop).
+ *
+ * @typedef {Object} EmitEvent
+ * @property {string} event       Event name (lowercase.dot.case).
+ * @property {string} ts          ISO-8601 timestamp.
+ * @property {Record<string, unknown>} [details]  Optional structured payload.
+ */
+
+import { existsSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEFAULT_INTERVAL_S = 15 * 60; // 15min
+const STATE_FILE_REL = '.orchestrator/metrics/ecosystem-health.jsonl';
+
+/**
+ * Parse CLI args into a typed config object. No deps — node:util's parseArgs
+ * is overkill for this surface and adds 2 lines of overhead per call.
+ * @param {string[]} argv
+ * @returns {{ watch: boolean, intervalS: number, help: boolean }}
+ */
+function parseArgs(argv) {
+  let watch = false;
+  let intervalS = DEFAULT_INTERVAL_S;
+  let help = false;
+  for (const arg of argv) {
+    if (arg === '--watch') {
+      watch = true;
+    } else if (arg === '--help' || arg === '-h') {
+      help = true;
+    } else if (arg.startsWith('--interval=')) {
+      const v = Number(arg.slice('--interval='.length));
+      if (!Number.isFinite(v) || v <= 0) {
+        process.stderr.write(`ecosystem-health: invalid --interval value: ${arg}\n`);
+        process.exit(1);
+      }
+      intervalS = v;
+    } else {
+      process.stderr.write(`ecosystem-health: unknown flag: ${arg}\n`);
+      process.exit(1);
+    }
+  }
+  return { watch, intervalS, help };
+}
+
+/**
+ * Emit one NDJSON line to stdout (one notification = one line).
+ * @param {EmitEvent} payload
+ */
+function emit(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+
+/**
+ * Read state-file fingerprint (size + last-line) for change detection.
+ * @param {string} absPath
+ * @returns {{ exists: boolean, size: number, mtimeMs: number, lastLine: string | null }}
+ */
+function fingerprint(absPath) {
+  if (!existsSync(absPath)) {
+    return { exists: false, size: 0, mtimeMs: 0, lastLine: null };
+  }
+  try {
+    const st = statSync(absPath);
+    // Tail read for last line — small file in practice (append-only JSONL).
+    // Reading full file is acceptable here at 15-min cadence.
+    let lastLine = null;
+    if (st.size > 0) {
+      const text = readFileSync(absPath, 'utf8');
+      const trimmed = text.replace(/\n$/, '');
+      const idx = trimmed.lastIndexOf('\n');
+      lastLine = idx === -1 ? trimmed : trimmed.slice(idx + 1);
+    }
+    return { exists: true, size: st.size, mtimeMs: st.mtimeMs, lastLine };
+  } catch (err) {
+    // Surface as an error event rather than silently returning a fake fingerprint.
+    emit({
+      event: 'error',
+      ts: new Date().toISOString(),
+      details: { phase: 'fingerprint', file: absPath, message: String(err?.message ?? err) },
+    });
+    return { exists: false, size: 0, mtimeMs: 0, lastLine: null };
+  }
+}
+
+/**
+ * Main watch loop. Runs until SIGTERM/SIGINT.
+ * @param {number} intervalS
+ */
+async function watchLoop(intervalS) {
+  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || process.cwd();
+  const absPath = join(pluginRoot, STATE_FILE_REL);
+
+  // Startup event — confirms the watcher is alive even when nothing has
+  // happened yet. Without this, a "no events" stream is indistinguishable
+  // from a crashed monitor.
+  let prev = fingerprint(absPath);
+  emit({
+    event: prev.exists ? 'watcher.started' : 'no-state-yet',
+    ts: new Date().toISOString(),
+    details: { file: STATE_FILE_REL, intervalSeconds: intervalS, exists: prev.exists },
+  });
+
+  // Loop forever — the Claude harness sends SIGTERM on session-end and the
+  // process exits 0 via the signal handlers below.
+  while (true) {
+    await sleep(intervalS * 1000);
+    const next = fingerprint(absPath);
+    if (!prev.exists && next.exists) {
+      emit({
+        event: 'state-file.appeared',
+        ts: new Date().toISOString(),
+        details: { file: STATE_FILE_REL, size: next.size },
+      });
+    } else if (prev.exists && !next.exists) {
+      emit({
+        event: 'state-file.disappeared',
+        ts: new Date().toISOString(),
+        details: { file: STATE_FILE_REL },
+      });
+    } else if (next.exists && (next.size !== prev.size || next.lastLine !== prev.lastLine)) {
+      emit({
+        event: 'state.changed',
+        ts: new Date().toISOString(),
+        details: {
+          file: STATE_FILE_REL,
+          sizeDelta: next.size - prev.size,
+          lastLine: next.lastLine,
+        },
+      });
+    }
+    prev = next;
+  }
+}
+
+/**
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    t.unref?.();
+  });
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stderr.write(
+      [
+        'Usage: ecosystem-health.mjs --watch [--interval=<seconds>]',
+        '',
+        'Plugin-monitor watcher for the ecosystem-health skill. Persistent',
+        'background process; one NDJSON line per state change → stdout.',
+        '',
+        'Flags:',
+        '  --watch              Required. Run the watch loop.',
+        '  --interval=<s>       Probe cadence in seconds (default 900).',
+        '  --help, -h           Print this message.',
+        '',
+        'Exit codes: 0 clean / 1 user-error / 2 system-error.',
+      ].join('\n') + '\n',
+    );
+    process.exit(0);
+  }
+  if (!args.watch) {
+    process.stderr.write('ecosystem-health: --watch is required\n');
+    process.exit(1);
+  }
+
+  // Graceful shutdown — Claude harness sends SIGTERM at session-end.
+  const shutdown = (sig) => {
+    emit({
+      event: 'watcher.shutdown',
+      ts: new Date().toISOString(),
+      details: { signal: sig },
+    });
+    process.exit(0);
+  };
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+
+  watchLoop(args.intervalS).catch((err) => {
+    emit({
+      event: 'error',
+      ts: new Date().toISOString(),
+      details: { phase: 'watchLoop', message: String(err?.message ?? err) },
+    });
+    process.exit(2);
+  });
+}
+
+main();

package/scripts/lib/ecosystem-wizard/ci-detector.mjs

@@ -0,0 +1,18 @@
+/**
+ * ci-detector.mjs — detects CI provider from repo structure.
+ * Checks for .gitlab-ci.yml (GitLab) or .github/workflows/ (GitHub).
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Detects CI provider from repo structure.
+ * @param {string} repoRoot
+ * @returns {'gitlab' | 'github' | 'none'}
+ */
+export function detectCiProvider(repoRoot) {
+  if (existsSync(join(repoRoot, '.gitlab-ci.yml'))) return 'gitlab';
+  if (existsSync(join(repoRoot, '.github', 'workflows'))) return 'github';
+  return 'none';
+}

package/scripts/lib/ecosystem-wizard/config-parser.mjs

@@ -0,0 +1,54 @@
+/**
+ * config-parser.mjs — pure parsing utilities for comma-separated user input.
+ * Converts raw wizard answer strings into typed endpoint/pipeline/label arrays.
+ */
+
+/**
+ * Parses a comma-separated string into a trimmed array, filtering empty items.
+ * @param {string} input
+ * @returns {string[]}
+ */
+export function parseCommaSeparated(input) {
+  return input
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+/**
+ * Parses endpoint input lines. Format: "Name|URL" per entry, separated by commas.
+ * @param {string} input
+ * @returns {Array<{name: string, url: string}>}
+ */
+export function parseEndpoints(input) {
+  return parseCommaSeparated(input)
+    .map((entry) => {
+      const pipe = entry.indexOf('|');
+      if (pipe === -1) return null;
+      const name = entry.slice(0, pipe).trim();
+      const url = entry.slice(pipe + 1).trim();
+      if (!name || !url) return null;
+      return { name, url };
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Parses pipeline input lines. Format: "id" or "id:label" per entry.
+ * @param {string} input
+ * @returns {Array<{id: string, label?: string}>}
+ */
+export function parsePipelines(input) {
+  return parseCommaSeparated(input)
+    .map((entry) => {
+      const colon = entry.indexOf(':');
+      if (colon === -1) {
+        return entry.trim() ? { id: entry.trim() } : null;
+      }
+      const id = entry.slice(0, colon).trim();
+      const label = entry.slice(colon + 1).trim();
+      if (!id) return null;
+      return label ? { id, label } : { id };
+    })
+    .filter(Boolean);
+}

package/scripts/lib/ecosystem-wizard/config-writer.mjs

@@ -0,0 +1,287 @@
+/**
+ * config-writer.mjs — validates ecosystem policy shape and writes artifacts:
+ * .orchestrator/policy/ecosystem.json and the ecosystem-health block in Session Config.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+/** @param {unknown} arr @param {string} field @param {string[]} errors */
+function _validateEndpoints(arr, field, errors) {
+  if (!Array.isArray(arr)) { errors.push(`${field} must be an array`); return; }
+  for (let i = 0; i < arr.length; i++) {
+    const ep = arr[i];
+    if (ep === null || typeof ep !== 'object' || Array.isArray(ep)) {
+      errors.push(`${field}[${i}] must be a plain object`); continue;
+    }
+    if (typeof ep['name'] !== 'string' || ep['name'].trim() === '')
+      errors.push(`${field}[${i}].name must be a non-empty string`);
+    if (typeof ep['url'] !== 'string' || ep['url'].trim() === '')
+      errors.push(`${field}[${i}].url must be a non-empty string`);
+  }
+}
+
+/** @param {unknown} arr @param {string} field @param {string[]} errors */
+function _validatePipelines(arr, field, errors) {
+  if (!Array.isArray(arr)) { errors.push(`${field} must be an array`); return; }
+  for (let i = 0; i < arr.length; i++) {
+    const pl = arr[i];
+    if (pl === null || typeof pl !== 'object' || Array.isArray(pl)) {
+      errors.push(`${field}[${i}] must be a plain object`); continue;
+    }
+    if (typeof pl['id'] !== 'string' || pl['id'].trim() === '')
+      errors.push(`${field}[${i}].id must be a non-empty string`);
+  }
+}
+
+/** @param {unknown} arr @param {string} field @param {string[]} errors */
+function _validateLabels(arr, field, errors) {
+  if (!Array.isArray(arr)) { errors.push(`${field} must be an array`); return; }
+  for (let i = 0; i < arr.length; i++) {
+    if (typeof arr[i] !== 'string' || arr[i].trim() === '')
+      errors.push(`${field}[${i}] must be a non-empty string`);
+  }
+}
+
+/**
+ * Validates the ecosystem policy shape.
+ * Returns [] when valid; an array of error strings when invalid.
+ *
+ * @param {unknown} policy
+ * @returns {string[]}
+ */
+export function validateEcosystemPolicy(policy) {
+  const errors = [];
+  if (policy === null || typeof policy !== 'object' || Array.isArray(policy)) {
+    errors.push('policy must be a plain object');
+    return errors;
+  }
+  if (policy['version'] !== 1) {
+    errors.push(`version must be 1, got ${JSON.stringify(policy['version'])}`);
+  }
+  if (policy['endpoints'] !== undefined) _validateEndpoints(policy['endpoints'], 'endpoints', errors);
+  if (policy['pipelines'] !== undefined) _validatePipelines(policy['pipelines'], 'pipelines', errors);
+  if (policy['criticalIssueLabels'] !== undefined)
+    _validateLabels(policy['criticalIssueLabels'], 'criticalIssueLabels', errors);
+  return errors;
+}
+
+// ---------------------------------------------------------------------------
+// Session Config reader/writer
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns whether the Session Config section in `text` already contains an
+ * ecosystem-health key.
+ * @param {string} text
+ * @param {RegExpMatchArray|null} startMatch
+ * @returns {boolean}
+ */
+function _ecosystemBlockPresent(text, startMatch) {
+  if (!startMatch || startMatch.index === undefined) return false;
+  const afterBlock = text.slice(startMatch.index + startMatch[0].length);
+  const nextHeadingMatch = afterBlock.match(/^## /m);
+  const blockContent = nextHeadingMatch ? afterBlock.slice(0, nextHeadingMatch.index) : afterBlock;
+  return /^\s*ecosystem-health\s*:/m.test(blockContent);
+}
+
+/**
+ * Replaces an existing ecosystem-health block in `text` with `snippetLines`.
+ * Returns the new text (which may equal `text` if the regex matched nothing different).
+ * @param {string} text
+ * @param {string[]} snippetLines
+ * @returns {string}
+ */
+function _replaceEcosystemBlock(text, snippetLines) {
+  return text.replace(/^ecosystem-health:(?:\n(?!##|\S).*)*\n?/m, snippetLines.join('\n') + '\n');
+}
+
+/**
+ * Inserts a new ecosystem-health snippet into `text` within the Session Config
+ * section, or appends a new section when none exists.
+ * @param {string} text
+ * @param {RegExpMatchArray|null} startMatch
+ * @param {string[]} snippetLines
+ * @returns {string}
+ */
+function _insertEcosystemBlock(text, startMatch, snippetLines) {
+  const snippet = '\n' + snippetLines.join('\n');
+  if (!startMatch || startMatch.index === undefined) {
+    return text + '\n## Session Config\n' + snippet + '\n';
+  }
+  const afterStartIdx = startMatch.index + startMatch[0].length;
+  const afterBlock = text.slice(afterStartIdx);
+  const nextHeadingMatch = afterBlock.match(/^## /m);
+  if (nextHeadingMatch && nextHeadingMatch.index !== undefined) {
+    const insertAt = afterStartIdx + nextHeadingMatch.index;
+    return text.slice(0, insertAt) + snippet + '\n' + text.slice(insertAt);
+  }
+  return text + snippet + '\n';
+}
+
+/**
+ * Builds the YAML snippet lines for an ecosystem-health block.
+ * @param {{endpoints: object[], pipelines: object[], criticalIssueLabels: string[]}} config
+ * @returns {string[]}
+ */
+function _buildEcosystemSnippetLines(config) {
+  const lines = ['ecosystem-health:'];
+  if (config.endpoints.length > 0) {
+    lines.push('  health-endpoints:');
+    for (const ep of config.endpoints) {
+      lines.push(`    - name: ${ep.name}`);
+      lines.push(`      url: ${ep.url}`);
+    }
+  }
+  if (config.pipelines.length > 0) {
+    lines.push('  pipelines:');
+    for (const pl of config.pipelines) {
+      const label = pl.label ? ` # ${pl.label}` : '';
+      lines.push(`    - id: ${pl.id}${label}`);
+    }
+  }
+  if (config.criticalIssueLabels.length > 0) {
+    lines.push(
+      `  critical-issue-labels: [${config.criticalIssueLabels.map((l) => JSON.stringify(l)).join(', ')}]`
+    );
+  }
+  return lines;
+}
+
+/**
+ * Resolves the config file path (CLAUDE.md or AGENTS.md).
+ * @param {string} repoRoot
+ * @returns {string|null}
+ */
+export function resolveConfigFile(repoRoot) {
+  const claude = join(repoRoot, 'CLAUDE.md');
+  const agents = join(repoRoot, 'AGENTS.md');
+  if (existsSync(claude)) return claude;
+  if (existsSync(agents)) return agents;
+  return null;
+}
+
+/**
+ * Reads existing ecosystem-health config from the policy JSON file.
+ * Uses .orchestrator/policy/ecosystem.json as the reliable source of truth
+ * (valid JSON, precisely parseable). Returns null when missing or malformed.
+ *
+ * @param {string} repoRoot
+ * @returns {{endpoints: object[], pipelines: object[], criticalIssueLabels: string[]} | null}
+ */
+export function readExistingEcosystemConfig(repoRoot) {
+  const policyPath = join(repoRoot, '.orchestrator', 'policy', 'ecosystem.json');
+  if (!existsSync(policyPath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(policyPath, 'utf8'));
+  } catch {
+    return null;
+  }
+  const errors = validateEcosystemPolicy(parsed);
+  if (errors.length > 0) return null;
+  return {
+    endpoints: Array.isArray(parsed.endpoints) ? parsed.endpoints : [],
+    pipelines: Array.isArray(parsed.pipelines) ? parsed.pipelines : [],
+    criticalIssueLabels: Array.isArray(parsed.criticalIssueLabels) ? parsed.criticalIssueLabels : [],
+  };
+}
+
+/**
+ * Writes (or updates) an `ecosystem-health:` block inside Session Config.
+ * When `overwrite` is true and an ecosystem-health block already exists, it is
+ * replaced with the new config (diff-aware merge). When `overwrite` is false
+ * and ecosystem-health already exists, the function skips (legacy behaviour).
+ *
+ * @param {string} configFilePath
+ * @param {{endpoints: object[], pipelines: object[], criticalIssueLabels: string[]}} config
+ * @param {boolean} dryRun
+ * @param {boolean} [overwrite=false]
+ * @returns {'written' | 'skipped' | 'error'}
+ */
+export function writeSessionConfigBlock(configFilePath, config, dryRun, overwrite = false) {
+  let text;
+  try {
+    text = readFileSync(configFilePath, 'utf8');
+  } catch {
+    return 'error';
+  }
+
+  const startMatch = text.match(/^## Session Config[ \t]*(?:\r?\n|$)/m);
+  const snippetLines = _buildEcosystemSnippetLines(config);
+
+  if (_ecosystemBlockPresent(text, startMatch)) {
+    if (!overwrite) return 'skipped';
+    // Replace the existing ecosystem-health block with the new snippet.
+    // The block spans from "ecosystem-health:" to the next top-level key or heading.
+    const newText = _replaceEcosystemBlock(text, snippetLines);
+    // If text did not change after replacement (regex produced the same string), skip.
+    // Also skip if the only difference is trailing whitespace on the replaced block — this
+    // happens when the existing file has an equivalent but differently formatted placeholder.
+    if (newText === text) return 'skipped';
+    if (!dryRun) {
+      try { writeFileSync(configFilePath, newText, 'utf8'); } catch { return 'error'; }
+    }
+    return 'written';
+  }
+
+  // Insert path: append ecosystem-health block to Session Config section
+  const newText = _insertEcosystemBlock(text, startMatch, snippetLines);
+  if (!dryRun) {
+    try { writeFileSync(configFilePath, newText, 'utf8'); } catch { return 'error'; }
+  }
+  return 'written';
+}
+
+/**
+ * Writes .orchestrator/policy/ecosystem.json.
+ *
+ * @param {string} repoRoot
+ * @param {{endpoints: object[], pipelines: object[], criticalIssueLabels: string[]}} config
+ * @param {boolean} dryRun
+ * @returns {'written' | 'skipped' | 'error'}
+ */
+export function writePolicyFile(repoRoot, config, dryRun) {
+  const policyDir = join(repoRoot, '.orchestrator', 'policy');
+  const policyPath = join(policyDir, 'ecosystem.json');
+
+  // Idempotency: read existing — if contents are identical, skip
+  if (existsSync(policyPath)) {
+    try {
+      const existing = JSON.parse(readFileSync(policyPath, 'utf8'));
+      // Re-check if it already has the same data (simple deep-equal via JSON round-trip)
+      const proposed = buildPolicyObject(config);
+      if (JSON.stringify(existing) === JSON.stringify(proposed)) {
+        return 'skipped';
+      }
+    } catch {
+      // malformed existing file — overwrite
+    }
+  }
+
+  const policy = buildPolicyObject(config);
+  if (!dryRun) {
+    try {
+      mkdirSync(policyDir, { recursive: true });
+      writeFileSync(policyPath, JSON.stringify(policy, null, 2) + '\n', 'utf8');
+    } catch {
+      return 'error';
+    }
+  }
+  return 'written';
+}
+
+export function buildPolicyObject(config) {
+  return {
+    version: 1,
+    rationale:
+      'Ecosystem health configuration. Generated by /bootstrap --ecosystem-health. Hand-edit to add or remove endpoints.',
+    endpoints: config.endpoints,
+    pipelines: config.pipelines,
+    criticalIssueLabels: config.criticalIssueLabels,
+  };
+}

package/scripts/lib/ecosystem-wizard/package-manager-detector.mjs

@@ -0,0 +1,42 @@
+/**
+ * package-manager-detector.mjs — detects package manager from lockfile presence
+ * and reads package.json script names for informational surfacing.
+ *
+ * A root lockfile that is gitignored is treated as absent (issue #715 bug
+ * class) — reuses the shared isIgnoredRootFile() helper from
+ * package-manager.mjs rather than re-implementing .gitignore parsing.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isIgnoredRootFile } from '../package-manager.mjs';
+
+/**
+ * Detects package manager from lockfile presence. A root lockfile that is
+ * gitignored is treated as absent.
+ * @param {string} repoRoot
+ * @returns {'pnpm' | 'yarn' | 'bun' | 'npm' | null}
+ */
+export function detectPackageManagerFromRoot(repoRoot) {
+  if (existsSync(join(repoRoot, 'pnpm-lock.yaml')) && !isIgnoredRootFile(repoRoot, 'pnpm-lock.yaml')) return 'pnpm';
+  if (existsSync(join(repoRoot, 'yarn.lock')) && !isIgnoredRootFile(repoRoot, 'yarn.lock')) return 'yarn';
+  if (existsSync(join(repoRoot, 'bun.lockb')) && !isIgnoredRootFile(repoRoot, 'bun.lockb')) return 'bun';
+  if (existsSync(join(repoRoot, 'package-lock.json')) && !isIgnoredRootFile(repoRoot, 'package-lock.json')) return 'npm';
+  return null;
+}
+
+/**
+ * Reads package.json scripts to surface script names (informational).
+ * @param {string} repoRoot
+ * @returns {string[]}
+ */
+export function readPackageScripts(repoRoot) {
+  const pkgPath = join(repoRoot, 'package.json');
+  if (!existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return Object.keys(pkg.scripts || {});
+  } catch {
+    return [];
+  }
+}