@bongos/core 1.19.1012 → 1.19.1014

package/tests/fleet_cost_view.mjs

@@ -0,0 +1,189 @@
+// tests/fleet_cost_view.mjs — Cost view v1 (task 1001949, ADR 0327): the fleet cost page
+// for the platform owner, and the one estimate line on a cloud-host owner's project page.
+//
+// The rule every case below leans on: an UNPRICED cost (null) renders as unpriced and never
+// as $0, and never moves a total. A $0 there would be a price nobody quoted.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import http from 'node:http';
+import vm from 'node:vm';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (p) => readFileSync(p, 'utf8').replace(/\r\n/g, '\n');
+const costs = require(path.join(HALL, 'fleet-costs.js'));
+const FIXTURE = JSON.parse(read(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'provisioning__fleet__cost-ledger.json')));
+
+// ── the fleet page's builders ────────────────────────────────────────────────
+const row = (over) => ({ id: '1', slug: 'p', owner: 'o', hosting_shape: 'cloud-host', tier: null, status: 'active', platform_monthly_usd: 0, owner_monthly_usd: null, ...over });
+const cells = (html) => [...html.matchAll(/<td[^>]*>([\s\S]*?)<\/td>/g)].map((m) => m[1].replace(/<[^>]+>/g, '').trim());
+const foot = (html) => html.slice(html.indexOf('<tfoot>'));
+
+test('money: whole dollars stay whole, cents show two places, and an unpriced value has no price', () => {
+  assert.equal(costs.money(13), '$13');
+  assert.equal(costs.money(12.5), '$12.50');
+  assert.equal(costs.money(0), '$0');
+  assert.equal(costs.money(null), null);
+  assert.equal(costs.money(undefined), null);
+});
+
+test('an unpriced row reads "not priced yet", never $0 — and a real $0 still reads $0', () => {
+  const html = costs.ledgerHtml({
+    instances: [row({ slug: 'a', platform_monthly_usd: 0, owner_monthly_usd: null })],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 1 } },
+  });
+  const [, , , , us, owner] = cells(html.slice(0, html.indexOf('<tfoot>')));
+  assert.equal(us, '$0', 'a cloud-host costs us a real, measured $0');
+  assert.equal(owner, 'not priced yet');
+});
+
+test('a total sums only priced rows and names how many it left out', () => {
+  const html = costs.ledgerHtml({
+    instances: [
+      row({ slug: 'cp', hosting_shape: 'control-plane', tier: 's-1vcpu-2gb', platform_monthly_usd: 12, owner_monthly_usd: 0 }),
+      row({ slug: 'priced', tier: 'starter+basic-256mb', owner_monthly_usd: 13 }),
+      row({ slug: 'bare', owner_monthly_usd: null }),
+    ],
+    totals: { platform: { monthly_usd: 12, unpriced: 0 }, owner: { monthly_usd: 13, unpriced: 1 } },
+  });
+  const [us, owner] = cells(foot(html));
+  assert.equal(us, '$12');
+  assert.equal(owner, '$13 + 1 not priced', 'the null row is counted, not summed');
+});
+
+test('a column with NOTHING priced has no total — the sum of no prices is not $0', () => {
+  const html = costs.ledgerHtml({
+    instances: [row({ slug: 'a' }), row({ slug: 'b' })],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 2 } },
+  });
+  const [us, owner] = cells(foot(html));
+  assert.equal(us, '$0', 'every row prices at a real $0 for us');
+  assert.equal(owner, 'not priced yet', 'the owner total is not printed as $0');
+});
+
+test('the harness fixture reads as live does today: our box priced, every owner bill but ours unpriced', () => {
+  const [us, owner] = cells(foot(costs.ledgerHtml(FIXTURE)));
+  assert.equal(us, '$12');
+  assert.equal(owner, '$0 + 2 not priced, 1 not visible');
+});
+
+test('the total says what its cells say: a self-hosted bill is "not visible", not "not priced"', () => {
+  const byo = (slug) => row({ slug, hosting_shape: 'byo-host' });
+  const mixed = costs.ledgerHtml({
+    instances: [row({ slug: 'p', tier: 'starter+basic-256mb', owner_monthly_usd: 13 }), byo('a'), byo('b')],
+    totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 13, unpriced: 2 } },
+  });
+  assert.equal(cells(foot(mixed))[1], '$13 + 2 not visible');
+  const allByo = costs.ledgerHtml({ instances: [byo('a'), byo('b')], totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 2 } } });
+  assert.equal(cells(foot(allByo))[1], 'not visible to us');
+});
+
+test('a self-hosted owner\'s bill is not ours to see — a different absence from an unrecorded plan', () => {
+  const html = costs.ledgerHtml({ instances: [row({ hosting_shape: 'byo-host' })], totals: { platform: { monthly_usd: 0, unpriced: 0 }, owner: { monthly_usd: 0, unpriced: 1 } } });
+  assert.equal(cells(html)[5], 'not visible to us');
+  assert.equal(cells(html)[2], 'Self-hosted');
+});
+
+test('every row of the fixture is listed, a missing plan says so, and row text is escaped', () => {
+  const html = costs.ledgerHtml(FIXTURE);
+  for (const r of FIXTURE.instances) assert.ok(html.includes(`>${r.slug}<`), `${r.slug} is a row`);
+  assert.match(html, /none recorded/);
+  const hostile = costs.ledgerHtml({ instances: [row({ slug: '<img src=x onerror=1>', owner: '"q"' })], totals: {} });
+  assert.doesNotMatch(hostile, /<img/);
+  assert.match(hostile, /&lt;img src=x onerror=1&gt;/);
+});
+
+test('no projects renders a sentence, not an empty table', () => {
+  assert.match(costs.ledgerHtml({ instances: [], totals: {} }), /No projects are hosted here yet/);
+  assert.match(costs.ledgerHtml(null), /No projects are hosted here yet/);
+});
+
+// ── the page: its wiring and its gate ────────────────────────────────────────
+test('the page loads the builders before its chrome and reads the ledger route', () => {
+  const html = read(path.join(HALL, 'fleet.html'));
+  assert.ok(html.indexOf('fleet-costs.js') !== -1 && html.indexOf('fleet-costs.js') < html.indexOf('/fleet.js'), 'fleet-costs.js loads first');
+  const js = read(path.join(HALL, 'fleet.js'));
+  assert.match(js, /\/provisioning\/fleet\/cost-ledger/);
+  assert.match(js, /status === 403[\s\S]{0,200}fl-sealed/, 'a refusal shows the sealed state');
+});
+
+test('the page gate is the atom the ledger route checks, and the nav mirrors its floor', () => {
+  const route = read(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'));
+  assert.match(route, /router\.get\('\/provisioning\/fleet\/cost-ledger', auth\.requireBuilder, auth\.requirePermission\('provisioning\.fleet\.manage'\)/);
+  assert.match(read(path.join(ROOT, 'src', 'bongos', 'auth.js')), /requireFleetPage: Object\.freeze\(\{ permission: 'provisioning\.fleet\.manage'/);
+  // The nav is cosmetic (the page gate is the wall); 'government' is the metic floor.
+  const { byKey } = require(path.join(ROOT, 'modules', 'government', 'catalog.js'));
+  assert.equal(byKey('provisioning.fleet.manage').floor, 'metic');
+  assert.match(read(path.join(HALL, 'shell.js')), /href: '\/fleet', gate: 'government', module: 'provisioning'/);
+});
+
+// ── the owner's line on their own project page ───────────────────────────────
+const HUB = read(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'));
+function hubFn(name) {
+  const start = HUB.indexOf(`function ${name}(`);
+  assert.ok(start !== -1, `${name} is defined in projects.html`);
+  const end = HUB.indexOf('\n  function ', start + 1);
+  const box = {};
+  vm.runInNewContext(`${HUB.slice(start, end)}\nbox.fn = ${name};`, { box });
+  return box.fn;
+}
+
+test('the owner\'s hosting-bill line: a price when the plan is known, "not priced yet" when not', () => {
+  const hostingBill = hubFn('hostingBill');
+  assert.equal(hostingBill(null), 'not priced yet');
+  assert.equal(hostingBill(undefined), 'not priced yet');
+  assert.equal(hostingBill(13), '$13/month, estimated. Render bills you directly.');
+  assert.equal(hostingBill(12.5), '$12.50/month, estimated. Render bills you directly.');
+});
+
+test('the line is shown only on a live cloud-host — a self-hosted owner\'s bill is theirs', () => {
+  const body = HUB.slice(HUB.indexOf('function renderManage('), HUB.indexOf("$('mMeta').innerHTML", HUB.indexOf('function renderManage(')));
+  assert.match(body, /if \(inst\.hosting_shape === 'cloud-host' && inst\.status !== 'torn_down'\) rows\.push\(\['hosting bill', hostingBill\(inst\.owner_monthly_usd\)\]\);/);
+});
+
+// ── the payload the owner's page reads ───────────────────────────────────────
+const provisioning = require(path.join(ROOT, 'modules', 'provisioning', 'provisioning.js'));
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+let detailRow = null;
+provisioning.getInstanceById = async () => detailRow;
+provisioning.getOpenIntent = async () => null;
+provisioning.getLatestOAuthManifestForInstance = async () => null;
+require(path.join(ROOT, 'modules', 'provisioning', 'catalog-bridge.js')).healInstanceCatalog = async () => {};
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+const express = require('express');
+const app = express();
+app.use((_req, res, next) => {
+  res.fail = (code, opts) => res.status(typeof opts === 'number' ? opts : (opts && opts.status) || 400).json({ error: { code } });
+  next();
+});
+app.use('/api/bongos', require(path.join(ROOT, 'modules', 'provisioning', 'routes', 'provisioning.js'))());
+const getJson = (url) => new Promise((resolve, reject) => {
+  http.get(url, (res) => { let d = ''; res.on('data', (c) => { d += c; }); res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(d || 'null') })); }).on('error', reject);
+});
+
+test('GET /provisioning/instances/:id carries the owner\'s estimate — null until a plan is recorded', async () => {
+  const server = app.listen(0);
+  await new Promise((r) => server.once('listening', r));
+  const url = `http://127.0.0.1:${server.address().port}/api/bongos/provisioning/instances/41`;
+  const base = { id: 41, owner_builder_id: 7, slug: 'p', status: 'active', hosting_shape: 'cloud-host', description: 'd' };
+  try {
+    detailRow = { ...base, tier: null };
+    let r = await getJson(url);
+    assert.equal(r.status, 200);
+    assert.ok('owner_monthly_usd' in r.body.instance, 'the field is present');
+    assert.equal(r.body.instance.owner_monthly_usd, null, 'no plan: unpriced, not 0');
+    detailRow = { ...base, tier: 'starter+basic-256mb' };
+    r = await getJson(url);
+    assert.equal(r.body.instance.owner_monthly_usd, 13, 'the ledger\'s own price for the named plan');
+    detailRow = { ...base, owner_builder_id: 8, tier: 'starter+basic-256mb' };
+    r = await getJson(url);
+    assert.equal(r.status, 404, 'another builder\'s project answers nothing');
+  } finally {
+    server.close();
+  }
+});

package/tests/hall_audit.mjs

@@ -354,9 +354,22 @@ test('the module doc still records where the 2179 density pass landed', () => {
 // no shell.js, a private hardcoded palette that silently kept the WCAG-failing
 // accent when the pack moved (idea 1000600). Task 1002868 adopted them, so the
 // rule is now universal and exception-free.
+// THE SKY is the one page that is not the hall's chrome, by the owner's decision
+// (task 1004231, ADR 0331): modules/hall-ui/public/thinking.html is the
+// prototype adopted as the design of record — a full-screen black surface with
+// its own header, composer and legend — and its <style> is the pixel contract.
+// It is not the fork this rule was written against: its palette is not a stale
+// private copy of the hall's, it is a different surface's own, pinned by
+// tests/hall_sky.mjs against the template. It still stamps the branding token
+// and the pack's font links like every hall page (the server injects them).
+const STANDALONE_EXEMPT = {
+  'thinking.html': 'the sky (task 1004231, ADR 0331) — the design of record is its own surface, not the hall chrome',
+};
+
 test('every hall page loads style.css and shell.js', () => {
   const missing = [];
   for (const f of pages()) {
+    if (STANDALONE_EXEMPT[f]) continue;
     const html = read(f);
     if (!/<link[^>]+href="[^"]*\bstyle\.css[^"]*"/.test(html)) missing.push(`${f}: no style.css link`);
     if (!/<script[^>]+src="[^"]*\bshell\.js[^"]*"/.test(html)) missing.push(`${f}: no shell.js`);
@@ -400,6 +413,15 @@ test('no page declares a private copy of a pack color var', () => {
 const LITERAL_EXEMPT = {
   'style.css': 'the token tier — this is the ONE file whose job is to hold the literals',
   'settings.css': 'the Discord button wears Discord\'s brand colour (#5865F2); a third-party mark is not a theme colour',
+  // The sky (task 1004231, ADR 0331) is the prototype the owner adopted as the
+  // design of record, verbatim: its sheet IS its token tier (a black void, one
+  // accent, the chart yellow, and the alpha-white ladder the canvas shares),
+  // and the two scripts that write inline colour do so with the template's own
+  // values. The atlas precedent: a page-scoped palette, pinned rather than
+  // re-tokened.
+  'thinking.css': 'the sky\'s own sheet is its token tier (task 1004231, ADR 0331 — the design of record)',
+  'sky-interaction.js': 'the sky\'s hover card writes the template\'s ring colour inline (task 1004231)',
+  'sky-panel.js': 'the sky\'s panel writes the template\'s dead-bar colour inline (task 1004231)',
 };
 const COLOUR_PROPS = 'color|background|background-color|border|border-color|border-top-color|border-bottom-color|fill|stroke|outline|outline-color|box-shadow|text-shadow';
 const colourLiteralRe = () =>
@@ -465,6 +487,11 @@ test('the verdict classes and the scrim exist in the token tier, in both modes',
 // exceptions are selectors that are not keyboard stops at all.
 const OUTLINE_NONE_EXEMPT = {
   main: 'the skip link\'s programmatic target — main takes tabindex="-1" focus so the reader lands past the nav, and ringing the whole page would be noise, not information',
+  // The sky's composer (task 1004231, ADR 0331): the line sits inside a pill
+  // form, and the indication is the FORM's ring — `.composer form:focus-within`
+  // brightens its inset hairline — which is the template's own design. A ring
+  // on the input inside the pill would draw two.
+  '.composer input': 'the sky\'s composer line — the indication is the pill form\'s focus-within ring (thinking.css), the template\'s own',
 };
 
 // Innermost rule blocks only, so a rule inside @media is read as itself and the

package/tests/hall_nav.mjs

@@ -287,7 +287,9 @@ test('sidebar groups read by audience, in order', () => {
   // 'deploy' (task 1003159, ADR 0293) is the SECOND archon item, beside 'government':
   // its gate is the `core.pin.move` atom, archon-floor and system:true. It sits with
   // the steering surfaces because that is what it is — the owner's third release gate.
-  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'gate', 'sessions', 'project-settings', 'deploy', 'government']);
+  // 'fleet' (task 1001949) follows it at the metic floor of `provisioning.fleet.manage`:
+  // what each hosted project costs is an operator surface, like the rest of this group.
+  assert.deepEqual(nav[4].items.map((i) => i.id), ['watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'government']);
 });
 
 test('Economy lives in Docs and points at the reward-schedule page', () => {

package/tests/hall_page_gate_map.mjs

@@ -68,12 +68,15 @@ const ORACLE = {
   // having a thought, and the page reads the VIEWER's own trail (the id comes
   // from GET /me, never from the URL), so a rank could protect nothing the
   // session does not already.
+  // Since task 1004231 (sky part 3, ADR 0331) that page IS the sky — the
+  // prototype the owner adopted, over GET /sky + GET /sky/mine, with the room
+  // inside it as the list drawer. Both reads are any-builder and the trail is
+  // the viewer's own, so sign-in is still the whole gate.
   '/builders/thinking': 'requireBuilderPage',
-  // THE SKY (task 1004105 / BV2.R26) — the ambient view over the SAME trail the
-  // room lists, drawn as a map. It reads the same endpoint with the same
-  // viewer-derived id, so it sits on the same tier: a rank floor here would
-  // protect on one page exactly what it admits on the other.
-  '/builders/sky': 'requireBuilderPage',
+  // Gone: the old ambient sky (task 1004105) was folded into /thinking by task
+  // 1004231, and /builders/sky now 301s there (serve-internal.js). A redirect is
+  // not a page, so it carries no gate; GONE_PAGES keeps the row honest.
+  '/builders/sky': null,
   '/builders/collab': 'requireBuilderPage',
   // task 1002710: the orientation reading rooms moved DOWN to this tier from a
   // thetes+ gate. They are the onboarding documents, so gating them above xenos
@@ -100,6 +103,8 @@ const ORACLE = {
   // its write on purpose: the preview discloses the exact core version the box serves
   // and how far behind it is, which is a vulnerability window.
   '/builders/deploy': 'requireCorePinPage',
+  // The fleet cost page (task 1001949), on the atom its one read checks.
+  '/builders/fleet': 'requireFleetPage',
 
   // Metic+ via the `project.curate` atom — the exact permission GET /scouting
   // checks, so the page can never drift wider than the API it fronts. Its
@@ -301,6 +306,9 @@ const GONE_PAGES = {
   // Task 1003890 — the dev-box deprecation removed the fleet these two drove.
   '/builders/harbor': 'task 1003890 — the dev box is gone, so its Archon view is too',
   '/builders/pair': 'task 1003890 — the dev box is gone, so its pairing page is too',
+  // Task 1004231 — the ideator's sky replaced both the room and the old sky with
+  // one page at /thinking; /sky is a 301 to it, not a page.
+  '/builders/sky': 'task 1004231 — the sky lives at /thinking now; /sky redirects there',
 };
 
 test('a row that is null because the page left the hall serves no page', () => {