salvage 2026-11-06: uncommitted work from src/mosaic-stack-rocko-164-r1 (disk cleanup #824)

This commit is contained in:
mos committed 2026-11-06 10:06:59 -06:00
1 parent 850484a7d2
commit 72fbae2c34
21 files changed
+705 -22

No files matched your search

+3 -3
View File
@@ -819,9 +819,9 @@ only hard waits in his inbox.
in `packages/queue/src/review.mjs`, the ledger's repository paths,
and the `refactor` branch in `scripts/land-work.sh`.
`gitea.baseUrl` exists in `vars.mjs` and the scripts don't read it.
- Channels: the human channel is `via: 'cli'` in the broker, the
WebUI reaches the bus by running the human CLI, and Discord isn't
connected to the bus.
- Channels: `cli` and `webui` are channel plug-in modules, selected by
the organization's `plugins.channel` list. Both retain the core human
proof transport (`via: 'cli'`); Discord isn't connected to the bus.
- Version 1.4:
- Jason approved REQ-WEB-3 in decision 021af0c8 (prd.approve, choice
yes; the approval message was request 2e031716, from request
+44
View File
@@ -0,0 +1,44 @@
// Row 164 explicitly freezes proof bytes and its literal entry-path rule.
import test from "node:test";
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import { readFileSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { provedRuntime } from "../../cli/tests/channel-fixture.mjs";
import { Client } from "../src/client.mjs";
const baselines = {
"packages/bus/src/human.mjs": "b995fc5cff3af8ade4c990d0e3bebf9d83829e00f034ebc9c3dcfd05f252b573",
"packages/bus/src/human-cli.mjs": "269c3a66008c0d57a54b14b73cf988d5f61f5e815455486296716e98ce5e8073",
"packages/cli/src/transport.mjs": "5129c44b4d9f642e825344df65c9bfb4bac4fc8d6b25343b42d39853dbd40774",
"packages/webui/src/bus.mjs": "dbad731ca8be19619064f050e766aeca856cf614783b9eca887caff3c2451f24",
};
const repoFile = path => new URL("../../../" + path, import.meta.url);
test("channel conversion preserves the four proof/transport byte baselines and modules cannot import a proof caller", () => {
for (const [file, hash] of Object.entries(baselines))
assert.equal(createHash("sha256").update(readFileSync(repoFile(file))).digest("hex"), hash, file);
for (const name of ["cli", "webui"]) {
const source = readFileSync(repoFile(`packages/plugins/channel/${name}/index.mjs`), "utf8");
assert.doesNotMatch(source, /human-cli|humanTransport|humanCall|verifyHuman|readProcess|child_process|spawn/);
}
});
test("channel recovery still requires the same shim path and rejects an absent or forged proof", { timeout: 20000 }, async t => {
const s = await provedRuntime(t);
const direct = new Client({ path: s.socket });
await assert.rejects(direct.call("plugins"), e => ["invalid-envelope", "unauthenticated", "human-required"].includes(e.code));
const forged = new Client({ path: s.socket, human: { business: "demo", pid: process.pid, startTime: "0", nonce: "a".repeat(64) } });
await assert.rejects(forged.call("plugins"), e => e.code === "human-required");
const genuine = await s.shimCall(s.shim, { business: "demo", verb: "plugins" });
assert.equal(genuine.status, 0, genuine.stderr);
assert.deepEqual(JSON.parse(genuine.stdout).plugins.channel, []);
let other = readFileSync(s.shim, "utf8");
other = other.replace("'./client.mjs'", JSON.stringify(new URL("../src/client.mjs", import.meta.url).href));
other = other.replace("'./human.mjs'", JSON.stringify(new URL("../src/human.mjs", import.meta.url).href));
const differentPath = join(s.root, "other-human-cli.mjs");
writeFileSync(differentPath, other);
const refused = await s.shimCall(differentPath, { business: "demo", verb: "plugins" });
assert.notEqual(refused.status, 0);
assert.equal(refused.stderr.trim(), "human-required");
});
+28 -4
View File
@@ -17,6 +17,8 @@ import { projectBusCommand, projectCommand, PROJECT_BUS_USAGE, PROJECT_USAGE } f
import { resolveThread, threadCommand, threadMembers, threadsCommand, THREAD_TALK_USAGE, THREAD_USAGE, THREADS_USAGE } from "./thread.mjs";
import { limitsCommand, LIMITS_USAGE } from "./limits.mjs";
import { pluginsCommand, PLUGINS_USAGE } from "./plugins.mjs";
import { createChannelCaller } from "../../plugins/src/channel.mjs";
import { PluginError } from "../../plugins/src/kinds.mjs";
import { CliError } from "./errors.mjs";
import { bootConfig, loadSystem, socketPath } from "./config.mjs";
import { bootLine, readBootStatus, recordBootOk, recordBootRefused } from "./boot-status.mjs";
@@ -186,6 +188,28 @@ function callFor(parsed, io, deps) {
return deps.transport ? deps.transport(business) : humanTransport({ socket: socketPath(system.dataRoot), business, env: io.env });
}
// Only the converted project/thread surface uses a channel. Management stays on callFor.
function channelCallFor(parsed, io, deps) {
const call = callFor(parsed, io, deps);
const channel = createChannelCaller({ name: "cli", call,
log: entry => io.stderr.write(`mosaic: channel module refused (${entry.code})\n`),
});
return async (verb, args = {}) => {
try { return await channel(verb, args); }
catch (error) {
if (!(error instanceof PluginError)) throw error;
let message = error.message;
if (error.code === "channel-disabled" && parsed.values["--business"]) {
message += ` Pass --business ${JSON.stringify(parsed.values["--business"])} to both commands.`;
}
const refused = new CliError(message, ["channel-disabled", "channel-config"].includes(error.code) ? 3 : 2);
refused.code = error.code;
throw refused;
}
};
}
// The human's unread messages, newest first, from every page of `messages`.
async function unreadMessages(call) {
const messages = [];
@@ -342,7 +366,7 @@ async function talk(rest, io, deps, receiveOnly = false) {
if (threadRef !== undefined) [to, body] = [threadRef, to];
// The broker refuses it too (tester-prefix); this is the clear early message.
if (!receiveOnly && parsed.flags.has("--tester") && !body.startsWith(TESTER_PREFIX)) throw new CliError(`a tester message starts with "${TESTER_PREFIX}"`, 2);
const call = callFor(parsed, io, deps);
const call = threadRef === undefined ? callFor(parsed, io, deps) : channelCallFor(parsed, io, deps);
let sent;
let thread = null;
if (threadRef !== undefined) {
@@ -538,9 +562,9 @@ export async function main(argv, io = { env: process.env, stdin: process.stdin,
if (argv.length === 0) return app(io, deps);
const [verb, ...rest] = argv;
if (["inbox", "decide", "tasks", "agents", "trail"].includes(verb)) return human(verb, rest, io, deps);
if (verb === "project") return ["create", "list"].includes(rest[0]) ? projectBusCommand(rest, io, (p) => callFor(p, io, deps)) : projectCommand(rest, io, deps);
if (verb === "threads") return threadsCommand(rest, io, (p) => callFor(p, io, deps));
if (verb === "thread") return threadCommand(rest, io, (p) => callFor(p, io, deps), formatMessage);
if (verb === "project") return ["create", "list"].includes(rest[0]) ? projectBusCommand(rest, io, (p) => channelCallFor(p, io, deps)) : projectCommand(rest, io, deps);
if (verb === "threads") return threadsCommand(rest, io, (p) => channelCallFor(p, io, deps));
if (verb === "thread") return threadCommand(rest, io, (p) => channelCallFor(p, io, deps), formatMessage);
if (verb === "limits") return limitsCommand(rest,io,p=>callFor(p,io,deps));
if (verb === "usage") return usageCommand(rest, io, p => callFor(p, io, deps));
if (verb === "plugins") return pluginsCommand(rest, io, (p) => callFor(p, io, deps));
+42
View File
@@ -0,0 +1,42 @@
// Row 164: switching CLI chat off never gates the core management verbs.
import test from "node:test";
import assert from "node:assert/strict";
import { run } from "../src/cli.mjs";
import { io, tmp } from "./helpers.mjs";
function setup(t, selected) {
const calls = [];
const deps = { system: { dataRoot: tmp(t, "channel-cli-") }, transport: () => async (verb, args = {}) => {
calls.push([verb, args]);
if (verb === "plugins") return { business: "demo", revision: "a".repeat(64), plugins: selected === undefined ? {} : { channel: selected } };
if (["project.list", "thread.list"].includes(verb)) return [];
assert.fail("unexpected operation " + verb);
} };
return { calls, async cli(argv) { const x = io(); return { code: await run([...argv, "--business", "demo"], x, deps), out: x.out.text, err: x.err.text }; } };
}
test("CLI off, absent and other-only channel selections refuse every project/thread flow before any effect", async t => {
for (const selected of [[], undefined, ["webui"]]) {
const s = setup(t, selected);
for (const argv of [["project", "list"], ["project", "create", "work"], ["threads"], ["thread", "read", "stack/chat"], ["thread", "open", "stack/chat"], ["thread", "create", "stack", "chat"], ["talk", "--thread", "stack/chat", "hello", "--wait", "0"], ["follow", "--thread", "stack/chat"]]) {
s.calls.length = 0;
const result = await s.cli(argv);
assert.equal(result.code, 3, argv.join(" "));
assert.match(result.err, /mosaic plugins.*mosaic plugins set/s);
assert.match(result.err, /plugins\.channel/);
assert.ok(result.err.includes('Pass --business "demo" to both commands.'));
assert.match(result.err, /cli.*webui/);
assert.equal(result.out, "");
assert.deepEqual(s.calls, [["plugins", {}]]);
}
}
});
test("CLI enabled project/thread lists dispatch through selection without changing output", async t => {
const s = setup(t, ["cli"]);
assert.deepEqual(await s.cli(["project", "list"]), { code: 0, out: "no projects\n", err: "" });
assert.deepEqual(s.calls, [["plugins", {}], ["project.list", {}]]);
s.calls.length = 0;
assert.deepEqual(await s.cli(["threads"]), { code: 0, out: "no threads\n", err: "" });
assert.deepEqual(s.calls, [["plugins", {}], ["thread.list", {}]]);
});
+75
View File
@@ -0,0 +1,75 @@
// Private fixture runtime only; no live host, unit, store or organization file.
import { spawn } from "node:child_process";
import { once } from "node:events";
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { fixture, BUSINESSES } from "./helpers.mjs";
import { systemFor } from "../../business/tests/helpers.mjs";
export async function childResult(file, args, env, input) {
const child = spawn(file, args, { env, stdio: ["pipe", "pipe", "pipe"] });
let stdout = "", stderr = "";
child.stdout.on("data", b => stdout += b);
child.stderr.on("data", b => stderr += b);
child.stdin.on("error", () => {});
child.stdin.end(input);
const [status, signal] = await once(child, "close");
return { status, signal, stdout, stderr };
}
export async function provedRuntime(t) {
const root = mkdtempSync(join(tmpdir(), "channel-recovery-"));
let host;
t.after(async () => {
try {
if (host && host.exitCode === null && host.signalCode === null) {
const done = once(host, "close");
const timer = setTimeout(() => host.kill("SIGKILL"), 3000);
host.kill("SIGTERM");
try { await done; } finally { clearTimeout(timer); }
}
} finally { rmSync(root, { recursive: true, force: true }); }
});
const f = fixture(root, "demo", doc => ({ ...doc, plugins: { channel: [] } }));
mkdirSync(f.dataRoot, { mode: 0o700 });
const url = rel => new URL(rel, import.meta.url).href;
const humanURL = url("../../bus/src/human.mjs");
const script = join(root, "fixture-runtime.mjs");
// As in stack-copy.test.mjs, isolate the fixture's ancestry from the seat.
// The real PID, UID, argv path, start time, nonce and verifier still run.
writeFileSync(script, `
import { mock } from 'node:test';
const real = await import(${JSON.stringify(humanURL)});
mock.module(${JSON.stringify(humanURL)}, { namedExports: {
readProcess: real.readProcess,
verifyHuman: (proof, options) => real.verifyHuman(proof, { ...options,
readProcess: pid => ({ ...real.readProcess(pid), ppid: 1 }) }),
} });
const { startBroker } = await import(${JSON.stringify(url("../../bus/src/runtime.mjs"))});
const runtime = await startBroker({ dataRoot: ${JSON.stringify(f.dataRoot)},
businesses: ${JSON.stringify(BUSINESSES)},
organization: { dir: ${JSON.stringify(join(root, "config"))}, rolesDir: ${JSON.stringify(f.roles)}, system: ${JSON.stringify(systemFor(root))} } });
process.on('SIGTERM', async () => { await runtime.close(); process.exit(0); });
console.log('fixture ready');
`);
const env = { PATH: process.env.PATH, HOME: root, TMPDIR: process.env.TMPDIR,
MOSAIC_CONFIG: f.config, MOSAIC_ROLES_DIR: f.roles };
host = spawn(process.execPath, ["--experimental-test-module-mocks", script], { env, stdio: ["ignore", "pipe", "pipe"] });
let output = "", errors = "";
host.stderr.on("data", b => errors += b);
await new Promise((resolve, reject) => {
host.stdout.on("data", b => { output += b; if (output.includes("fixture ready")) resolve(); });
host.once("exit", code => reject(new Error(`fixture failed ${code}: ${errors}`)));
host.once("error", reject);
});
const cli = fileURLToPath(new URL("../src/cli.mjs", import.meta.url));
const shim = fileURLToPath(new URL("../../bus/src/human-cli.mjs", import.meta.url));
return { root, f, env, shim, socket: join(f.dataRoot, "bus/broker.sock"),
cli: argv => childResult(process.execPath, [cli, ...argv, "--business", "demo"], env),
shimCall: (file, request) => childResult(process.execPath, [file, join(f.dataRoot, "bus/broker.sock")], env, JSON.stringify(request) + "\n"),
file: join(root, "config/businesses/demo.json"),
history: () => readFileSync(join(root, "config/businesses/.history/demo/changes.jsonl"), "utf8").trim().split("\n").map(JSON.parse),
};
}
@@ -0,0 +1,39 @@
// Removing or disabling every channel must leave the proved management writer usable.
import test from "node:test";
import assert from "node:assert/strict";
import { writeFileSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { provedRuntime } from "./channel-fixture.mjs";
test("both channels off recover through the existing human CLI, socket and organization writer", { timeout: 20000 }, async t => {
const s = await provedRuntime(t);
const off = await s.cli(["threads"]);
assert.equal(off.status, 3, off.stderr);
assert.match(off.stderr, /mosaic plugins.*mosaic plugins set/s);
const view = await s.cli(["plugins", "--json"]);
assert.equal(view.status, 0, view.stderr);
const state = JSON.parse(view.stdout);
assert.deepEqual(state.plugins.channel, []);
const patch = join(s.root, "enable.json");
writeFileSync(patch, JSON.stringify({ revision: state.revision, plugins: { channel: ["cli", "webui"] } }));
const done = await s.cli(["plugins", "set", "--file", patch]);
assert.equal(done.status, 0, done.stderr);
assert.deepEqual(JSON.parse(done.stdout).plugins.channel, ["cli", "webui"]);
assert.deepEqual(JSON.parse(readFileSync(s.file, "utf8")).plugins.channel, ["cli", "webui"]);
const receipt = s.history().at(-1);
assert.equal(receipt.actor, "jason");
assert.equal(receipt.state, "committed");
const threads = await s.cli(["threads"]);
assert.deepEqual([threads.status, threads.stdout, threads.stderr], [0, "no threads\n", ""]);
const before = readFileSync(s.file, "utf8");
const stale = await s.cli(["plugins", "set", "--file", patch]);
assert.notEqual(stale.status, 0);
assert.match(stale.stderr, /revision-conflict/);
assert.equal(readFileSync(s.file, "utf8"), before);
// Removing the key is also off, and does not remove the recovery read path.
const now = JSON.parse((await s.cli(["plugins"])).stdout);
writeFileSync(patch, JSON.stringify({ revision: now.revision, plugins: { channel: null } }));
assert.equal((await s.cli(["plugins", "set", "--file", patch])).status, 0);
assert.equal((await s.cli(["threads"])).status, 3);
assert.equal((await s.cli(["plugins"])).status, 0);
});
+2 -1
View File
@@ -44,11 +44,12 @@ test('project create and list validate their arguments before any bus call', asy
assert.match(x.err.text, /mosaic project create <name>/);
}
const listed = [];
const transport = () => async verb => (listed.push(verb), []);
const managementReads = [], transport = () => async verb => verb === 'plugins' ? (managementReads.push(verb), { business: 'acme', revision: 'a'.repeat(64), plugins: { channel: ['cli', 'webui'] } }) : (listed.push(verb), []);
const x = io(humanEnv(f.env));
assert.equal(await run(['project', 'list', '--business', 'acme'], x, { transport }), 0);
assert.deepEqual(listed, ['project.list']);
assert.equal(x.out.text, 'no projects\n');
assert.deepEqual(managementReads, ['plugins']);
});
test('project dispatcher reaches the human CLI', async t => {
+6
View File
@@ -32,7 +32,13 @@ function setup(t, { businessRoles = roles } = {}) {
store.close();
rmSync(root, { recursive: true, force: true });
});
const managementReads = [];
const b = new Broker({
organization: (business, verb) => {
assert.equal(verb, "plugins");
managementReads.push([business, verb]);
return { business, revision: "a".repeat(64), plugins: { channel: ["cli", "webui"] } };
},
store,
businesses: { demo: { id: "demo", human: "jason", arbiters: { technical: "chief", delivery: "chief" }, roles: businessRoles, definitions, projects: { stack: { root: "/nonexistent" } } } },
});
+38
View File
@@ -19,6 +19,7 @@ loader.
| `usage-source` | 1 | list | `interfaceVersion`, `readTurn` |
| `limit-check` | 1 | list | `interfaceVersion`, `mayLaunch`, `mustStop` |
| `search-source` | 1 | one | `interfaceVersion`, `search` |
| `channel` | 1 | list | `interfaceVersion`, `dispatch` |
Every module exports `interfaceVersion`, equal to its kind's interface
version, plus the kind's functions. PRD REQ-LIMIT-4 says what the two kinds
@@ -131,3 +132,40 @@ and appends baselines and outcomes. See that module's README for JSONL formats,
security/resource bounds and the best-reading limitation. No limit check ships
with this row. Enable transcript through the human plug-in settings writer;
a restart/re-pin remains a separate authorized window.
## Human project/thread channels
`channel` modules carry project/thread operations between a human surface and
its existing core bus caller. The shipped `cli` and `webui` modules implement
`dispatch({ verb, args }, { call })`, returning the bus result or refusal
unchanged. Only the fixed project/thread operations are supported; CLI also
uses message.receive/read for thread talk/follow. Modules do not create a human
proof, choose a business/owner, spawn the shim or write organization settings.
The broker still sees the proved transport as `via: 'cli'` for both surfaces.
Discord is not connected and no Discord module ships here.
The setting is `"plugins": { "channel": ["cli", "webui"] }`. An absent key or
an empty list disables both converted chat surfaces. No silent default enables
them. CLI off refuses with exit 3; web chat off returns 503, both naming recovery.
Other CLI administration and Console views are independent. CLI project
init/check and non-thread talk/inbox are core operations, outside this conversion.
Each chat operation reads the existing plugins setting, loads only its channel
selection through the in-tree loader, captures a frozen `snapshot('channel')`
array of `{ name, module }`, then dispatches without a lock. A slow send does
not block a list. A captured array never changes after a reload; loaded() and
modules() keep their existing interfaces. Invalid module settings retain the
loader's last good selection; the first refused load has nothing enabled.
The recovery commands never need a channel: from a human shell, run
`mosaic plugins --business BUSINESS --json`, make a patch with its revision and
`{"channel":["cli","webui"]}` as the plugins value, then run
`mosaic plugins set --business BUSINESS --file PATCH`. This uses the existing
proved human transport and organization writer, with revision checks and actor
receipts. The next chat operation reads the restored selection. Disabling a
channel cannot disable this write path. It is not a repair bypass for an invalid
organization file or unavailable bus.
For the re-pin introducing this kind, Jason enables both channels through
plugins.set immediately after activate in Mos's window, then smokes CLI thread
listing and Console chat. No development seat performs that live step.
+19
View File
@@ -0,0 +1,19 @@
// Surface adapter only. The caller and its human proof belong to core.
import { PluginError } from "../../src/kinds.mjs";
export const interfaceVersion = 1;
const VERBS = new Set([
"project.list",
"project.create",
"thread.list",
"thread.create",
"thread.messages",
"thread.send",
"thread.open",
"message.receive",
"message.read",
]);
export async function dispatch({ verb, args }, { call }) {
if (!VERBS.has(verb)) throw new PluginError("channel-operation", "unsupported channel operation");
return call(verb, args);
}
+17
View File
@@ -0,0 +1,17 @@
// Surface adapter only. The caller and its human proof belong to core.
import { PluginError } from "../../src/kinds.mjs";
export const interfaceVersion = 1;
const VERBS = new Set([
"project.list",
"project.create",
"thread.list",
"thread.create",
"thread.messages",
"thread.send",
"thread.open",
]);
export async function dispatch({ verb, args }, { call }) {
if (!VERBS.has(verb)) throw new PluginError("channel-operation", "unsupported channel operation");
return call(verb, args);
}
+28
View File
@@ -0,0 +1,28 @@
// Core selection only: modules receive a business-bound call, never a proof or writer.
import { createLoader } from "./loader.mjs";
import { NAME, PluginError } from "./kinds.mjs";
export const CHANNEL_RECOVERY = 'Run mosaic plugins to read the revision, then mosaic plugins set --file PATCH with plugins.channel set to ["cli","webui"].';
const record = value => value !== null && typeof value === "object" && !Array.isArray(value);
const report = entry => process.stderr.write(`channel: ${JSON.stringify({
event: entry.event, kind: entry.kind, name: entry.name, code: entry.code, kept: entry.kept,
})}\n`);
export function createChannelCaller({ name, call, log = report }) {
if (typeof name !== "string" || !NAME.test(name)) throw new PluginError("bad-name", "invalid channel name");
if (typeof call !== "function") throw new TypeError("channel needs a core caller");
const loader = createLoader({ log });
return async (verb, args = {}) => {
const settings = await call("plugins", {});
if (!record(settings) || !record(settings.plugins)) {
throw new PluginError("channel-config", "invalid channel settings response");
}
const selection = Object.hasOwn(settings.plugins, "channel") ? { channel: settings.plugins.channel } : {};
await loader.load(selection);
const snapshot = loader.snapshot("channel");
const entry = snapshot.find(item => item.name === name);
if (!entry) throw new PluginError("channel-disabled", CHANNEL_RECOVERY, name);
// No lock spans dispatch. Concurrent reads can proceed while a send awaits.
return entry.module.dispatch({ verb, args }, { call });
};
}
+4
View File
@@ -22,6 +22,10 @@ export const KINDS = Object.freeze({
"search-source": Object.freeze({
kind: "search-source", interfaceVersion: 1, exports: Object.freeze(["search"]), switch: "one",
}),
// Human project/thread surfaces; proof and the recovery writer remain in core.
channel: Object.freeze({
kind: "channel", interfaceVersion: 1, exports: Object.freeze(["dispatch"]), switch: "list",
}),
});
export class PluginError extends Error {
+7 -1
View File
@@ -154,5 +154,11 @@ export function createLoader({ log, barrier = () => {} }) {
return current.get(kind).map(m => m.module);
}
return { load, loaded, modules };
// Capture names and modules together, without exposing mutable state or a dispatch lock.
function snapshot(kind) {
if (!current.has(kind)) refuse("unknown-kind", `unknown kind ${JSON.stringify(kind)}`);
return current.get(kind);
}
return { load, loaded, modules, snapshot };
}
+233
View File
@@ -0,0 +1,233 @@
// Row 164: channel selection stays independent of human proof and administration.
import test from "node:test";
import assert from "node:assert/strict";
import { mkdirSync, renameSync, symlinkSync, unlinkSync } from "node:fs";
import { join } from "node:path";
import { createLoader } from "../src/loader.mjs";
import { KINDS } from "../src/kinds.mjs";
import { tree } from "./helpers.mjs";
const code = expected => e => e.code === expected;
const fixtureModule = tag => `export const interfaceVersion = 1;
export async function dispatch(request, {call}) { return call(request.verb, {...request.args, fixture:${JSON.stringify(tag)}}); }
`;
const settings = channel => ({ business: "demo", revision: "a".repeat(64), plugins: channel === undefined ? {} : { channel } });
const helper = () => import("../src/channel.mjs");
test("channel registry requires dispatch at interface 1 and switches a list", () => {
assert.deepEqual(KINDS.channel, { kind: "channel", interfaceVersion: 1, exports: ["dispatch"], switch: "list" });
assert.ok(Object.isFrozen(KINDS.channel));
assert.ok(Object.isFrozen(KINDS.channel.exports));
});
test("channel shipped modules load and preserve every supported operation and bus refusal", async () => {
const loader = createLoader({ log: () => {} });
assert.deepEqual((await loader.load({ channel: ["cli", "webui"] })).refused, []);
assert.deepEqual(loader.loaded().channel, ["cli", "webui"]);
const modules = loader.modules("channel");
for (const [index, verbs] of [
[0, ["project.list", "project.create", "thread.list", "thread.create", "thread.messages", "thread.send", "thread.open", "message.receive", "message.read"]],
[1, ["project.list", "project.create", "thread.list", "thread.create", "thread.messages", "thread.send", "thread.open"]],
]) {
for (const verb of verbs) {
const seen = [];
const result = await modules[index].dispatch({ verb, args: { thread: "thread-one", body: "literal", class: "REQUEST" } }, {
call: async (v, args) => { seen.push([v, args]); return { receipt: "preserved" }; },
});
assert.deepEqual(result, { receipt: "preserved" });
assert.deepEqual(seen, [[verb, { thread: "thread-one", body: "literal", class: "REQUEST" }]]);
}
const refusal = Object.assign(new Error("thread-not-owned"), { code: "thread-not-owned" });
await assert.rejects(modules[index].dispatch({ verb: "thread.list", args: {} }, { call: async () => { throw refusal; } }), e => e === refusal);
let calls = 0;
await assert.rejects(modules[index].dispatch({ verb: "plugins.set", args: {} }, { call: async () => calls++ }), code("channel-operation"));
assert.equal(calls, 0);
}
await assert.rejects(modules[1].dispatch({ verb: "message.receive", args: {} }, { call: async () => assert.fail("not a web chat operation") }), code("channel-operation"));
});
test("channel snapshot is a frozen matched pair and a captured array survives reload", async t => {
const s = tree(t);
s.write("channel", "one", fixtureModule("one"));
s.write("channel", "two", fixtureModule("two"));
const loader = await s.loader();
await loader.load({ channel: ["two", "one"] });
assert.equal(typeof loader.snapshot, "function");
const captured = loader.snapshot("channel");
assert.deepEqual(captured.map(x => x.name), ["two", "one"]);
assert.deepEqual(captured.map(x => x.name), loader.loaded().channel);
assert.deepEqual(captured.map(x => x.module), loader.modules("channel"));
assert.ok(Object.isFrozen(captured));
assert.ok(captured.every(Object.isFrozen));
assert.throws(() => captured.push(captured[0]), TypeError);
await loader.load({ channel: ["one"] });
assert.deepEqual(loader.snapshot("channel").map(x => x.name), ["one"]);
assert.deepEqual(captured.map(x => x.name), ["two", "one"]);
assert.deepEqual(await captured[0].module.dispatch({ verb: "thread.list", args: {} }, { call: async (verb, args) => args }), { fixture: "two" });
assert.throws(() => loader.snapshot("no-such-kind"), code("unknown-kind"));
});
test("channel guards refuse bad names, missing paths, exports and versions while retaining last good", async t => {
const s = tree(t);
s.write("channel", "good", fixtureModule("good"));
mkdirSync(join(s.pkg, "channel", "empty"));
mkdirSync(join(s.pkg, "channel", "dir-index", "index.mjs"), { recursive: true });
s.write("channel", "missing-export", "export const interfaceVersion = 1;\n");
s.write("channel", "missing-version", "export function dispatch() {}\n");
s.write("channel", "bad-type", "export const interfaceVersion = 1; export const dispatch = 1;\n");
s.write("channel", "wrong-version", "export const interfaceVersion = 2; export function dispatch() {}\n");
const loader = await s.loader();
assert.deepEqual((await loader.load({ channel: ["good"] })).refused, []);
for (const [names, expected] of [
[["../good"], "bad-name"], [["absent"], "missing"], [["empty"], "missing"], [["dir-index"], "missing"],
[["missing-export"], "missing-export"], [["missing-version"], "missing-export"], [["bad-type"], "missing-export"], [["wrong-version"], "interface-version"],
]) {
const result = await loader.load({ channel: names });
assert.equal(result.refused.length, 1);
assert.equal(result.refused[0].code, expected);
assert.deepEqual(result.loaded.channel, ["good"]);
assert.deepEqual(result.refused[0].kept, ["good"]);
}
});
test("channel guards refuse symlinked module, index and kind directories", async t => {
const s = tree(t);
const good = s.write("channel", "good", fixtureModule("good"));
const loader = await s.loader();
await loader.load({ channel: ["good"] });
symlinkSync(good, join(s.pkg, "channel", "linked"));
const index = s.write("channel", "linked-index", fixtureModule("unused"));
unlinkSync(join(index, "index.mjs"));
symlinkSync(join(good, "index.mjs"), join(index, "index.mjs"));
for (const name of ["linked", "linked-index"]) {
const result = await loader.load({ channel: [name] });
assert.equal(result.refused[0].code, "symlink");
const refusedPath = `/channel/${name}${name === "linked-index" ? "/index.mjs" : ""} is a symlink`;
assert.ok(result.refused[0].message.endsWith(refusedPath));
assert.deepEqual(result.loaded.channel, ["good"]);
}
renameSync(join(s.pkg, "channel"), join(s.pkg, "channel-real"));
symlinkSync(join(s.pkg, "channel-real"), join(s.pkg, "channel"));
assert.equal((await loader.load({ channel: ["good"] })).refused[0].code, "symlink");
});
test("channel caller re-reads settings and keeps off switches independent by module name", async () => {
const { createChannelCaller } = await helper();
let selected = ["webui"];
const calls = [], logged = [];
const call = async (verb, args) => {
calls.push([verb, args]);
return verb === "plugins" ? settings(selected) : { ok: true };
};
const cli = createChannelCaller({ name: "cli", call, log: entry => logged.push(entry) });
const webui = createChannelCaller({ name: "webui", call, log: entry => logged.push(entry) });
await assert.rejects(cli("thread.list", {}), e => e.code === "channel-disabled" && /mosaic plugins.*mosaic plugins set/s.test(e.message));
assert.deepEqual(calls.splice(0), [["plugins", {}]]);
assert.deepEqual(await webui("thread.list", {}), { ok: true });
assert.deepEqual(calls.splice(0), [["plugins", {}], ["thread.list", {}]]);
selected = ["cli"];
assert.deepEqual(await cli("project.list", {}), { ok: true });
calls.length = 0;
await assert.rejects(webui("thread.send", { body: "private" }), code("channel-disabled"));
assert.deepEqual(calls, [["plugins", {}]]);
for (selected of [[], undefined]) {
calls.length = 0;
await assert.rejects(cli("message.receive", {}), code("channel-disabled"));
assert.deepEqual(calls, [["plugins", {}]]);
}
assert.deepEqual(logged, []);
});
test("channel caller malformed settings refuse without a chat operation and no unrelated kind loads", async () => {
const { createChannelCaller } = await helper();
let answer = null;
let ops = 0;
const logged = [];
const call = async verb => verb === "plugins" ? answer : ++ops;
const caller = createChannelCaller({ name: "cli", call, log: e => logged.push(e) });
for (answer of [null, [], {}, { plugins: null }, { plugins: [] }]) {
await assert.rejects(caller("project.list", {}), code("channel-config"));
assert.equal(ops, 0);
}
answer = { ...settings(["cli"]), plugins: { channel: ["cli"], "usage-source": ["missing-unrelated"] } };
assert.equal(await caller("project.list", {}), 1);
assert.deepEqual(logged, []);
});
test("channel caller uses last good after loader refusal and fails closed on first load", async () => {
const { createChannelCaller } = await helper();
let selected = ["cli"];
const logged = [];
const call = async verb => verb === "plugins" ? settings(selected) : "kept";
const caller = createChannelCaller({ name: "cli", call, log: e => logged.push(e) });
assert.equal(await caller("project.list", {}), "kept");
selected = ["missing-module"];
assert.equal(await caller("project.list", {}), "kept");
assert.equal(logged[0].code, "missing");
assert.deepEqual(logged[0].kept, ["cli"]);
const fresh = createChannelCaller({ name: "cli", call, log: () => {} });
await assert.rejects(fresh("project.list", {}), code("channel-disabled"));
});
test("channel dispatch holds no selection lock while a slow send is awaiting", async () => {
const { createChannelCaller } = await helper();
let release, started;
const entered = new Promise(r => started = r);
const held = new Promise(r => release = r);
const caller = createChannelCaller({ name: "cli", log: () => {}, call: async verb => {
if (verb === "plugins") return settings(["cli"]);
if (verb === "thread.send") { started(); await held; return "sent"; }
return "listed";
} });
const send = caller("thread.send", {});
await entered;
let timer;
try {
assert.equal(await Promise.race([caller("project.list", {}), new Promise((_, reject) => timer = setTimeout(() => reject(new Error("dispatch blocked list")), 1000))]), "listed");
} finally { clearTimeout(timer); release(); }
assert.equal(await send, "sent");
});
test("channel last realpath check refuses an index swapped after component checks", async t => {
const s = tree(t);
const good = s.write("channel", "good", fixtureModule("good"));
const swapped = s.write("channel", "swapped", fixtureModule("old"));
let swap = false;
const loader = await s.loader({ barrier: (point, { name }) => {
if (swap && point === "checked" && name === "swapped") {
unlinkSync(join(swapped, "index.mjs"));
symlinkSync(join(good, "index.mjs"), join(swapped, "index.mjs"));
}
} });
await loader.load({ channel: ["good"] });
swap = true;
const result = await loader.load({ channel: ["swapped"] });
assert.equal(result.refused[0].code, "symlink");
assert.deepEqual(result.loaded.channel, ["good"]);
});
test("channel caller refuses invalid core construction", async () => {
const { createChannelCaller } = await helper();
for (const name of ["../cli", "Cli", null])
assert.throws(() => createChannelCaller({ name, call: async () => ({}) }), code("bad-name"));
assert.throws(() => createChannelCaller({ name: "cli", call: null }), TypeError);
});
test("channel caller invokes the selected loaded module instead of bypassing dispatch", async t => {
const s = tree(t);
s.write("channel", "cli", fixtureModule("cli-fixture"));
s.write("channel", "webui", fixtureModule("webui-fixture"));
const { createChannelCaller } = await import(new URL("./channel.mjs", s.loaderUrl));
const caller = createChannelCaller({ name: "webui", log: () => {}, call: async (verb, args) =>
verb === "plugins" ? settings(["cli", "webui"]) : args });
assert.deepEqual(await caller("thread.list", { project: "one" }), { project: "one", fixture: "webui-fixture" });
});
test("channel caller keeps the selected module operation filter in front of the core transport", async () => {
const { createChannelCaller } = await helper();
let writes = 0;
const caller = createChannelCaller({ name: "cli", log: () => {}, call: async verb =>
verb === "plugins" ? settings(["cli"]) : ++writes });
await assert.rejects(caller("plugins.set", {}), code("channel-operation"));
assert.equal(writes, 0);
});
+1 -1
View File
@@ -6,7 +6,7 @@ import { KINDS, NAME, PluginError, checkPlugins } from "../src/kinds.mjs";
const code = expected => e => e instanceof PluginError && e.code === expected;
test("REQ-PLUG-1 REQ-LIMIT-4 the registry: usage-source and limit-check at interface version 1, each a list", () => {
assert.deepEqual(Object.keys(KINDS), ["usage-source", "limit-check", "search-source"]);
assert.deepEqual(Object.keys(KINDS), ["usage-source", "limit-check", "search-source", "channel"]);
assert.deepEqual({ ...KINDS["usage-source"], exports: [...KINDS["usage-source"].exports] },
{ kind: "usage-source", interfaceVersion: 1, exports: ["readTurn"], switch: "list" });
assert.deepEqual({ ...KINDS["limit-check"], exports: [...KINDS["limit-check"].exports] },
+5 -5
View File
@@ -12,7 +12,7 @@ import { validateBusinessDocument } from "../../business/src/business.mjs";
const GOOD = { "usage-source": ["meter"], "limit-check": ["cap"] };
// What loaded() reports for GOOD: search-source is a kind too, switched off here.
const GOOD_LOADED = { ...GOOD, "search-source": [] };
const GOOD_LOADED = { ...GOOD, "search-source": [], channel: [] };
// A tree with one good module of each kind, already loaded.
async function loadedTree(t, options) {
@@ -56,7 +56,7 @@ test("REQ-PLUG-1 fixture modules of each kind switch on from a test organization
const loader = await s.loader();
const result = await loader.load(business.plugins);
assert.deepEqual(result.refused, []);
assert.deepEqual(result.loaded, { ...doc.plugins, "search-source": [] });
assert.deepEqual(result.loaded, { ...doc.plugins, "search-source": [], channel: [] });
assert.equal(loader.modules("usage-source")[0].readTurn(), "fixture-usage");
assert.equal(loader.modules("limit-check")[0].mayLaunch(), "fixture-limit");
assert.equal(loader.modules("limit-check")[0].mustStop(), false);
@@ -170,7 +170,7 @@ test("REQ-PLUG-1 a path that becomes unreadable after the lstat checks refuses a
assert.match(result.refused[0].message, /packages\/plugins can't be read \(EACCES\)/);
assert.deepEqual(result.refused[0].kept, ["meter"]);
assert.deepEqual(s.loader.logged.slice(before), result.refused);
assert.deepEqual(s.loader.loaded(), { "usage-source": ["meter"], "limit-check": [], "search-source": [] });
assert.deepEqual(s.loader.loaded(), { "usage-source": ["meter"], "limit-check": [], "search-source": [], channel: [] });
} finally {
if (lock) chmodSync(lock, 0o755);
}
@@ -214,7 +214,7 @@ test("REQ-PLUG-1 a kind refused on its first load has nothing switched on, and t
const loader = await s.loader();
// meter loads, absent refuses: the whole kind stays off, not half on.
const result = await loader.load({ "usage-source": ["meter", "absent"], "limit-check": ["cap"] });
assert.deepEqual(result.loaded, { "usage-source": [], "limit-check": ["cap"], "search-source": [] });
assert.deepEqual(result.loaded, { "usage-source": [], "limit-check": ["cap"], "search-source": [], channel: [] });
assert.deepEqual(loader.loaded(), result.loaded);
assert.deepEqual(loader.modules("usage-source"), []);
assert.equal(loader.logged.length, 1);
@@ -242,7 +242,7 @@ test("REQ-PLUG-1 the setting's shape: unknown kinds refuse alone, a bad whole se
await refusesKeepingOld(s, ["meter", "meter"], "bad-setting", "meter", /twice/);
// An absent key switches the kind off.
result = await s.loader.load({ "limit-check": ["cap"] });
assert.deepEqual(result.loaded, { "usage-source": [], "limit-check": ["cap"], "search-source": [] });
assert.deepEqual(result.loaded, { "usage-source": [], "limit-check": ["cap"], "search-source": [], channel: [] });
});
test("REQ-PLUG-1 loads run one at a time, so the last requested setting wins", async t => {
+2
View File
@@ -10,6 +10,7 @@ const json = (res, status, value) => {
res.end(JSON.stringify(value));
};
const STATUS = {
'channel-disabled': 503,
'invalid-request': 400, 'unknown-repo': 400, 'message-not-found': 400,
'project-not-found': 404, 'thread-not-found': 404, 'thread-not-owned': 403,
'project-exists': 409, 'thread-exists': 409, 'human-required': 403, unauthenticated: 403,
@@ -17,6 +18,7 @@ const STATUS = {
'thread-instance-missing': 503, 'thread-instance-ambiguous': 503, 'outcome-unknown': 503,
};
function safeMessage(code) {
if (code === 'channel-disabled') return 'Run mosaic plugins to read the revision, then mosaic plugins set --file PATCH with plugins.channel set to ["cli","webui"].';
if (code === 'thread-not-owned') return 'This thread is not available to this user.';
if (code === 'outcome-unknown') return 'Outcome unknown. Read the current list or conversation before trying again. Nothing was retried.';
return `Chat operation refused (${code}).`;
+19 -7
View File
@@ -1,14 +1,26 @@
// Row 129: the single seam between Console chat operations and the current human transport.
// No browser-selected bus verb, tenant, owner, capability or message class crosses this seam.
import { createChannelCaller } from '../../plugins/src/channel.mjs';
import { PluginError } from '../../plugins/src/kinds.mjs';
import { BusReadError } from './bus.mjs';
export function createChat({ call }) {
if (typeof call !== 'function') throw new TypeError('chat needs a human transport');
const dispatch = createChannelCaller({ name: 'webui', call });
const channel = async (verb, args) => {
try { return await dispatch(verb, args); }
catch (err) {
if (err instanceof PluginError) throw new BusReadError(err.code, err.message);
throw err;
}
};
return Object.freeze({
projects: () => call('project.list', {}),
createProject: ({ name, repo }) => call('project.create', { name, ...(repo === undefined ? {} : { repo }) }),
threads: ({ project } = {}) => call('thread.list', project === undefined ? {} : { project }),
createThread: ({ project, name }) => call('thread.create', { project, name }),
messages: ({ thread, after, limit }) => call('thread.messages', { thread, ...(after ? { after } : {}), limit }),
send: ({ thread, body }) => call('thread.send', { thread, body, class: 'REQUEST' }),
open: ({ thread }) => call('thread.open', { thread }),
projects: () => channel('project.list', {}),
createProject: ({ name, repo }) => channel('project.create', { name, ...(repo === undefined ? {} : { repo }) }),
threads: ({ project } = {}) => channel('thread.list', project === undefined ? {} : { project }),
createThread: ({ project, name }) => channel('thread.create', { project, name }),
messages: ({ thread, after, limit }) => channel('thread.messages', { thread, ...(after ? { after } : {}), limit }),
send: ({ thread, body }) => channel('thread.send', { thread, body, class: 'REQUEST' }),
open: ({ thread }) => channel('thread.open', { thread }),
});
}
@@ -0,0 +1,83 @@
// Row 164: the chat switch and fixed recovery message stay local to chat HTTP.
import test from "node:test";
import assert from "node:assert/strict";
import { request } from "node:http";
import { createChat } from "../src/chat.mjs";
import { startServer } from "../src/serve.mjs";
import { BusReadError } from "../src/bus.mjs";
import { close } from "./fixture.mjs";
const P = "10000000-0000-4000-8000-000000000001";
const T = "20000000-0000-4000-8000-000000000002";
const preview = { host: "chat.example.com", header: "remote-user", user: "jason" };
const headers = { host: preview.host, "remote-user": "jason", origin: "https://chat.example.com", "sec-fetch-site": "same-origin", "content-type": "application/json" };
function http(port, path, body) {
const raw = body === undefined ? undefined : JSON.stringify(body);
return new Promise((resolve, reject) => {
const req = request({ host: '127.0.0.1', port, path, method: raw === undefined ? 'GET' : 'POST',
headers: { ...headers, ...(raw === undefined ? {} : { 'content-length': Buffer.byteLength(raw) }) },
}, res => {
let text = '';
res.on('data', chunk => text += chunk);
res.on('end', () => resolve({ status: res.statusCode, data: JSON.parse(text) }));
});
req.on('error', reject); req.end(raw);
});
}
async function setup(t, selected) {
const calls = [], logs = [];
const chat = createChat({ call: async (verb, args) => {
calls.push([verb, args]);
if (verb === "plugins") return { business: "demo", revision: "a".repeat(64), plugins: selected === undefined ? {} : { channel: selected } };
return [];
} });
const server = await startServer({ port: 0, chat, preview, send: async () => ({}), log: line => logs.push(line) });
t.after(() => close(server));
return { calls, logs, async request(path, body) {
return http(server.address().port, path, body);
} };
}
test("WebUI channel off returns 503 and named recovery for every chat route without a chat operation", async t => {
for (const selected of [[], undefined, ["cli"]]) {
const s = await setup(t, selected);
for (const [path, body] of [
["/api/chat/projects"], ["/api/chat/threads"], [`/api/chat/threads/${T}/messages`],
["/api/chat/projects", { name: "work" }], ["/api/chat/threads", { project: P, name: "chat" }],
[`/api/chat/threads/${T}/messages`, { body: "private body" }], [`/api/chat/threads/${T}/open`, {}],
]) {
s.calls.length = 0;
const res = await s.request(path, body);
assert.equal(res.status, 503);
assert.equal(res.data.error, "channel-disabled");
assert.match(res.data.message, /mosaic plugins.*mosaic plugins set/s);
assert.match(res.data.message, /plugins\.channel/);
assert.match(res.data.message, /cli.*webui/);
if (body !== undefined) assert.equal(res.data.sent, false);
assert.deepEqual(s.calls, [["plugins", {}]]);
assert.doesNotMatch(JSON.stringify(res.data), /private body/);
}
}
});
test("WebUI only selection keeps web chat enabled while retaining the old read envelope", async t => {
const s = await setup(t, ["webui"]);
const res = await s.request("/api/chat/projects");
assert.equal(res.status, 200);
assert.deepEqual(res.data.rows, []);
assert.deepEqual(s.calls, [["plugins", {}], ["project.list", {}]]);
});
test("WebUI channel-disabled recovery text is fixed and never echoes transport text", async t => {
const chat = createChat({ call: async () => { throw new BusReadError("channel-disabled", "SENTINEL-private-input"); } });
const server = await startServer({ port: 0, chat, preview, send: async () => ({}), log: () => {} });
t.after(() => close(server));
const res = await http(server.address().port, '/api/chat/projects');
const result = res.data;
assert.equal(res.status, 503);
assert.equal(result.error, "channel-disabled");
assert.match(result.message, /mosaic plugins.*mosaic plugins set/s);
assert.doesNotMatch(JSON.stringify(result), /SENTINEL/);
});
+10
View File
@@ -33,7 +33,12 @@ function http(port, path, { method = 'GET', value, raw, extra = {}, host = previ
async function setup(t, options = {}) {
const calls = [], logs = [];
const state = { answer: [] };
const managementReads = [];
const chat = createChat({ call: async (verb, args) => {
if (verb === 'plugins') {
managementReads.push([verb, args]);
return { business: 'demo', revision: 'a'.repeat(64), plugins: { channel: ['cli', 'webui'] } };
}
calls.push([verb, args]);
if (state.answer instanceof Error) throw state.answer;
return typeof state.answer === 'function' ? state.answer(verb, args) : state.answer;
@@ -189,7 +194,12 @@ test('REQ-USER-2 real broker: owned catalog, create/name/filter, isolated histor
let b = new Broker({ store, businesses });
let cap = b.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const calls = [];
const managementReads = [];
const chat = createChat({ call: async (verb, args) => {
if (verb === 'plugins') {
managementReads.push([verb, args]);
return { business: 'demo', revision: 'a'.repeat(64), plugins: { channel: ['cli', 'webui'] } };
}
calls.push(verb);
try { return structuredClone(await b.request(cap, { verb, args })); }
catch (err) { throw new BusReadError(err.code); }