Rebased onto aca16404c. Item 8 (scripts/stack-release.sh): a re-pin drops
--board for a target cli.mjs that does not parse it (parses_flag ignores
refusal lines); the plan names the drop. The rollback-install conflict
(webui-service.sh has no --board branch) is open for Sage's ruling and
recorded in BUILD.md.
Killers: retired.test.mjs (M1, M2, M9), board.test.mjs (M15),
board-inprocess.test.mjs (M3, M5, M6, M7, M10, M14), pinned-copy M11,
stack-release M12/M13. M14 is a known gap, recorded in BUILD.md.
B4: stale-pid case ported to createBoard via isPidAlive; bad-JSON moved to
send.test.mjs; page.html and tester board-proxy tests dropped (reasons in
BUILD.md). B5: non-numeric --port test removed.
Docs: webui and control-board READMEs drop the 7331 serve flow; CURRENT.md
dated line appended.
UNVERIFIED: no node or tests run (Sage's gate, sage-2821).
124 lines
6.7 KiB
JavaScript
124 lines
6.7 KiB
JavaScript
// Row 198: the board runs in-process in the Console. These are the Console-side killers:
|
|
// M3 (no proxy fetch to a board URL), M5 (no seen write without --send), M6 and M7 (the
|
|
// preview gate runs before any board route), M10 (positive control: the write branches
|
|
// reach the board under --send) and M14 (a pending board read never blocks /healthz).
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { existsSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { request } from 'node:http';
|
|
import { startServer } from '../src/serve.mjs';
|
|
import { seenPath } from '../../control-board/src/scan.mjs';
|
|
import { close, fixture } from './fixture.mjs';
|
|
|
|
const NAME = 'mosaic-preview.example.com', HEADER = 'remote-user', ID = 'jason';
|
|
const preview = { host: NAME, header: HEADER, user: ID };
|
|
const ok = { [HEADER]: ID, origin: `https://${NAME}`, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' };
|
|
const without = name => Object.fromEntries(Object.entries(ok).filter(([k]) => k !== name));
|
|
const BODY = '{"agent":"proj/agent1","text":"hi"}';
|
|
const BOARD_ROUTES = [['GET', '/api/board'], ['GET', '/api/conversations'], ['POST', '/api/seen'], ['POST', '/api/reply']];
|
|
|
|
// node:http, not fetch: fetch can't set Host.
|
|
function call(port, { method = 'POST', path, headers = ok, host = NAME, body = BODY } = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const length = method === 'GET' ? {} : { 'content-length': Buffer.byteLength(body) };
|
|
const req = request({ host: '127.0.0.1', port, method, path, headers: { host, ...length, ...headers } }, res => {
|
|
let text = '';
|
|
res.on('data', c => (text += c));
|
|
res.on('end', () => resolve({ status: res.statusCode, text }));
|
|
});
|
|
req.on('error', reject);
|
|
req.end(method === 'GET' ? undefined : body);
|
|
});
|
|
}
|
|
|
|
// A board that counts every call that reaches it.
|
|
function countingBoard(hits, index = async () => ({ sessions: [], seen: [] })) {
|
|
return {
|
|
index: async () => { hits.push('index'); return index(); },
|
|
markSeen: async () => { hits.push('markSeen'); return { seen: [] }; },
|
|
reply: async () => { hits.push('reply'); return { status: 200, body: { delivered: true } }; },
|
|
conversation: async () => { hits.push('conversation'); return { status: 200, body: {} }; },
|
|
};
|
|
}
|
|
|
|
function stop(web) {
|
|
return new Promise(resolve => { web.closeAllConnections(); web.close(resolve); });
|
|
}
|
|
|
|
// M6, M7: under the preview, every board route refuses a request without the proxy header
|
|
// (401) and a request with a foreign Host (403), and the board never runs.
|
|
test('preview: every board route refuses without the proxy header (401) or with a foreign Host (403) before the board runs (M6, M7)', async t => {
|
|
const hits = [];
|
|
const web = await startServer({ port: 0, board: countingBoard(hits), preview });
|
|
t.after(() => stop(web));
|
|
const port = web.address().port;
|
|
for (const [method, path] of BOARD_ROUTES) {
|
|
const bare = await call(port, { method, path, headers: without(HEADER) });
|
|
assert.equal(bare.status, 401, `${method} ${path} without the header`);
|
|
const foreign = await call(port, { method, path, host: 'evil.example' });
|
|
assert.equal(foreign.status, 403, `${method} ${path} with a foreign Host`);
|
|
}
|
|
assert.deepEqual(hits, [], 'the board ran for a refused request');
|
|
});
|
|
|
|
// M5: without --send the seen write refuses and writes no mark file.
|
|
test('seen without --send refuses and writes no mark (M5)', async t => {
|
|
const f = await fixture();
|
|
t.after(() => f.close());
|
|
const web = await startServer({ port: 0, board: f.board, preview });
|
|
t.after(() => stop(web));
|
|
const res = await call(web.address().port, { path: '/api/seen', body: JSON.stringify({ project: 'proj', agent: 'agent1', lastActivity: 'x', seen: true }) });
|
|
assert.equal(res.status, 403);
|
|
assert.equal(JSON.parse(res.text).sent, false);
|
|
assert.equal(existsSync(seenPath(join(f.root, 'board'))), false, 'a mark was written without --send');
|
|
});
|
|
|
|
// M10: positive control. With --send on the public name, both writes reach the in-process
|
|
// board. A branch moved below the read-only refusal would answer 403 here and fail.
|
|
test('with --send on the public name, seen and reply reach the in-process board (M10)', async t => {
|
|
const f = await fixture();
|
|
t.after(() => f.close());
|
|
const web = await startServer({ port: 0, board: f.board, preview, send: async () => ({ id: 'msg-0001' }) });
|
|
t.after(() => stop(web));
|
|
const port = web.address().port;
|
|
const rec = (await f.board.index()).sessions.find(r => r.agent === 'agent1');
|
|
const seen = await call(port, { path: '/api/seen', body: JSON.stringify({ project: rec.project, agent: rec.agent, lastActivity: rec.lastActivity, seen: true }) });
|
|
assert.equal(seen.status, 200, seen.text);
|
|
assert.equal(existsSync(seenPath(join(f.root, 'board'))), true, 'the seen write did not reach the board');
|
|
const reply = await call(port, { path: '/api/reply' });
|
|
assert.equal(reply.status, 200, reply.text);
|
|
assert.equal(JSON.parse(reply.text).delivered, true);
|
|
assert.equal(f.captures.length, 1);
|
|
assert.match(f.captures[0].args.at(-1), /^hi\n/);
|
|
});
|
|
|
|
// M3: the Console reads its board in-process. No request leaves the Console for a board URL.
|
|
test('a board read makes no request to a board URL (M3)', async t => {
|
|
const hits = [];
|
|
const web = await startServer({ port: 0, board: countingBoard(hits) });
|
|
t.after(() => stop(web));
|
|
const base = `http://127.0.0.1:${web.address().port}`;
|
|
const urls = [];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (url, opts) => { urls.push(String(url)); return realFetch(url, opts); };
|
|
t.after(() => { globalThis.fetch = realFetch; });
|
|
assert.equal((await globalThis.fetch(base + '/api/board')).status, 200);
|
|
assert.deepEqual(hits, ['index'], 'the board ran once, in-process');
|
|
assert.equal(urls.length, 1, 'the spy saw the test request');
|
|
assert.ok(urls.every(u => u.startsWith(base)), `a request left the Console: ${urls.join(', ')}`);
|
|
});
|
|
|
|
// M14: /healthz answers within 200 ms while a board read is pending. This checks the async
|
|
// path only. A read that blocks the loop (spawnSync) is not reliably caught in-process, since
|
|
// the test shares the loop; BUILD.md records that gap, and the mutant run is the real check.
|
|
test('healthz answers within 200 ms while a board read is pending (M14)', async t => {
|
|
const web = await startServer({ port: 0, board: countingBoard([], () => new Promise(() => {})) });
|
|
t.after(() => stop(web));
|
|
const base = `http://127.0.0.1:${web.address().port}`;
|
|
// stop() drops the pending socket, so this fetch rejects at teardown; its outcome is unused.
|
|
fetch(base + '/api/board').catch(() => {});
|
|
const health = await fetch(base + '/healthz', { signal: AbortSignal.timeout(200) });
|
|
assert.equal(health.status, 200);
|
|
});
|