|
|
|
@@ -0,0 +1,986 @@
|
|
|
|
|
diff --git a/docs/prd/mosaic-stack.md b/docs/prd/mosaic-stack.md
|
|
|
|
|
index 794a39bbb..cf6e9f774 100644
|
|
|
|
|
--- a/docs/prd/mosaic-stack.md
|
|
|
|
|
+++ b/docs/prd/mosaic-stack.md
|
|
|
|
|
@@ -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
|
|
|
|
|
diff --git a/packages/bus/tests/channel-proof.test.mjs b/packages/bus/tests/channel-proof.test.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..a1e6ad3b2
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/bus/tests/channel-proof.test.mjs
|
|
|
|
|
@@ -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");
|
|
|
|
|
+});
|
|
|
|
|
diff --git a/packages/cli/src/cli.mjs b/packages/cli/src/cli.mjs
|
|
|
|
|
index 7b903e506..a56a1b118 100644
|
|
|
|
|
--- a/packages/cli/src/cli.mjs
|
|
|
|
|
+++ b/packages/cli/src/cli.mjs
|
|
|
|
|
@@ -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));
|
|
|
|
|
diff --git a/packages/cli/tests/channel-cli.test.mjs b/packages/cli/tests/channel-cli.test.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..8e6f1ee58
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/cli/tests/channel-cli.test.mjs
|
|
|
|
|
@@ -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", {}]]);
|
|
|
|
|
+});
|
|
|
|
|
diff --git a/packages/cli/tests/channel-fixture.mjs b/packages/cli/tests/channel-fixture.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..b3a04d9b3
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/cli/tests/channel-fixture.mjs
|
|
|
|
|
@@ -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),
|
|
|
|
|
+ };
|
|
|
|
|
+}
|
|
|
|
|
diff --git a/packages/cli/tests/channel-recovery.test.mjs b/packages/cli/tests/channel-recovery.test.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..e0998413b
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/cli/tests/channel-recovery.test.mjs
|
|
|
|
|
@@ -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);
|
|
|
|
|
+});
|
|
|
|
|
diff --git a/packages/cli/tests/project.test.mjs b/packages/cli/tests/project.test.mjs
|
|
|
|
|
index c101ba5e7..5e067247b 100644
|
|
|
|
|
--- a/packages/cli/tests/project.test.mjs
|
|
|
|
|
+++ b/packages/cli/tests/project.test.mjs
|
|
|
|
|
@@ -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 => {
|
|
|
|
|
diff --git a/packages/cli/tests/thread-cli.test.mjs b/packages/cli/tests/thread-cli.test.mjs
|
|
|
|
|
index 47e557eaf..13e32bc86 100644
|
|
|
|
|
--- a/packages/cli/tests/thread-cli.test.mjs
|
|
|
|
|
+++ b/packages/cli/tests/thread-cli.test.mjs
|
|
|
|
|
@@ -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" } } } },
|
|
|
|
|
});
|
|
|
|
|
diff --git a/packages/plugins/README.md b/packages/plugins/README.md
|
|
|
|
|
index 97703951f..9f8b86d62 100644
|
|
|
|
|
--- a/packages/plugins/README.md
|
|
|
|
|
+++ b/packages/plugins/README.md
|
|
|
|
|
@@ -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.
|
|
|
|
|
diff --git a/packages/plugins/channel/cli/index.mjs b/packages/plugins/channel/cli/index.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..d74347edb
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/plugins/channel/cli/index.mjs
|
|
|
|
|
@@ -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);
|
|
|
|
|
+}
|
|
|
|
|
diff --git a/packages/plugins/channel/webui/index.mjs b/packages/plugins/channel/webui/index.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..e9cb53f15
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/plugins/channel/webui/index.mjs
|
|
|
|
|
@@ -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);
|
|
|
|
|
+}
|
|
|
|
|
diff --git a/packages/plugins/src/channel.mjs b/packages/plugins/src/channel.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..84c54c091
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/plugins/src/channel.mjs
|
|
|
|
|
@@ -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 });
|
|
|
|
|
+ };
|
|
|
|
|
+}
|
|
|
|
|
diff --git a/packages/plugins/src/kinds.mjs b/packages/plugins/src/kinds.mjs
|
|
|
|
|
index f5679ad3f..a29681573 100644
|
|
|
|
|
--- a/packages/plugins/src/kinds.mjs
|
|
|
|
|
+++ b/packages/plugins/src/kinds.mjs
|
|
|
|
|
@@ -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 {
|
|
|
|
|
diff --git a/packages/plugins/src/loader.mjs b/packages/plugins/src/loader.mjs
|
|
|
|
|
index 5a8aa8b5e..04731ee91 100644
|
|
|
|
|
--- a/packages/plugins/src/loader.mjs
|
|
|
|
|
+++ b/packages/plugins/src/loader.mjs
|
|
|
|
|
@@ -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 };
|
|
|
|
|
}
|
|
|
|
|
diff --git a/packages/plugins/tests/channel.test.mjs b/packages/plugins/tests/channel.test.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..b44856580
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/plugins/tests/channel.test.mjs
|
|
|
|
|
@@ -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);
|
|
|
|
|
+});
|
|
|
|
|
diff --git a/packages/plugins/tests/kinds.test.mjs b/packages/plugins/tests/kinds.test.mjs
|
|
|
|
|
index 9bed0dee8..14c72e311 100644
|
|
|
|
|
--- a/packages/plugins/tests/kinds.test.mjs
|
|
|
|
|
+++ b/packages/plugins/tests/kinds.test.mjs
|
|
|
|
|
@@ -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] },
|
|
|
|
|
diff --git a/packages/plugins/tests/loader.test.mjs b/packages/plugins/tests/loader.test.mjs
|
|
|
|
|
index 2cd0068ed..b4b02eb44 100644
|
|
|
|
|
--- a/packages/plugins/tests/loader.test.mjs
|
|
|
|
|
+++ b/packages/plugins/tests/loader.test.mjs
|
|
|
|
|
@@ -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 => {
|
|
|
|
|
diff --git a/packages/webui/src/chat-http.mjs b/packages/webui/src/chat-http.mjs
|
|
|
|
|
index 94f765482..5a92dcff8 100644
|
|
|
|
|
--- a/packages/webui/src/chat-http.mjs
|
|
|
|
|
+++ b/packages/webui/src/chat-http.mjs
|
|
|
|
|
@@ -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}).`;
|
|
|
|
|
diff --git a/packages/webui/src/chat.mjs b/packages/webui/src/chat.mjs
|
|
|
|
|
index 85d3cda92..2cf33ee78 100644
|
|
|
|
|
--- a/packages/webui/src/chat.mjs
|
|
|
|
|
+++ b/packages/webui/src/chat.mjs
|
|
|
|
|
@@ -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 }),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
diff --git a/packages/webui/tests/channel-chat.test.mjs b/packages/webui/tests/channel-chat.test.mjs
|
|
|
|
|
new file mode 100644
|
|
|
|
|
index 000000000..c550cd39b
|
|
|
|
|
--- /dev/null
|
|
|
|
|
+++ b/packages/webui/tests/channel-chat.test.mjs
|
|
|
|
|
@@ -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/);
|
|
|
|
|
+});
|
|
|
|
|
diff --git a/packages/webui/tests/chat.test.mjs b/packages/webui/tests/chat.test.mjs
|
|
|
|
|
index 00ee8326a..5b6611bb3 100644
|
|
|
|
|
--- a/packages/webui/tests/chat.test.mjs
|
|
|
|
|
+++ b/packages/webui/tests/chat.test.mjs
|
|
|
|
|
@@ -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); }
|
Claude Opus 5.5