harness-everything 0.2.2 → 0.4.0

package/scripts/lib/workspace.js

@@ -1,14 +1,246 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
 
-function getWorkspaceRoot() {
-  let dir = path.resolve(process.cwd());
-  while (dir !== path.parse(dir).root) {
-    if (fs.existsSync(path.join(dir, '.git'))) return dir;
-    dir = path.dirname(dir);
+const WORKSPACE_CONTEXT_KEYS = [
+  'workspace_root', 'workspaceRoot', 'project_root', 'projectRoot',
+  'working_directory', 'workingDirectory', 'cwd', 'root'
+];
+const SESSION_CONTEXT_KEYS = ['session_id', 'sessionId'];
+const HOST_CONTEXT_KEYS = [
+  'host_id', 'hostId', 'agent_id', 'agentId', 'client_id', 'clientId',
+  'machine_id', 'machineId', 'runtime_id', 'runtimeId'
+];
+const SESSION_REGISTRY_DIR = 'session-workspaces';
+const SESSION_REGISTRY_VERSION = 1;
+const UNBOUND_WORKSPACE_KEY = 'unbound-workspace';
+
+function findWorkspaceRoot(startPath, allowNonGit = false) {
+  if (typeof startPath !== 'string' || !startPath.trim()) return null;
+  let dir = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.git'))) return canonicalPath(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return allowNonGit ? canonicalPath(startPath) : null;
+}
+
+function canonicalPath(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const resolved = path.resolve(value);
+  try { return fs.realpathSync(resolved); } catch (err) { return resolved; }
+}
+
+function getSessionId(context) {
+  if (!context || typeof context !== 'object') return null;
+  for (const key of SESSION_CONTEXT_KEYS) {
+    if (typeof context[key] === 'string' && context[key].trim()) {
+      return context[key].trim();
+    }
+  }
+  for (const key of ['session', 'metadata', 'context']) {
+    if (context[key] && typeof context[key] === 'object') {
+      const nested = getSessionId(context[key]);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function getHostId(context) {
+  if (!context || typeof context !== 'object') return null;
+  for (const key of HOST_CONTEXT_KEYS) {
+    if (typeof context[key] === 'string' && context[key].trim()) return context[key].trim();
+  }
+  if (typeof context.host === 'string' && context.host.trim()) return context.host.trim();
+  if (context.host && typeof context.host === 'object') return getHostId(context.host);
+  for (const key of ['agent', 'client', 'machine', 'runtime', 'metadata', 'context']) {
+    if (context[key] && typeof context[key] === 'object') {
+      const nested = getHostId(context[key]);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function contextPath(context, depth = 0) {
+  if (typeof context === 'string' && context.trim()) return context.trim();
+  if (!context || typeof context !== 'object' || depth > 2) return null;
+
+  for (const key of WORKSPACE_CONTEXT_KEYS) {
+    const value = context[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+    if (value && typeof value === 'object') {
+      const nested = contextPath(value, depth + 1);
+      if (nested) return nested;
+    }
+  }
+
+  for (const key of ['workspace', 'project', 'host', 'context']) {
+    const nested = contextPath(context[key], depth + 1);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+function sessionRegistryPath(sessionId, hostId) {
+  const namespace = hostId ? `${hostId}\0${sessionId}` : String(sessionId);
+  const hash = crypto.createHash('sha256').update(namespace).digest('hex');
+  return path.join(getStateHome(), SESSION_REGISTRY_DIR, `${hash}.json`);
+}
+
+function readRegistryRecord(filePath) {
+  try {
+    const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (record.version !== SESSION_REGISTRY_VERSION || typeof record.workspaceRoot !== 'string') return null;
+    return record;
+  } catch (err) {
+    return null;
+  }
+}
+
+function findSessionRecords(sessionId) {
+  const registryDir = path.join(getStateHome(), SESSION_REGISTRY_DIR);
+  try {
+    return fs.readdirSync(registryDir, { withFileTypes: true })
+      .filter(entry => entry.isFile() && entry.name.endsWith('.json'))
+      .map(entry => readRegistryRecord(path.join(registryDir, entry.name)))
+      .filter(record => record && record.sessionId === sessionId);
+  } catch (err) {
+    return [];
+  }
+}
+
+function readWorkspaceSession(sessionId, context) {
+  if (!sessionId) return null;
+  const hostId = getHostId(context);
+  const records = [];
+  const preferred = readRegistryRecord(sessionRegistryPath(sessionId, hostId));
+  if (preferred && (!hostId || !preferred.hostId || preferred.hostId === hostId)) records.push(preferred);
+  if (hostId) {
+    // A session may have been first observed by a caller that did not expose
+    // host metadata. Reuse that unscoped binding rather than forking state.
+    const unscoped = readRegistryRecord(sessionRegistryPath(sessionId, null));
+    if (unscoped && !unscoped.hostId) records.push(unscoped);
+  } else {
+    records.push(...findSessionRecords(sessionId));
   }
-  return process.cwd();
+
+  const unique = [...new Map(records.map(record => [
+    `${record.hostId || ''}\0${record.workspaceRoot}`,
+    record
+  ])).values()];
+  if (unique.length === 1) return unique[0];
+  if (unique.length > 1) {
+    // Hostless payloads are safe only when all known host bindings agree on
+    // the same workspace. Otherwise select nothing and require context.
+    const roots = new Set(unique.map(record => canonicalPath(record.workspaceRoot)));
+    if (roots.size === 1) return unique[0];
+  }
+  return null;
+}
+
+function bindWorkspaceSession(sessionId, workspaceRoot, context, force = false) {
+  if (!sessionId) return null;
+  const root = findWorkspaceRoot(workspaceRoot, true);
+  if (!root) return null;
+  const hostId = getHostId(context);
+  const target = sessionRegistryPath(sessionId, hostId);
+  const record = {
+    version: SESSION_REGISTRY_VERSION,
+    sessionId,
+    hostId: hostId || undefined,
+    workspaceRoot: root,
+    workspaceKey: getWorkspaceKey(root),
+    updatedAt: new Date().toISOString()
+  };
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(temporary, JSON.stringify(record, null, 2), 'utf8');
+    // Keep the first successful binding when two hooks initialize together.
+    if (fs.existsSync(target)) {
+      if (readRegistryRecord(target) && !force) fs.unlinkSync(temporary);
+      else {
+        fs.unlinkSync(target);
+        fs.renameSync(temporary, target);
+      }
+    } else fs.renameSync(temporary, target);
+  } catch (err) {
+    // Identity persistence is best effort. The caller still receives the
+    // resolved root and the next invocation can retry the binding.
+    try { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); } catch (cleanupErr) { /* ignore */ }
+  }
+  return root;
+}
+
+function isIdentityReset(context) {
+  if (!context || typeof context !== 'object') return false;
+  return context.workspace_identity_reset === true ||
+    context.workspaceIdentityReset === true ||
+    context.new_session === true ||
+    context.newSession === true;
+}
+
+function getWorkspaceRoot(context) {
+  const sessionId = getSessionId(context);
+  const existing = readWorkspaceSession(sessionId, context);
+  const explicit = contextPath(context);
+
+  // SessionStart is the host's authoritative opportunity to establish (or
+  // re-establish) the project identity. All later hook invocations keep that
+  // binding even if the agent changes cwd or reports a nested repository.
+  if (existing && !isIdentityReset(context)) return existing.workspaceRoot;
+
+  const hostRoot = explicit || process.env.HARNESS_WORKSPACE_ROOT ||
+    process.env.CLAUDE_PROJECT_DIR || process.env.CODEX_PROJECT_DIR;
+  const root = findWorkspaceRoot(hostRoot || process.cwd(), Boolean(hostRoot));
+  if (sessionId) bindWorkspaceSession(sessionId, root, context, isIdentityReset(context));
+  return root;
+}
+
+// Single global root for ALL Harness runtime state (session counters,
+// circuit-breaker trips, audit logs, handoff timestamps, ...). Never
+// cwd-derived, so a script invoked from a fixture dir, worktree, submodule,
+// or any other nested non-git directory can never scatter files there
+// (issue #42). `$HARNESS_STATE_HOME` matches the env var the opencode
+// plugin already used for its own (differently-rooted) global state.
+function getStateHome() {
+  return process.env.HARNESS_STATE_HOME || path.join(os.homedir(), '.agents', 'harness-everything');
+}
+
+// Keys runtime state per real workspace instead of per invocation cwd, so
+// two different repos (or a repo and a stray subdirectory someone `cd`ed
+// into) never collide or fork the same state stream. Uses the resolved real
+// path (symlinks collapsed) hashed short, prefixed with a readable slug
+// purely so `~/.agents/harness-everything/workspaces/` stays eyeballable.
+function getWorkspaceKey(root) {
+  const workspaceRoot = typeof root === 'string' && root.trim() ? root : getWorkspaceRoot(root);
+  if (!workspaceRoot) return UNBOUND_WORKSPACE_KEY;
+  const resolved = path.resolve(workspaceRoot);
+  let real = resolved;
+  try { real = fs.realpathSync(resolved); } catch (err) { /* path may not exist yet (tests) */ }
+  const slug = path.basename(real).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'workspace';
+  const hashInput = process.platform === 'win32' ? real.toLowerCase() : real;
+  const hash = crypto.createHash('sha1').update(hashInput).digest('hex').slice(0, 12);
+  return `${slug}-${hash}`;
+}
+
+function getWorkspaceStateDir(root) {
+  return path.join(getStateHome(), 'workspaces', getWorkspaceKey(root));
+}
+
+function resolveWorkspaceIdentity(context) {
+  const workspaceRoot = getWorkspaceRoot(context);
+  return {
+    workspaceRoot,
+    workspaceKey: getWorkspaceKey(workspaceRoot),
+    stateDir: getWorkspaceStateDir(workspaceRoot),
+    sessionId: getSessionId(context)
+  };
 }
 
 function getUserPromptsDir() {
@@ -25,4 +257,34 @@ function getUserPromptsDir() {
   }
 }
 
-module.exports = { getWorkspaceRoot, getUserPromptsDir };
+// The harness repo must never be "repaired" into carrying its own generated
+// advisory files. Identify it by repo identity, not by comparing the caller's
+// __dirname: when harness runs from an npx/global install against its own
+// source checkout, the installed path and the workspace path differ and a
+// path-based guard silently fails open (issue #40).
+const HARNESS_PACKAGE_NAME = 'harness-everything';
+
+function isHarnessRepo(workspaceRoot) {
+  try {
+    const pkgPath = path.join(workspaceRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.name === HARNESS_PACKAGE_NAME;
+  } catch (err) {
+    return false;
+  }
+}
+
+module.exports = {
+  getWorkspaceRoot,
+  resolveWorkspaceIdentity,
+  bindWorkspaceSession,
+  readWorkspaceSession,
+  getSessionId,
+  getHostId,
+  getStateHome,
+  getWorkspaceKey,
+  getWorkspaceStateDir,
+  getUserPromptsDir,
+  isHarnessRepo,
+  HARNESS_PACKAGE_NAME,
+};

package/scripts/sync-openai-plugin.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, '.claude-plugin', 'plugin.json'), 'utf8'));
+const pluginSkillsRoot = path.join(ROOT, 'plugins', 'harness-everything', 'skills');
+const pluginRoot = path.join(ROOT, 'plugins', 'harness-everything');
+const pluginHooksRoot = path.join(pluginRoot, 'hooks');
+const sourceHooksScriptsRoot = path.join(ROOT, 'hooks', 'scripts');
+
+function normalizeText(file) {
+  const bytes = fs.readFileSync(file);
+  // Skills and hooks are text, but keeping binary assets byte-preserving makes
+  // this copier safe if a referenced asset is added later.
+  if (bytes.includes(0)) return;
+  const normalized = bytes.toString('utf8').replace(/\r\n/g, '\n');
+  fs.writeFileSync(file, normalized, 'utf8');
+}
+
+function normalizeTree(root) {
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) normalizeTree(full);
+    else if (entry.isFile()) normalizeText(full);
+  }
+}
+
+function syncTree(source, destination) {
+  fs.rmSync(destination, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  if (fs.statSync(source).isDirectory()) {
+    fs.cpSync(source, destination, { recursive: true });
+    normalizeTree(destination);
+  } else {
+    fs.copyFileSync(source, destination);
+    normalizeText(destination);
+  }
+}
+
+fs.mkdirSync(pluginSkillsRoot, { recursive: true });
+
+const expected = new Set();
+for (const entry of manifest.skills || []) {
+  const source = path.resolve(ROOT, entry);
+  const name = path.basename(source);
+  const destination = path.join(pluginSkillsRoot, name);
+  expected.add(name);
+  syncTree(source, destination);
+  console.log(`synced ${name}`);
+}
+
+for (const name of fs.readdirSync(pluginSkillsRoot)) {
+  if (!expected.has(name)) fs.rmSync(path.join(pluginSkillsRoot, name), { recursive: true, force: true });
+}
+
+// The Claude hook definitions are host-specific, but their enforcement
+// scripts are shared. Package the scripts plus the small runtime libraries
+// they require so every OpenAI hook is self-contained under PLUGIN_ROOT.
+const packageHookScriptsRoot = path.join(pluginHooksRoot, 'scripts');
+syncTree(sourceHooksScriptsRoot, packageHookScriptsRoot);
+
+const packageWorkspace = path.join(packageHookScriptsRoot, 'lib', 'workspace.js');
+syncTree(path.join(ROOT, 'scripts', 'lib', 'workspace.js'), packageWorkspace);
+
+const packageAdvisoryText = path.join(pluginRoot, 'scripts', 'lib', 'advisory-text.js');
+syncTree(path.join(ROOT, 'scripts', 'lib', 'advisory-text.js'), packageAdvisoryText);
+
+// The source hook state module is shared with Claude and uses the repository
+// layout. Rewrite only that import in the packaged copy; all other relative
+// imports remain inside the package tree.
+const packageState = path.join(packageHookScriptsRoot, 'lib', 'harness-state.js');
+const stateSource = fs.readFileSync(packageState, 'utf8');
+fs.writeFileSync(
+  packageState,
+  stateSource.replace("require('../../../scripts/lib/workspace')", "require('./workspace')"),
+  'utf8'
+);
+
+const packageSessionStart = path.join(pluginHooksRoot, 'session-start.js');
+syncTree(path.join(sourceHooksScriptsRoot, 'openai-session-start.js'), packageSessionStart);
+const sessionSource = fs.readFileSync(packageSessionStart, 'utf8');
+fs.writeFileSync(
+  packageSessionStart,
+  sessionSource.replace("require('./lib/harness-state')", "require('./scripts/lib/harness-state')"),
+  'utf8'
+);
+
+console.log(`OpenAI plugin skills and runtime synchronized: ${expected.size} skills`);

package/scripts/sync-release-version.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const STABLE_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+
+const VERSION_TARGETS = [
+  { file: 'package.json', get: data => data.version, set: (data, v) => { data.version = v; } },
+  {
+    file: 'package-lock.json',
+    get: data => [data.version, data.packages && data.packages[''] && data.packages[''].version],
+    set: (data, v) => {
+      if (!data.packages || !data.packages['']) throw new Error('package-lock.json missing packages[""]');
+      data.version = v;
+      data.packages[''].version = v;
+    }
+  },
+  { file: '.claude-plugin/plugin.json', get: data => data.version, set: (data, v) => { data.version = v; } },
+  {
+    file: '.claude-plugin/marketplace.json',
+    get: data => {
+      const entry = Array.isArray(data.plugins) ? data.plugins.find(p => p && p.name === 'harness-everything') : null;
+      return entry && entry.version;
+    },
+    set: (data, v) => {
+      const entry = Array.isArray(data.plugins) ? data.plugins.find(p => p && p.name === 'harness-everything') : null;
+      if (!entry) throw new Error('.claude-plugin/marketplace.json missing harness-everything plugin entry');
+      entry.version = v;
+    }
+  },
+  { file: 'plugins/harness-everything/plugin.json', get: data => data.version, set: (data, v) => { data.version = v; } },
+  { file: 'plugins/harness-everything/.codex-plugin/plugin.json', get: data => data.version, set: (data, v) => { data.version = v; } },
+  { file: 'opencode-plugin/plugin.json', get: data => data.version, set: (data, v) => { data.version = v; } }
+];
+
+function isStableSemVer(version) {
+  return STABLE_SEMVER.test(String(version || ''));
+}
+
+function readJsonTargets(root) {
+  return VERSION_TARGETS.map(target => {
+    const filePath = path.join(root, target.file);
+    if (!fs.existsSync(filePath)) throw new Error(`Missing release version target: ${target.file}`);
+    let data;
+    try {
+      data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (error) {
+      throw new Error(`Invalid JSON in ${target.file}: ${error.message}`);
+    }
+    const current = target.get(data);
+    if (Array.isArray(current)) {
+      if (current.some(value => typeof value !== 'string' || !value)) {
+        throw new Error(`${target.file} is missing one or more owned version fields`);
+      }
+    } else if (typeof current !== 'string' || !current) {
+      throw new Error(`${target.file} is missing its owned version field`);
+    }
+    return { kind: 'json', target, filePath, data, current };
+  });
+}
+
+function canonicalSkillDirs(root) {
+  const manifestPath = path.join(root, '.claude-plugin', 'plugin.json');
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  if (!Array.isArray(manifest.skills)) throw new Error('.claude-plugin/plugin.json missing skills array');
+  return manifest.skills.map(entry => {
+    const dir = path.resolve(root, entry);
+    const boundary = `${root}${path.sep}`;
+    if (dir !== root && !dir.startsWith(boundary)) throw new Error(`Skill path escapes repository: ${entry}`);
+    if (!fs.existsSync(path.join(dir, 'SKILL.md'))) throw new Error(`Skill path missing SKILL.md: ${entry}`);
+    return { entry, dir, rel: path.relative(root, dir).replace(/\\/g, '/') };
+  });
+}
+
+function changedSkillDirs(root, base) {
+  if (!base) return [];
+  const skills = canonicalSkillDirs(root);
+  let changed;
+  try {
+    changed = execFileSync(
+      'git',
+      ['diff', '--name-only', `${base}...HEAD`, '--', ...skills.map(skill => skill.rel)],
+      { cwd: root, encoding: 'utf8' }
+    ).split(/\r?\n/).filter(Boolean);
+  } catch (error) {
+    throw new Error(`Unable to diff changed skills from ${base}: ${String(error.stderr || error.message).trim()}`);
+  }
+  return skills.filter(skill => changed.some(file => file === skill.rel || file.startsWith(`${skill.rel}/`)));
+}
+
+function walkSkillDocs(root, dir, out = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walkSkillDocs(root, full, out);
+    else if (entry.isFile() && entry.name === 'SKILL.md') out.push(full);
+  }
+  return out;
+}
+
+function readSkillTargets(root, base) {
+  const records = [];
+  for (const skill of changedSkillDirs(root, base)) {
+    for (const filePath of walkSkillDocs(root, skill.dir)) {
+      const text = fs.readFileSync(filePath, 'utf8');
+      const match = text.match(/^(\s{2}version:\s*)(\S+)(\s*)$/m);
+      const rel = path.relative(root, filePath).replace(/\\/g, '/');
+      if (!match) throw new Error(`${rel} is missing metadata.version`);
+      records.push({
+        kind: 'skill',
+        file: rel,
+        filePath,
+        text,
+        current: match[2],
+        prefix: match[1],
+        suffix: match[3]
+      });
+    }
+  }
+  return records;
+}
+
+function syncReleaseVersion(root, version, options = {}) {
+  if (!isStableSemVer(version)) {
+    throw new Error(`Release version must be stable SemVer x.y.z (no prerelease/build suffix): ${version}`);
+  }
+
+  // Read and validate every target before the first write. This keeps a missing
+  // manifest or malformed skill version from leaving a half-updated release tree.
+  const jsonRecords = readJsonTargets(root);
+  const skillRecords = readSkillTargets(root, options.base);
+  const records = [...jsonRecords, ...skillRecords];
+
+  if (options.checkOnly) {
+    const mismatches = [];
+    for (const record of records) {
+      const values = Array.isArray(record.current) ? record.current : [record.current];
+      if (values.some(value => value !== version)) {
+        const name = record.kind === 'json' ? record.target.file : record.file;
+        mismatches.push(`${name}: ${values.join(', ')} != ${version}`);
+      }
+    }
+    if (mismatches.length) throw new Error(`Release version drift:\n${mismatches.join('\n')}`);
+    return records.map(record => record.kind === 'json' ? record.target.file : record.file);
+  }
+
+  for (const record of jsonRecords) record.target.set(record.data, version);
+  for (const record of jsonRecords) {
+    fs.writeFileSync(record.filePath, `${JSON.stringify(record.data, null, 2)}\n`, 'utf8');
+  }
+  for (const record of skillRecords) {
+    const next = record.text.replace(
+      /^(\s{2}version:\s*)(\S+)(\s*)$/m,
+      `$1${version}$3`
+    );
+    fs.writeFileSync(record.filePath, next, 'utf8');
+  }
+
+  return records.map(record => record.kind === 'json' ? record.target.file : record.file);
+}
+
+function parseArgs(argv) {
+  let checkOnly = false;
+  let validateOnly = false;
+  let version = null;
+  let base = null;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--check') checkOnly = true;
+    else if (arg === '--validate') validateOnly = true;
+    else if (arg === '--base') {
+      base = argv[++i];
+      if (!base) throw new Error('--base requires a git ref');
+    } else if (!version) version = arg;
+    else throw new Error(`Unexpected argument: ${arg}`);
+  }
+  return { checkOnly, validateOnly, version, base };
+}
+
+function main(argv = process.argv.slice(2)) {
+  const { checkOnly, validateOnly, version, base } = parseArgs(argv);
+  if (!version) throw new Error('Usage: sync-release-version.js [--check|--validate] <x.y.z> [--base <git-ref>]');
+  if (validateOnly) {
+    if (!isStableSemVer(version)) throw new Error(`Release version must be stable SemVer x.y.z: ${version}`);
+    console.log(`Valid stable release version: ${version}`);
+    return;
+  }
+  const files = syncReleaseVersion(ROOT, version, { checkOnly, base });
+  const skillNote = base ? ` (changed skills since ${base} included)` : '';
+  console.log(`${checkOnly ? 'Verified' : 'Synchronized'} release version ${version} across ${files.length} files${skillNote}.`);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  VERSION_TARGETS,
+  isStableSemVer,
+  canonicalSkillDirs,
+  changedSkillDirs,
+  syncReleaseVersion
+};