@bongos/core 1.20.32 → 1.20.34

package/tests/move_escalation.mjs

@@ -0,0 +1,191 @@
+// tests/move_escalation.mjs — a core move nobody can heal files ONE blocker and ONE notice,
+// and a later move that lands closes it (task 1004449, goal 1000090 deploy self-heal).
+//
+// WHAT IS AT RISK. Two opposite failures: a person never hears about a move that left a
+// project down, or hears about it on every runner tick until they mute the channel. The
+// blockers table here is a fake that enforces the real (source, source_ref) uniqueness, and
+// the drain loop is the real one, so "one per failed move" is measured across retries and
+// re-runs rather than assumed.
+//
+// Run:  node tests/move_escalation.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+process.env.PROVISION_APP_USER = process.env.PROVISION_APP_USER || 'lars'; // appUser() refuses a Windows account name
+const require = createRequire(import.meta.url);
+const E = require('../scripts/gds/move-escalation.js');
+const P = require('../scripts/gds/provision.js');
+
+let passed = 0;
+let failed = 0;
+const t = async (name, fn) => {
+  try { await fn(); passed += 1; console.log(`  PASS  ${name}`); }
+  catch (e) { failed += 1; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+};
+
+const inst = (over = {}) => ({ id: 7, slug: 'cloudbongos', db_name: 'cloudbongos', port: 3002, status: 'active', hosting_shape: 'control-plane', owner_builder_id: 1, ...over });
+const unknownFail = { ok: false, error: 'core upgrade to 1.20.31 failed and was rolled back: health check failed after restart', failure: { class: 'unknown', reason: 'health' } };
+
+// A blockers table with the real partial unique index on (source, source_ref).
+function blockersTable() {
+  const rows = []; let next = 500;
+  const query = async (sql, params) => {
+    if (/INSERT INTO blockers/.test(sql)) {
+      const [title, body_md, source, source_ref] = params;
+      if (rows.some((r) => r.source === source && r.source_ref === source_ref)) return { rows: [] };
+      const r = { id: next++, title, body_md, source, source_ref, status: 'open' }; rows.push(r); return { rows: [{ id: r.id }] };
+    }
+    if (/UPDATE blockers/.test(sql)) {
+      const [source, like, note] = params; const prefix = like.replace(/%$/, '');
+      const hit = rows.filter((r) => r.status === 'open' && r.source === source && r.source_ref.startsWith(prefix));
+      for (const r of hit) { r.status = 'resolved'; r.resolution_note = note; }
+      return { rows: hit.map((r) => ({ id: r.id })) };
+    }
+    return { rows: [] };
+  };
+  return { rows, query };
+}
+
+console.log('\nwho needs a person (needsPerson):');
+
+await t('unknown and rollback_failed escalate; every other class does not', () => {
+  const i = { action: 'core-upgrade' };
+  assert.equal(E.needsPerson({ intent: i, failure: { class: 'unknown', reason: 'health' } }), true);
+  assert.equal(E.needsPerson({ intent: i, failure: { class: 'unknown', reason: 'rollback_failed' }, terminal: true }), true);
+  assert.equal(E.needsPerson({ intent: i, failure: { class: 'unknown', reason: 'remedy_did_not_hold' } }), true, 'a fix that did not hold (task 1004448)');
+  for (const c of ['transient', 'known_wedge', 'needs_decision']) assert.equal(E.needsPerson({ intent: i, failure: { class: c, reason: 'x' } }), false, c);
+  assert.equal(E.needsPerson({ intent: { action: 'restart' }, failure: { class: 'unknown', reason: 'x' } }), false, 'core moves only');
+});
+
+console.log('\nwhat is said (blockerFor, noticeText):');
+
+await t('the blocker names project, target, reason and what the move reported', () => {
+  const b = E.blockerFor({ inst: inst(), intent: { id: 11, target_version: '1.20.31' }, failure: unknownFail.failure, error: unknownFail.error });
+  assert.equal(b.source, 'provisioning');
+  assert.equal(b.sourceRef, 'core-move:7:11');
+  assert.match(b.title, /cloudbongos: the core move to 1\.20\.31 failed/);
+  assert.match(b.bodyMd, /`health`/);
+  assert.match(b.bodyMd, /health check failed after restart/);
+  assert.match(b.bodyMd, /closes by itself/);
+});
+
+await t('a failed rollback says the project may be down', () => {
+  const b = E.blockerFor({ inst: inst(), intent: { id: 11, target_version: '1.20.31' }, failure: { class: 'unknown', reason: 'rollback_failed' }, error: 'x' });
+  assert.match(b.title, /may be down/);
+  assert.match(E.noticeText({ kind: 'failed', name: 'x', down: true }), /may be down/);
+});
+
+await t('reported output cannot break out of its code block', () => {
+  const b = E.blockerFor({ inst: inst(), intent: { id: 1, target_version: '1' }, failure: unknownFail.failure, error: 'a```\n# injected' });
+  assert.equal((b.bodyMd.match(/```/g) || []).length, 2);
+});
+
+await t('Discord names only a PUBLIC project, and never carries the upgrade output', () => {
+  assert.match(E.noticeText({ kind: 'failed', name: null, to: '1.20.31' }), /^⚠️ A private project/);
+  assert.match(E.noticeText({ kind: 'failed', name: 'mercury', to: '1.20.31' }), /\*\*mercury\*\*/);
+  assert.doesNotMatch(E.noticeText({ kind: 'failed', name: 'm', to: '1' }), /health/);
+});
+
+console.log('\nonce per failed move, closed by success (afterRetire / afterSuccess):');
+
+function deps(table, { visibility = 'private' } = {}) {
+  const posts = [];
+  return { posts, d: { apply: true, log: () => {}, db: { query: table.query }, postNotice: (text) => posts.push(text), provisioning: { effectiveSettings: () => ({ visibility }) } } };
+}
+
+await t('a retired unknown move files one blocker and one notice', async () => {
+  const table = blockersTable(); const { posts, d } = deps(table);
+  const r = await E.afterRetire({ intent: { id: 11, action: 'core-upgrade', target_version: '1.20.31' }, inst: inst(), result: unknownFail, deps: d });
+  assert.equal(r.filed, true);
+  assert.equal(table.rows.length, 1);
+  assert.equal(posts.length, 1);
+});
+
+await t('the same move retiring again files nothing and posts nothing', async () => {
+  const table = blockersTable(); const { posts, d } = deps(table);
+  const i = { id: 11, action: 'core-upgrade', target_version: '1.20.31' };
+  await E.afterRetire({ intent: i, inst: inst(), result: unknownFail, deps: d });
+  const again = await E.afterRetire({ intent: i, inst: inst(), result: unknownFail, deps: d });
+  assert.equal(again.filed, false);
+  assert.equal(table.rows.length, 1);
+  assert.equal(posts.length, 1, 'edge-triggered: the notice follows the insert');
+});
+
+await t('a later move that lands closes this project\'s blockers — and only this project\'s', async () => {
+  const table = blockersTable(); const { posts, d } = deps(table, { visibility: 'public' });
+  await E.afterRetire({ intent: { id: 11, action: 'core-upgrade', target_version: '1.20.31' }, inst: inst(), result: unknownFail, deps: d });
+  await E.afterRetire({ intent: { id: 12, action: 'core-upgrade', target_version: '1.20.31' }, inst: inst({ id: 70, slug: 'other' }), result: unknownFail, deps: d });
+  const r = await E.afterSuccess({ intent: { id: 13, action: 'core-upgrade', target_version: '1.20.32' }, inst: inst(), result: { ok: true, served: '1.20.32' }, deps: d });
+  assert.equal(r.closed, 1);
+  assert.deepEqual(table.rows.map((x) => x.status), ['resolved', 'open'], 'instance 70 is not instance 7 — a LIKE prefix must not over-match');
+  assert.match(table.rows[0].resolution_note, /later core move to 1\.20\.32 succeeded \(intent 13\)/);
+  assert.match(posts[posts.length - 1], /^✅ \*\*cloudbongos\*\* took its core update to 1\.20\.32/);
+});
+
+await t('a no-op or a failed result closes nothing; nothing open posts no all-clear', async () => {
+  const table = blockersTable(); const { posts, d } = deps(table);
+  await E.afterRetire({ intent: { id: 11, action: 'core-upgrade', target_version: '1' }, inst: inst(), result: unknownFail, deps: d });
+  assert.equal((await E.afterSuccess({ intent: { id: 13, action: 'core-upgrade' }, inst: inst(), result: { ok: true, noop: true }, deps: d })).closed, 0);
+  assert.equal((await E.afterSuccess({ intent: { id: 13, action: 'core-upgrade' }, inst: inst(), result: { ok: false }, deps: d })).closed, 0);
+  const empty = blockersTable(); const e2 = deps(empty);
+  await E.afterSuccess({ intent: { id: 13, action: 'core-upgrade' }, inst: inst(), result: { ok: true, served: '1' }, deps: e2.d });
+  assert.equal(e2.posts.length, 0);
+});
+
+await t('a database error never throws into the drain', async () => {
+  const { d } = deps({ query: async () => { throw new Error('boom'); } });
+  assert.deepEqual(await E.afterRetire({ intent: { id: 1, action: 'core-upgrade' }, inst: inst(), result: unknownFail, deps: d }), { filed: false });
+  assert.deepEqual(await E.afterSuccess({ intent: { id: 1, action: 'core-upgrade' }, inst: inst(), result: { ok: true, served: '1' }, deps: d }), { closed: 0 });
+});
+
+console.log('\nthe drain loop, end to end:');
+
+// One move that fails `health` (rolled back, unknown), then — a later, separate move — lands.
+async function drain({ table, row, upgradeFails }) {
+  const posts = []; const resolved = [];
+  const deps = {
+    apply: true, privileged: false, log: () => {}, sleep: async () => {},
+    postNotice: (text) => posts.push(text),
+    db: { query: async (sql, params) => {
+      if (/blockers/.test(sql)) return table.query(sql, params);
+      if (/SET state='pending'/.test(sql)) { row.state = 'pending'; row.not_before = new Date(Date.now() + params[params.length - 1]); }
+      return { rows: [] };
+    } },
+    provisioning: {
+      claimNextIntent: async () => { if (row.state !== 'pending' || (row.not_before && row.not_before > new Date())) return null; row.state = 'running'; row.attempts += 1; return { ...row }; },
+      getInstanceById: async () => inst(),
+      resolveIntent: async (_db, id, state) => { resolved.push(state); row.state = state; },
+      setInstanceStatus: async () => {}, recordEvent: async () => {}, clearErrorNote: async () => {},
+      effectiveSettings: () => ({ visibility: 'private' }),
+      claimNextOAuthManifest: async () => null, resolveOAuthManifest: async () => {},
+    },
+    exec: (cmd) => {
+      if (/upgrade\.js/.test(cmd) && upgradeFails) { const e = new Error('Command failed'); e.stderr = '✖ health check failed after restart\nBONGOS_UPGRADE_OUTCOME {"stage":"rolled_back","reason":"health"}\n'; throw e; }
+      return { ok: true, stdout: /\/version/.test(cmd) ? JSON.stringify({ coreVersion: upgradeFails ? '1.20.30' : row.target_version, schemaPending: 0 }) : '' };
+    },
+    writeFile: () => ({ ok: true }),
+    readInstalledCoreVersion: () => '1.20.30', selfInstanceRoot: () => '/srv/cb',
+    updateChannel: { DEFAULT_CHANNEL: 'patch', normalizeChannel: (c) => c || 'patch', channelAllows: () => true, listAvailableVersions: () => ({ ok: true, versions: ['1.20.30', '1.20.31', '1.20.32'] }) },
+    checkDnsTokenScope: async () => ({ reachable: true, zone: 'z' }), checkCaddyWiring: () => null,
+  };
+  await P.cmdRunIntents(deps);
+  return { posts, resolved };
+}
+
+await t('a move that fails unknown files ONE blocker; a later move that lands closes it', async () => {
+  const table = blockersTable();
+  const first = await drain({ table, upgradeFails: true, row: { id: 11, instance_id: 7, action: 'core-upgrade', target_version: '1.20.31', attempts: 0, state: 'pending' } });
+  assert.deepEqual(first.resolved, ['error'], 'retired at once — unknown is not retried');
+  assert.equal(table.rows.length, 1);
+  assert.equal(table.rows[0].source_ref, 'core-move:7:11');
+  assert.equal(first.posts.length, 1);
+  const later = await drain({ table, upgradeFails: false, row: { id: 12, instance_id: 7, action: 'core-upgrade', target_version: '1.20.32', attempts: 0, state: 'pending' } });
+  assert.deepEqual(later.resolved, ['done']);
+  assert.equal(table.rows[0].status, 'resolved');
+  assert.equal(later.posts.length, 1);
+  assert.match(later.posts[0], /^✅ A private project took its core update to 1\.20\.32/);
+});
+
+console.log(`\nmove_escalation: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/plain_cards.mjs

@@ -18,7 +18,7 @@ import * as shipLand from '../scripts/gds/ship-land.js';
 
 const require = createRequire(import.meta.url);
 const { JARGON_TERMS } = require('../modules/sessions/accessibility.js');
-const { formatClaimFailure } = require('../scripts/gds/claim.js');
+const { formatClaimFailure, QUEUE_GATED_EXIT } = require('../scripts/gds/claim.js');
 const { formatGradeOutcome } = require('../scripts/gds/ship-grade-steps.js');
 
 let passed = 0;
@@ -130,7 +130,7 @@ test('a card interpolates nothing — it is static text, so it adds no injection
 test('a refused claim prints the engineer text first and the card after it', () => {
   const r = { status: 409, data: { error: { code: 'REBASE_REQUIRED', message: 'x', details: { rebaseTasks: [{ id: 7, reason: 'strand:pr_not_landed' }] } } } };
   const { lines, exit } = formatClaimFailure(r, 42);
-  assert.equal(exit, 1);
+  assert.equal(exit, QUEUE_GATED_EXIT, 'the queue-wide gate keeps its own exit code (task 1004396)');
   assert.match(lines[0], /queue is gated/);
   const at = lines.findIndex((l) => l.includes(PLAIN_MARKER));
   assert.ok(at > 0, 'card follows the existing guidance');