@bongos/core 1.21.72 → 1.21.74

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = 'af1c61ca87767b44';
+const SHELL_SHA = '02e600a176c32f6a';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/project_settings_page.mjs

@@ -63,8 +63,10 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
     resolveOptional: api.resolveOptional,
     list: gc.listCategories,
     set: api.projectSettings.set,
+    resolveShipMode: api.projectSettings.resolveShipMode,
   };
   api.resolveRotDays = async () => timer;
+  api.projectSettings.resolveShipMode = async () => ({ mode: 'auto', source: 'default', chosen: false, invalid: null });
   // reward: WORKING_REWARD (default) | null (port absent) | 'throws' (rewardConfig raises).
   const rewardPort = reward === 'throws'
     ? { rewardConfig: () => { throw new Error('reward boom'); } }
@@ -80,6 +82,7 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
     api.resolveOptional = saved.resolveOptional;
     gc.listCategories = saved.list;
     api.projectSettings.set = saved.set;
+    api.projectSettings.resolveShipMode = saved.resolveShipMode;
   };
   // The handler is the LAST layer on the matching route (requireBuilder and the
   // permission gate sit in front); calling it directly is what keeps this a unit test
@@ -99,22 +102,22 @@ const CATS = [
   { id: 2, slug: 'retired-thing', label: 'Retired thing', sort_order: 20, active: false },
 ];
 
-test('one read returns all five fundamentals, each naming where its value came from', async () => {
+test('one read returns all six fundamentals, each naming where its value came from', async () => {
   const { handlerFor, restore } = buildRouterWithStubs({ timer: TIMER_OK, categories: CATS });
   try {
     const res = fakeRes();
     await handlerFor('get', '/project-settings')({ query: {} }, res);
     const rows = res.payload.rows;
-    assert.equal(rows.length, 5, 'the page draws five rows, so the read returns five');
+    assert.equal(rows.length, 6, 'the page draws six rows, so the read returns six');
     assert.deepEqual(rows.map((r) => r.key),
-      ['rot_timer', 'work_categories', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
+      ['ship_mode', 'rot_timer', 'work_categories', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
     // Provenance is the point of the page: every row says where its value came from.
     for (const r of rows) {
       assert.ok(r.reads && r.reads.file, `${r.key} names no file`);
       assert.ok(r.sentence && r.sentence.length > 20, `${r.key} has no readable sentence`);
     }
-    // Exactly two knobs — the criterion's "change the two that are knobs".
-    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['rot_timer', 'work_categories']);
+    // Three knobs: the criterion's two, plus ship mode (task 1004628).
+    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['ship_mode', 'rot_timer', 'work_categories']);
     // A no-store receipt: a cached settings read is wrong the moment a knob turns.
     assert.equal(res.headers['Cache-Control'], 'no-store');
   } finally { restore(); }

package/tests/ship_mode.mjs

@@ -0,0 +1,171 @@
+// tests/ship_mode.mjs — the project's ship mode: who starts a ship (task 1004628, ADR 0369).
+//
+// Pinned here:
+//   1. the parser accepts exactly auto|manual (trimmed, any case) and explains a refusal;
+//   2. the resolver defaults to AUTO, tells "never chosen" apart from "chose auto",
+//      reports an unusable stored value instead of throwing, and survives a dead DB;
+//   3. the routes: any builder can READ it (the AI must know), the write validates
+//      through the same parser and echoes what the system will now read;
+//   4. the CLI verb is registered and its text names how to change the mode.
+//
+// Run:  node --test tests/ship_mode.mjs
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const poolMod = require(path.join(ROOT, 'src', 'bongos', 'pool.js'));
+// Destructured from a literal relative path, so the dead-code scan (knip) can see
+// these exports are used — a computed path.join() is invisible to it.
+const {
+  SHIP_MODES, DEFAULT_SHIP_MODE, parseShipMode, resolveShipMode, describeShipMode,
+} = require('../src/bongos/project-settings.js');
+const ps = { SHIP_MODES, DEFAULT_SHIP_MODE, parseShipMode, resolveShipMode, describeShipMode };
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+
+// Swap the pool's query for the duration of one call; project-settings reads
+// `pool.query` at call time, so this reaches the real SQL path.
+async function withPool(query, fn) {
+  const pool = poolMod.pool;
+  const saved = pool.query;
+  pool.query = query;
+  try { return await fn(); } finally { pool.query = saved; }
+}
+const rowWith = (value) => async () => ({ rows: value == null ? [] : [{ key: 'ship.mode', value, updated_at: null, updated_by: 1 }] });
+
+test('parseShipMode accepts exactly auto|manual, trimmed and in any case', () => {
+  assert.deepEqual([...ps.SHIP_MODES], ['auto', 'manual']);
+  assert.deepEqual(ps.parseShipMode('auto'), { mode: 'auto' });
+  assert.deepEqual(ps.parseShipMode(' Manual '), { mode: 'manual' });
+  assert.equal(ps.parseShipMode('').reason, 'empty');
+  assert.equal(ps.parseShipMode(null).reason, 'empty');
+  assert.match(ps.parseShipMode('yolo').reason, /auto \| manual/);
+});
+
+test('the default is auto, and an unset project reads as NOT chosen', async () => {
+  assert.equal(ps.DEFAULT_SHIP_MODE, 'auto');
+  const r = await withPool(rowWith(null), () => ps.resolveShipMode());
+  assert.deepEqual(r, { mode: 'auto', source: 'default', chosen: false, invalid: null });
+});
+
+test('a stored choice is read back as chosen — even when it equals the default', async () => {
+  const auto = await withPool(rowWith('auto'), () => ps.resolveShipMode());
+  assert.equal(auto.mode, 'auto');
+  assert.equal(auto.chosen, true, 'choosing auto is different from never choosing');
+  assert.equal(auto.source, 'project_settings');
+  const manual = await withPool(rowWith('manual'), () => ps.resolveShipMode());
+  assert.equal(manual.mode, 'manual');
+});
+
+test('an unusable stored value falls back to auto and is reported, not thrown', async () => {
+  const r = await withPool(rowWith('sometimes'), () => ps.resolveShipMode());
+  assert.equal(r.mode, 'auto');
+  assert.equal(r.chosen, false);
+  assert.equal(r.invalid.raw, 'sometimes');
+  assert.match(r.invalid.where, /ship\.mode/);
+});
+
+test('a database that cannot be read answers the default instead of failing a ship', async () => {
+  const r = await withPool(async () => { throw new Error('db down'); }, () => ps.resolveShipMode());
+  assert.deepEqual(r, { mode: 'auto', source: 'default', chosen: false, invalid: null });
+});
+
+test('describeShipMode says what each mode means in plain words', () => {
+  assert.match(ps.describeShipMode({ mode: 'auto', chosen: true }), /ships and lands it/);
+  assert.match(ps.describeShipMode({ mode: 'manual', chosen: true }), /waits for a person/);
+  assert.match(ps.describeShipMode({ mode: 'auto', chosen: false }), /nobody has chosen yet/);
+});
+
+// ---- the routes -------------------------------------------------------------
+
+const fakeRes = () => ({
+  code: null, statusCode: 200, payload: null, headers: {},
+  fail(code, opts) { this.code = code; this.statusCode = opts?.status ?? 400; this.payload = { error: code, ...(opts || {}) }; return this; },
+  status(c) { this.statusCode = c; return this; },
+  set(k, v) { this.headers[k] = v; return this; },
+  json(p) { this.payload = p; return this; },
+});
+
+function buildRouter({ resolved }) {
+  const saved = { resolve: api.projectSettings.resolveShipMode, set: api.projectSettings.set };
+  const writes = [];
+  let current = resolved;
+  api.projectSettings.resolveShipMode = async () => current;
+  api.projectSettings.set = async (key, value, by) => {
+    writes.push({ key, value, by });
+    current = { mode: value, source: 'project_settings', chosen: true, invalid: null };
+    return { key, value };
+  };
+  const file = path.join(ROOT, 'modules', 'lifecycle', 'routes', 'project-settings.js');
+  delete require.cache[require.resolve(file)];
+  const router = require(file)();
+  const route = (method, p) => router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]).route;
+  const restore = () => { api.projectSettings.resolveShipMode = saved.resolve; api.projectSettings.set = saved.set; };
+  return { route, writes, restore };
+}
+
+test('GET /project-settings/ship-mode is open to any signed-in builder, not gated Metic+', () => {
+  const { route, restore } = buildRouter({ resolved: { mode: 'auto', source: 'default', chosen: false, invalid: null } });
+  try {
+    const names = route('get', '/project-settings/ship-mode').stack.map((l) => l.name);
+    assert.equal(names.length, 2, 'requireBuilder + the handler, and no permission gate');
+    const write = route('patch', '/project-settings/ship-mode').stack;
+    assert.equal(write.length, 3, 'the write carries requireBuilder + the settings permission + the handler');
+  } finally { restore(); }
+});
+
+test('the read returns the mode, whether it was chosen, and the sentence to show', async () => {
+  const { route, restore } = buildRouter({ resolved: { mode: 'auto', source: 'default', chosen: false, invalid: null } });
+  try {
+    const res = fakeRes();
+    const stack = route('get', '/project-settings/ship-mode').stack;
+    await stack[stack.length - 1].handle({}, res);
+    assert.equal(res.payload.mode, 'auto');
+    assert.equal(res.payload.chosen, false);
+    assert.match(res.payload.sentence, /nobody has chosen yet/);
+    assert.deepEqual(res.payload.choices.map((c) => c.mode), ['auto', 'manual']);
+    assert.match(res.payload.choices[0].label, /recommended/i);
+    assert.equal(res.headers['Cache-Control'], 'no-store');
+  } finally { restore(); }
+});
+
+test('the write refuses an unknown mode and saves a good one, echoing what is now read', async () => {
+  const { route, writes, restore } = buildRouter({ resolved: { mode: 'auto', source: 'default', chosen: false, invalid: null } });
+  try {
+    const stack = route('patch', '/project-settings/ship-mode').stack;
+    const handle = stack[stack.length - 1].handle;
+
+    const bad = fakeRes();
+    await handle({ body: { mode: 'sometimes' }, builder: { id: 7 } }, bad);
+    assert.equal(bad.code, 'bad_ship_mode');
+    assert.equal(writes.length, 0, 'a refused mode writes nothing');
+
+    const good = fakeRes();
+    await handle({ body: { mode: 'Manual' }, builder: { id: 7 } }, good);
+    assert.equal(good.code, null);
+    assert.deepEqual(writes, [{ key: 'ship.mode', value: 'manual', by: 7 }]);
+    assert.equal(good.payload.mode, 'manual');
+    assert.equal(good.payload.chosen, true);
+  } finally { restore(); }
+});
+
+// ---- the CLI ----------------------------------------------------------------
+
+test('bongos ship-mode is a registered verb wired to shipping-mode.js', () => {
+  const cli = require(path.join(ROOT, 'bin', 'bongos.js'));
+  const def = cli.VERBS['ship-mode'];
+  assert.ok(def, 'bongos ship-mode must be a registered verb');
+  assert.equal(def.script, 'shipping-mode.js');
+});
+
+test('the CLI text names the mode and how to switch it', () => {
+  const { describe } = require(path.join(ROOT, 'scripts', 'gds', 'shipping-mode.js'));
+  const auto = describe({ mode: 'auto', chosen: false, sentence: 'Auto: …' });
+  assert.match(auto, /Ship mode: auto \(default — not chosen yet\)/);
+  assert.match(auto, /shipping-mode\.js manual/);
+  assert.match(describe({ mode: 'manual', chosen: true }), /shipping-mode\.js auto/);
+});