Function main

scripts/test-hook-events.js:15–66

()

const OPENCODE_FIXTURE = path.join(__dirname, 'fixtures', 'opencode-hook-events.json');

function fail(message) {
  console.error(message);
  process.exit(1);
}

// A hook must not be able to tell which runtime it is running under. For every
// fixture pair, the opencode payload and the equivalent Claude Code payload have
// to reduce to the same envelope fields.
function assertOpencodeEquivalence() {
  const fixture = JSON.parse(fs.readFileSync(OPENCODE_FIXTURE, 'utf8'));
  assert(fixture.equivalents.length > 0, 'opencode fixture has no equivalence cases');

  for (const item of fixture.equivalents) {
    const opencode = normalizeOpencodeHookInput(item.opencode);
    const claude = normalizeClaudeHookInput(item.claude);

    for (const [field, expected] of Object.entries(item.expect)) {
      assert.deepStrictEqual(
        opencode[field], expected,
        `${item.name}: opencode ${field} mismatch`,
      );
      assert.deepStrictEqual(
        claude[field], expected,
        `${item.name}: claude ${field} mismatch (fixture pair is not equivalent)`,
      );
    }

    assert.equal(opencode.runtime, 'opencode', `${item.name}: runtime mismatch`);
    assert.equal(
      opencode.native_event_name, item.opencode.hook_event_name,
      `${item.name}: native event name must be preserved for skip reporting`,
    );
    // The untouched payload has to survive: the plugin adapter mutates
    // opencode's own args object in place, which is the only mutation opencode
    // honors, so it cannot be handed a normalized copy.
    assert.strictEqual(opencode.raw, item.opencode, `${item.name}: raw payload must be the caller's object`);
  }

  // The fixture's mapped list and the shipped map must not drift apart.
  assert.deepStrictEqual(
    Object.keys(normalizeEvent.OPENCODE_EVENT_MAP).sort(),
    [...fixture.mapped].sort(),
    'opencode event map and fixture mapped list have drifted',
  );

  // Events we chose not to map must stay unmapped. Any of these silently
  // acquiring a Citadel event id would misreport the runtime's lifecycle.
  for (const native of Object.keys(fixture.deliberatelyUnmapped)) {
    assert.equal(
      normalizeEvent.OPENCODE_EVENT_MAP[native], undefined,
      `${native} must stay unmapped: ${fixture.deliberatelyUnmapped[native]}`,
    );
    // An unmapped name passes through rather than becoming a wrong event id.
    assert.equal(