@jakobm/peacekeeper 0.0.0-stage → 0.12.1

package/scripts/project-config.js

@@ -0,0 +1,99 @@
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CONFIG_FILE = 'peacekeeper.config.json';
+
+function repositoryRoot(cwd = process.cwd()) {
+  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd,
+    encoding: 'utf8',
+  }).trim();
+}
+
+function requireExactKeys(value, keys, location, file, optionalKeys = []) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${file}: ${location} must be an object`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key) && !optionalKeys.includes(key)) throw new Error(`${file}: unknown field ${location}.${key}`);
+  }
+  for (const key of keys) {
+    if (!Object.hasOwn(value, key)) throw new Error(`${file}: missing field ${location}.${key}`);
+  }
+}
+
+function requireNonemptyString(value, location, file) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`${file}: ${location} must be a nonempty string`);
+  }
+}
+
+function validateConfig(config, file) {
+  requireExactKeys(config, ['git', 'tests', 'loggingDirectory'], 'config', file, ['projectChecks']);
+  if (Object.hasOwn(config, 'projectChecks')) {
+    requireExactKeys(config.projectChecks, ['testWorkflow', 'requiredJobs'], 'projectChecks', file);
+    if (typeof config.projectChecks.testWorkflow !== 'string' || !/^[A-Za-z0-9_-]+\.ya?ml$/u.test(config.projectChecks.testWorkflow)) {
+      throw new Error(`${file}: projectChecks.testWorkflow must be a workflow filename`);
+    }
+    const jobs = config.projectChecks.requiredJobs;
+    if (!Array.isArray(jobs) || !jobs.length || jobs.some(job => typeof job !== 'string' || !job.trim() || job !== job.trim()) || new Set(jobs).size !== jobs.length) {
+      throw new Error(`${file}: projectChecks.requiredJobs must contain unique nonempty job names`);
+    }
+  }
+  requireExactKeys(config.git, ['remote', 'defaultBranch', 'branchPrefix'], 'git', file, ['checkpointPushRemotes', 'releaseMergeMethod', 'releaseRequiredChecks', 'releaseTestWorkflow']);
+  requireExactKeys(config.tests, ['commands', 'receiptMaxAgeMinutes', 'npmTestUsesRunner'], 'tests', file);
+
+  for (const field of ['remote', 'defaultBranch', 'branchPrefix']) {
+    requireNonemptyString(config.git[field], `git.${field}`, file);
+  }
+  if (Object.hasOwn(config.git, 'checkpointPushRemotes')) {
+    const remotes = config.git.checkpointPushRemotes;
+    if (!Array.isArray(remotes)
+        || remotes.some((remote) => typeof remote !== 'string' || remote.trim() === ''
+          || remote !== remote.trim() || remote.startsWith('-'))
+        || new Set(remotes).size !== remotes.length) {
+      throw new Error(`${file}: git.checkpointPushRemotes must be an array of unique remote names`);
+    }
+  }
+  if (Object.hasOwn(config.git, 'releaseTestWorkflow')) {
+    if (typeof config.git.releaseTestWorkflow !== 'string' || !/^[A-Za-z0-9_-]+\.ya?ml$/u.test(config.git.releaseTestWorkflow)) {
+      throw new Error(`${file}: git.releaseTestWorkflow must be a workflow filename ending in .yml or .yaml`);
+    }
+  }
+  if (Object.hasOwn(config.git, 'releaseRequiredChecks')) {
+    const checks = config.git.releaseRequiredChecks;
+    if (!Array.isArray(checks) || !checks.length || checks.some(check => typeof check !== 'string' || !check.trim() || check !== check.trim()) || new Set(checks).size !== checks.length) {
+      throw new Error(`${file}: git.releaseRequiredChecks must be a nonempty array of unique check names`);
+    }
+  }
+  if (Object.hasOwn(config.git, 'releaseMergeMethod')
+      && !['merge', 'squash', 'rebase'].includes(config.git.releaseMergeMethod)) {
+    throw new Error(`${file}: git.releaseMergeMethod must be merge, squash, or rebase`);
+  }
+  requireNonemptyString(config.loggingDirectory, 'loggingDirectory', file);
+  if (!Array.isArray(config.tests.commands) || config.tests.commands.length === 0
+      || config.tests.commands.some((command) => typeof command !== 'string' || command.trim() === '')) {
+    throw new Error(`${file}: tests.commands must be a nonempty array of command strings`);
+  }
+  if (!Number.isSafeInteger(config.tests.receiptMaxAgeMinutes)
+      || config.tests.receiptMaxAgeMinutes < 1) {
+    throw new Error(`${file}: tests.receiptMaxAgeMinutes must be a positive integer`);
+  }
+  if (typeof config.tests.npmTestUsesRunner !== 'boolean') {
+    throw new Error(`${file}: tests.npmTestUsesRunner must be a boolean`);
+  }
+}
+
+function projectConfig(cwd = process.cwd()) {
+  const root = repositoryRoot(cwd);
+  const file = path.join(root, CONFIG_FILE);
+  if (!fs.existsSync(file)) {
+    throw new Error(`${file}: configuration file is required; define tests.commands explicitly`);
+  }
+  const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  validateConfig(config, file);
+  return { root, ...config };
+}
+
+module.exports = { CONFIG_FILE, projectConfig, repositoryRoot };

package/scripts/queue-merged-worktree-cleanup.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * Queue targeted cleanup for the current linked feature worktree.
+ *
+ * This explicit entrypoint is intended for workflows that have already
+ * confirmed a pull request merge and need cleanup to start before the Codex
+ * task is archived. The detached worker performs the same safety checks as the
+ * SessionEnd hook.
+ */
+
+const {
+  captureWorktreeTarget,
+  launchWorker,
+} = require('./cleanup-ended-session.js');
+const { logScriptInvocation } = require('./log-script-invocation.js');
+
+function helpText() {
+  return 'Usage: peacekeeper queue-merged-worktree-cleanup\n';
+}
+
+function queueCurrentWorktree(cwd = process.cwd(), launch = launchWorker) {
+  const target = captureWorktreeTarget(cwd);
+  if (!target) {
+    throw new Error(
+      'the current directory must be a linked worktree on a non-default branch',
+    );
+  }
+
+  const job = launch(target);
+  return { ...job, target };
+}
+
+function main(args = process.argv.slice(2)) {
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(helpText());
+    return;
+  }
+  if (args.length > 0) {
+    throw new Error(`unknown argument: ${args[0]}`);
+  }
+
+  logScriptInvocation();
+  const { logPath, pid, target } = queueCurrentWorktree();
+  console.log(`Queued cleanup for ${target.branch} at ${target.objectId}.`);
+  console.log(`Worker PID: ${pid}. Log: ${logPath}`);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { helpText, queueCurrentWorktree };

package/scripts/receipt-state.js

@@ -0,0 +1,81 @@
+const { execFileSync } = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { repositoryRoot } = require('./project-config');
+
+const ROOT = repositoryRoot;
+const RECEIPT_DIRECTORY = 'peacekeeper-test-receipts';
+
+function git(root, args) {
+  return execFileSync('git', args, { cwd: root, maxBuffer: 10 * 1024 * 1024 });
+}
+
+function pathsFromOutput(output) {
+  return output.toString('utf8').split('\0').filter(Boolean);
+}
+
+function changedPaths(root, baseCommit) {
+  const tracked = pathsFromOutput(git(root, [
+    'diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--name-only', '-z', baseCommit, '--',
+  ]));
+  const untracked = pathsFromOutput(git(root, ['ls-files', '--others', '--exclude-standard', '-z']));
+  return [...new Set([...tracked, ...untracked])].sort();
+}
+
+function fileFingerprint(root, relative) {
+  const fullPath = path.join(root, relative);
+  let stat;
+  try {
+    stat = fs.lstatSync(fullPath);
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'missing';
+    throw error;
+  }
+  const hash = crypto.createHash('sha256');
+  hash.update(`${stat.mode & 0o777}\0`);
+  if (stat.isSymbolicLink()) hash.update(fs.readlinkSync(fullPath));
+  else if (stat.isFile()) hash.update(fs.readFileSync(fullPath));
+  else hash.update(`special:${stat.mode}`);
+  return hash.digest('hex');
+}
+
+function sharedScriptsFingerprint() {
+  const hash = crypto.createHash('sha256');
+  for (const name of fs.readdirSync(__dirname).filter((file) => file.endsWith('.js')).sort()) {
+    hash.update(name);
+    hash.update('\0');
+    hash.update(fs.readFileSync(path.join(__dirname, name)));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+function environmentFingerprint() {
+  return JSON.stringify({
+    node: process.version,
+    platform: process.platform,
+    architecture: process.arch,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    sharedScripts: sharedScriptsFingerprint(),
+    environment: Object.fromEntries(['CI', 'TZ', 'LANG', 'LC_ALL', 'NODE_OPTIONS']
+      .map((name) => [name, process.env[name] || ''])),
+  });
+}
+
+function snapshot(root = ROOT(), baseCommit = git(root, ['rev-parse', 'HEAD']).toString('utf8').trim()) {
+  return {
+    baseCommit,
+    environment: environmentFingerprint(),
+    changedFiles: changedPaths(root, baseCommit)
+      .map((relative) => [relative, fileFingerprint(root, relative)]),
+  };
+}
+
+function receiptPath(root = ROOT()) {
+  const id = crypto.createHash('sha256').update(fs.realpathSync(root)).digest('hex');
+  return path.join(os.tmpdir(), RECEIPT_DIRECTORY, `${id}.git.json`);
+}
+
+module.exports = { ROOT, environmentFingerprint, receiptPath, snapshot };

package/scripts/record-test-receipt.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { ROOT, receiptPath, snapshot } = require('./receipt-state');
+
+function recordReceipt(root = ROOT(), testedSnapshot) {
+  const current = snapshot(root, testedSnapshot?.baseCommit);
+  if (testedSnapshot && JSON.stringify(current) !== JSON.stringify(testedSnapshot)) {
+    throw new Error('Files or environment changed while tests ran; rerun tests before recording a receipt.');
+  }
+  const receipt = { version: 1, passedAt: Date.now(), ...current };
+  const destination = receiptPath(root);
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(receipt)}\n`);
+  fs.renameSync(temporary, destination);
+  return receipt;
+}
+
+if (require.main === module) {
+  if (process.argv.length !== 2) {
+    console.error('Usage: node scripts/record-test-receipt.js');
+    process.exitCode = 2;
+  } else {
+    try {
+      recordReceipt();
+    } catch (error) {
+      console.error(error.message);
+      process.exitCode = 1;
+    }
+  }
+}
+
+module.exports = { recordReceipt };