@bongos/core 1.21.83 → 1.21.85

package/tests/provision_settings_apply.mjs

@@ -78,6 +78,7 @@ ${NEUTRAL_PREFIX}_LOGO_URL=
 ${NEUTRAL_PREFIX}_FOUNDING_BIRTH=
 ${NEUTRAL_PREFIX}_DEMO_PEOPLE=
 ${NEUTRAL_PREFIX}_DEMO_HOURS=
+${NEUTRAL_PREFIX}_SHIP_MODE=
 ${NEUTRAL_PREFIX}_HUB_UPGRADE_URL=
 `;
 
@@ -148,6 +149,8 @@ t('settingsEnvVarsFor: the runner pushes the SAME pair webEnvBody writes at stan
     [`${NEUTRAL_PREFIX}_LOOK_ACCENT`]: '', [`${NEUTRAL_PREFIX}_LOGO_URL`]: '',
     // the birth marker and a demo's box (task 1004506), empty on an un-stamped row
     [`${NEUTRAL_PREFIX}_FOUNDING_BIRTH`]: '', [`${NEUTRAL_PREFIX}_DEMO_PEOPLE`]: '', [`${NEUTRAL_PREFIX}_DEMO_HOURS`]: '',
+    // the wizard's ship mode (task 1004629), empty when none was picked
+    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '',
     // where the hall's Update button goes (task 1004608), empty when no hub origin resolves
     [`${NEUTRAL_PREFIX}_HUB_UPGRADE_URL`]: '',
   });
@@ -250,7 +253,7 @@ await ta('dry-run PLANS the patch: reads nothing real, writes NOTHING (no synthe
   assert.equal(r.ok, true);
   assert.equal(r.healthy, null, 'nothing ran, nothing observed');
   assert.equal(writes.length, 0, 'a dry-run must not plan a two-line overwrite of web.env');
-  assert.ok(logs.some((l) => /would patch .*_PLATFORM_VISIBILITY, .*_JOINABILITY, .*_VISIBILITY, .*_JOIN_GRANT, .*_ARTIST_GATE, .*_SPEND_PAYER, .*_LOOK, .*_NIGHT_TINT, .*_ARTIST_GATE_SINCE, .*_LOOK_ACCENT, .*_LOGO_URL, .*_FOUNDING_BIRTH, .*_DEMO_PEOPLE, .*_DEMO_HOURS, .*_HUB_UPGRADE_URL in \/etc\/spike\/web\.env in place/.test(l)), logs.join('\n'));
+  assert.ok(logs.some((l) => /would patch .*_PLATFORM_VISIBILITY, .*_JOINABILITY, .*_VISIBILITY, .*_JOIN_GRANT, .*_ARTIST_GATE, .*_SPEND_PAYER, .*_LOOK, .*_NIGHT_TINT, .*_ARTIST_GATE_SINCE, .*_LOOK_ACCENT, .*_LOGO_URL, .*_FOUNDING_BIRTH, .*_DEMO_PEOPLE, .*_DEMO_HOURS, .*_SHIP_MODE, .*_HUB_UPGRADE_URL in \/etc\/spike\/web\.env in place/.test(l)), logs.join('\n'));
   assert.ok(cmds.some((c) => /restart spike/.test(c)), 'the restart is still in the plan');
   assert.ok(logs.some((l) => /dry-run — nothing ran/.test(l)), 'the closing line does not claim a restart happened');
 });

package/tests/provisioning_settings_env.mjs

@@ -127,6 +127,8 @@ t('settingsEnvVars is the single source both legs derive from — same keys, sam
     // The birth marker and a demo's box (task 1004506): empty on a row the create
     // route never stamped, which is every row made before it shipped (spec D8).
     CLOUDBONGOS_FOUNDING_BIRTH: '', CLOUDBONGOS_DEMO_PEOPLE: '', CLOUDBONGOS_DEMO_HOURS: '',
+    // The wizard's ship mode (task 1004629): empty when none was picked.
+    CLOUDBONGOS_SHIP_MODE: '',
   });
   // varsOf splits on '=', so an empty value reads as '' on both sides — the point
   // of the comparison is that the standup lines carry exactly the same key set.
@@ -135,7 +137,7 @@ t('settingsEnvVars is the single source both legs derive from — same keys, sam
     X_PLATFORM_VISIBILITY: 'public', X_JOINABILITY: 'apply', X_VISIBILITY: 'public', X_JOIN_GRANT: 'full',
     X_ARTIST_GATE: 'strict', X_ARTIST_GATE_SINCE: '', X_SPEND_PAYER: 'none',
     X_LOOK: 'own', X_NIGHT_TINT: 'on', X_LOOK_ACCENT: '', X_LOGO_URL: '',
-    X_FOUNDING_BIRTH: '', X_DEMO_PEOPLE: '', X_DEMO_HOURS: '',
+    X_FOUNDING_BIRTH: '', X_DEMO_PEOPLE: '', X_DEMO_HOURS: '', X_SHIP_MODE: '',
   }, 'defaults, explicitly');
 });
 

package/tests/wizard_physics_more.mjs

@@ -377,13 +377,13 @@ test('rewards are hidden for a solo founder: the real table hides the row, and t
   assert.equal(w.run("rowApplies('rewards')"), false, 'the REAL softLimitsFor hides reward_intents for one-and-one');
   assert.equal(w.row('rewards').hidden, true, 'and the row goes with it');
   assert.ok(!w.run('unconfirmedRows()').includes('rewards'), 'nothing to confirm for a question never asked');
-  assert.equal(w.run('unconfirmedRows()').length, 6, 'six rows apply');
+  assert.equal(w.run('unconfirmedRows()').length, 7, 'seven rows apply');
   assert.equal(w.run('createDetail()').reward_intents, undefined);
   w.change('team');
   w.q('[data-phys-solo="many"]')[0].click();
   await w.settle();
   assert.equal(w.row('rewards').hidden, false, 'a team brings the question back, once the table is asked again');
-  assert.equal(w.run('unconfirmedRows()').length, 7);
+  assert.equal(w.run('unconfirmedRows()').length, 8);
 });
 
 test('rewards: a greyed option is disabled and leaves the list, and each reason is said once', async () => {
@@ -482,9 +482,9 @@ test('one "Looks right, continue" confirms every row that applies, each through
   assert.equal(w.go().disabled, false, 'Continue is never locked: it is the confirmation');
   assert.equal(w.go().textContent, 'Looks right, continue');
   assert.equal(w.row('code').querySelector('[data-row-ok]'), null, 'no row carries a Looks right of its own');
-  assert.equal(w.run('unconfirmedRows()').length, 7, 'nothing is confirmed before the founder says so');
+  assert.equal(w.run('unconfirmedRows()').length, 8, 'nothing is confirmed before the founder says so');
   assert.equal(w.run('validateStep(4)'), true, 'one Continue confirms them all');
-  for (const key of ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run']) assert.equal(w.state.confirmed[key], true, key);
+  for (const key of ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run', 'ship']) assert.equal(w.state.confirmed[key], true, key);
   assert.equal(w.state.modules && plain(w.state.modules).join(), 'discord', 'confirming the extras is the answer the create sends');
   w.change('team');
   assert.equal(w.state.confirmed.team, undefined, 'Edit takes a row back');
@@ -629,7 +629,7 @@ test('no path reaches Look without the founder confirming the address: a prefill
     assert.equal(w.state.confirmed.address, undefined, `${label}: the prefills leave the address unconfirmed`);
     assert.equal(w.run("rowFixed('address')"), false, `${label}: the address is never a fixed row`);
     assert.equal(w.row('address').querySelector('[data-row-chg]').hidden, false, `${label}: it can always be changed`);
-    for (const key of ['code', 'app', 'extras', 'team', 'rewards', 'run']) if (w.run(`rowApplies('${key}')`)) w.ok(key);
+    for (const key of ['code', 'app', 'extras', 'team', 'rewards', 'run', 'ship']) if (w.run(`rowApplies('${key}')`)) w.ok(key);
     assert.deepEqual(plain(w.run('unconfirmedRows()')), ['address'], `${label}: every other row confirmed, the address still asked`);
     // the address is on the page the founder confirms (task 1004550): only their own
     // "Looks right, continue" — or Done on the row — confirms it, and its check still runs

package/tests/wizard_ship_mode.mjs

@@ -0,0 +1,187 @@
+// tests/wizard_ship_mode.mjs — the project-creation wizard asks how finished work ships,
+// and the new project is born with that answer (task 1004629, ADR 0369).
+//
+// Pinned here, end to end:
+//   1. the wizard's review has a Shipping row: Auto first and checked, one plain sentence
+//      each, "you can change it later", and the create request carries ship_mode;
+//   2. the create route accepts only auto|manual and stamps it, write-once, on the row it
+//      just made (modules/provisioning/birth.js);
+//   3. the stamp rides the new instance's web.env as <PREFIX>_SHIP_MODE, which
+//      src/branding.js maps onto the server-only founding.shipMode;
+//   4. the instance's resolveShipMode reads it as a CHOSEN mode while no project_settings
+//      row exists, and a row (the settings page, the CLI) always wins.
+//
+// Run:  node --test tests/wizard_ship_mode.mjs
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HUB = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+
+// Destructured from literal relative paths, so the dead-code scan (knip) can trace them.
+const { SHIP_MODE_KEY, stampShipMode, BIRTH_COMPANION_ENV } = require('../modules/provisioning/birth.js');
+const { resolveShipMode } = require('../src/bongos/project-settings.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+const poolMod = require('../src/bongos/pool.js');
+
+function slice(start, end, what) {
+  const a = HUB.indexOf(start), b = HUB.indexOf(end, a);
+  assert.ok(a > 0 && b > a, `slice for ${what} not found — a rename moved it`);
+  return HUB.slice(a, b);
+}
+
+// ── 1. the wizard ──────────────────────────────────────────────────────────
+
+test('the review asks how finished work ships: Auto (recommended) first and checked, Manual second', () => {
+  const row = slice('<div class="setRow" data-row="ship">', '<div class="hint" id="h-review">', 'the ship row');
+  const auto = row.indexOf('value="auto"'), manual = row.indexOf('value="manual"');
+  assert.ok(auto > 0 && manual > auto, 'Auto comes first');
+  assert.match(row, /<input type="radio" name="shipMode" value="auto" checked>/, 'and is the pick until the founder says otherwise');
+  assert.match(row, /<b>Auto \(recommended\)<\/b>/);
+  assert.match(row, /<b>Manual<\/b>/);
+  assert.match(row, /ships finished work on its own/, 'one plain sentence for Auto');
+  assert.match(row, /waits for you to approve it/, 'and one for Manual');
+});
+
+test('the row says what was picked and that it can be changed later; an older draft reads Auto', () => {
+  const fns = slice('    /* the ship row (task 1004629)', '    var ROWS = [', 'the ship choice');
+  const ctx = { state: {} };
+  vm.runInNewContext(`${fns}; this.choice = shipModeChoice;`, ctx);
+  assert.equal(ctx.choice(), 'auto', 'a draft with no shipMode is Auto');
+  ctx.state.shipMode = 'manual';
+  assert.equal(ctx.choice(), 'manual');
+  ctx.state.shipMode = 'yolo';
+  assert.equal(ctx.choice(), 'auto', 'anything but manual is Auto');
+  const say = slice("      if (key === 'ship') {", "      return { v: '', s: '' };", "the ship row's words");
+  assert.match(say, /v: 'Auto \(recommended\)'/);
+  assert.match(say, /v: 'Manual'/);
+  assert.equal((say.match(/You can change this later in your project’s settings\./g) || []).length, 2, 'both say it can be changed later');
+});
+
+test('the draft remembers the pick, and Create sends it as ship_mode', () => {
+  assert.match(HUB, /appPlatform: 'later', shipMode: 'auto', physics: null/, 'the initial state starts on Auto');
+  assert.equal((HUB.match(/shipMode: 'auto'/g) || []).length, 2, 'and so does the reset (the two literals stay equal)');
+  assert.match(HUB, /if \(type === 'change' && ev\.target\.name === 'shipMode'\) \{ state\.shipMode = ev\.target\.value; saveDraft\(\); \}/);
+  assert.match(HUB, /ship_mode: shipModeChoice\(\)\n {10}\}\)/, 'the create request carries it');
+});
+
+// ── 2. the stamp ───────────────────────────────────────────────────────────
+
+test('stampShipMode writes a valid answer once, and writes nothing for none or junk', async () => {
+  const seen = [];
+  const db = { query: async (sql, params) => { seen.push({ sql, params }); return { rows: [] }; } };
+  assert.equal(await stampShipMode(db, 41, 'manual'), true);
+  assert.equal(seen.length, 1);
+  assert.match(seen[0].sql, /UPDATE provisioning_instances/);
+  assert.match(seen[0].sql, /WHERE id = \$1 AND NOT \(COALESCE\(settings, '\{\}'::jsonb\) \? \$2::text\)/, 'write-once');
+  assert.deepEqual(seen[0].params, [41, SHIP_MODE_KEY, 'manual']);
+  assert.equal(await stampShipMode(db, 41, undefined), false, 'no answer: the project asks at its first ship instead');
+  assert.equal(await stampShipMode(db, 41, 'yolo'), false);
+  assert.equal(seen.length, 1, 'nothing written for either');
+});
+
+test('the stamp is not a setting: no client patch can write it and it never projects as one', () => {
+  assert.ok(!(SHIP_MODE_KEY in provisioning.SETTINGS_VOCAB));
+  assert.ok(!(SHIP_MODE_KEY in provisioning.PLANET_VOCAB));
+  assert.ok(!(SHIP_MODE_KEY in provisioning.effectiveSettings({ settings: { [SHIP_MODE_KEY]: 'manual' } })));
+});
+
+// ── 3. the transport ───────────────────────────────────────────────────────
+
+test('the stamped mode rides web.env as SHIP_MODE; an unstamped or mangled row sends empty', () => {
+  assert.equal(typeof BIRTH_COMPANION_ENV.SHIP_MODE, 'function');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'manual' } }, 'X').X_SHIP_MODE, 'manual');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'auto' } }, 'X').X_SHIP_MODE, 'auto');
+  assert.equal(provisioning.settingsEnvVars({ settings: {} }, 'X').X_SHIP_MODE, '');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'sometimes' } }, 'X').X_SHIP_MODE, '');
+});
+
+test('the instance reads it into founding.shipMode, and never publishes it to the client', () => {
+  const read = (env) => JSON.parse(execFileSync(process.execPath, ['-e',
+    "const b=require('./src/branding.js');const r=(b.branding||b)();console.log(JSON.stringify({m:(r.founding||{}).shipMode||null,c:'founding' in b.clientBranding(r)}))"],
+    { cwd: ROOT, encoding: 'utf8', env: { ...process.env, ...env } }));
+  assert.deepEqual(read({ CLOUDBONGOS_SHIP_MODE: 'manual' }), { m: 'manual', c: false });
+  assert.deepEqual(read({ CLOUDBONGOS_SHIP_MODE: '' }), { m: null, c: false }, 'the empty line every other instance carries is nothing');
+});
+
+// ── 4. the instance's own resolver ─────────────────────────────────────────
+
+async function withRow(value, fn) {
+  const pool = poolMod.pool;
+  const saved = pool.query;
+  pool.query = async () => ({ rows: value == null ? [] : [{ key: 'ship.mode', value, updated_at: null, updated_by: 1 }] });
+  try { return await fn(); } finally { pool.query = saved; }
+}
+const packWith = (shipMode) => () => ({ founding: { shipMode } });
+
+test('a wizard pick counts as chosen while no setting row exists', async () => {
+  const r = await withRow(null, () => resolveShipMode({ branding: packWith('manual') }));
+  assert.deepEqual(r, { mode: 'manual', source: 'wizard', chosen: true, invalid: null });
+  const auto = await withRow(null, () => resolveShipMode({ branding: packWith('auto') }));
+  assert.equal(auto.chosen, true, 'picking Auto in the wizard is a choice, so the first ship does not ask again');
+});
+
+test('the settings page (a row) always wins over the wizard; junk or no pick is the default, unchosen', async () => {
+  const r = await withRow('auto', () => resolveShipMode({ branding: packWith('manual') }));
+  assert.equal(r.mode, 'auto');
+  assert.equal(r.source, 'project_settings');
+  assert.deepEqual(await withRow(null, () => resolveShipMode({ branding: packWith('') })), { mode: 'auto', source: 'default', chosen: false, invalid: null });
+  assert.deepEqual(await withRow(null, () => resolveShipMode({ branding: packWith('maybe') })), { mode: 'auto', source: 'default', chosen: false, invalid: null });
+  assert.equal((await withRow(null, () => resolveShipMode({ branding: () => { throw new Error('no pack'); } }))).source, 'default', 'a pack that cannot be read is no pick');
+});
+
+// ── 2b. the create route ───────────────────────────────────────────────────
+
+const api = require('../src/module-api.js');
+const birth = require('../modules/provisioning/birth.js');
+provisioning.getInstanceBySlug = async () => null;
+provisioning.getInstanceByDomain = async () => null;
+birth.stampBirth = async () => {};
+provisioning.createInstance = async (_db, args) => ({
+  instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: 'requested', hosting_shape: 'byo-host', detail: {} }, created: true,
+});
+provisioning.enqueueIntent = async (_db, _id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
+provisioning.getOpenIntent = async () => null;
+provisioning.recordEvent = async () => {};
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+const stamped = [];
+api.pool.query = async (sql, params) => { if (/jsonb_build_object/.test(sql) && params[1] === SHIP_MODE_KEY) stamped.push(params[2]); return { rows: [] }; };
+
+const express = require('express');
+const app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.fail = (code, opts) => {
+    const status = typeof opts === 'number' ? opts : (opts && opts.status) || 400;
+    res.status(status).json({ error: { code, message: opts && opts.message } });
+  };
+  next();
+});
+app.use('/api/bongos', require('../modules/provisioning/routes/provisioning.js')());
+const server = app.listen(0);
+after(() => server.close());
+async function create(body) {
+  await new Promise((r) => (server.listening ? r() : server.once('listening', r)));
+  const res = await fetch(`http://127.0.0.1:${server.address().port}/api/bongos/provisioning/instances`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+test('the create route stamps the pick on the new row, and refuses anything but auto|manual', async () => {
+  stamped.length = 0;
+  const r = await create({ slug: 'ships-by-hand', hosting_shape: 'byo-host', ship_mode: 'manual' });
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(stamped, ['manual']);
+  stamped.length = 0;
+  assert.equal((await create({ slug: 'no-pick', hosting_shape: 'byo-host' })).status, 201, 'the answer is optional (an API caller)');
+  assert.deepEqual(stamped, [], 'and none is stamped when none is given');
+  assert.equal((await create({ slug: 'bad-pick', hosting_shape: 'byo-host', ship_mode: 'sometimes' })).status, 400);
+});

package/tests/wizard_six_screens.mjs

@@ -81,10 +81,10 @@ test('planet words survive only as the light touch: the fork and the alive momen
   assert.match(SCRIPT, /if \(inst\.last_verified_up\) \{\n\s*\/\*[^*]*\*\/\n\s*\$\('done-h'\)\.textContent =/, 'said only once the project has answered (Live is a verified claim)');
 });
 
-test('the review cannot be skipped: seven rows, one Edit each, and one Continue that confirms them all (task 1004550)', () => {
+test('the review cannot be skipped: eight rows, one Edit each, and one Continue that confirms them all (task 1004550)', () => {
   const p = panel('panel-review');
   const rows = [...p.matchAll(/<div class="setRow" data-row="([a-z]+)">/g)].map((m) => m[1]);
-  assert.deepEqual(rows, ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run']);
+  assert.deepEqual(rows, ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run', 'ship']);
   for (const key of rows) {
     const r = (p.match(new RegExp(`<div class="setRow" data-row="${key}">[\\s\\S]*?<span class="acts">[^\\n]*\\n`)) || [''])[0];
     assert.match(r, /<span class="acts"><button type="button" class="rowChg" data-row-chg aria-expanded="false">Edit<\/button><\/span>/, `${key}: one Edit, nothing else`);
@@ -110,6 +110,7 @@ test('nothing the old steps could do is lost: their controls are moved whole int
   has('extras', ['modQ', 'modCards', 'modWhy', 'modCoreNote']);
   has('team', ['physTeam', 'physStartN', 'physExpected', 'teamCards']);
   has('run', ['physSuite']);
+  has('ship', ['shipOpts']);
   for (const id of ['physCountry', 'physRegion', 'physAges', 'physIntent', 'physForms', 'physHaveEntity', 'checksStop', 'physStopMsg', 'physFromAccount']) {
     assert.match(panel('panel-checks'), new RegExp(`id="${id}"`), `the quick checks host #${id}`);
   }