// Row 129: the single seam between Console chat operations and the bus transport it is given. // The signed-in listener passes the human transport (cli.mjs, `chat = createChat({ call })`); the row 176 // tester listener passes the tester transport (row 177, `createChat({ call })` over TESTER_CLI). // 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'; // FED R6 (#1800, sage-3153): `owner`, when given, is the owner's transport, and it carries only // the channel settings read, `plugins` with {}. A granted user's chat needs it since `plugins` is // not a user verb. The result gates the webui channel server-side and is never sent to the user. // Every chat verb goes over the user's own `call`. export function createChat({ call, owner = null }) { if (typeof call !== 'function') throw new TypeError('chat needs a bus transport function'); if (owner !== null && typeof owner !== 'function') throw new TypeError('chat owner must be a bus transport function'); const dispatch = createChannelCaller({ name: 'webui', call: owner === null ? call : (verb, args) => verb === 'plugins' ? owner('plugins', {}) : call(verb, args) }); 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: () => channel('project.list', {}), createProject: ({ name, repo }) => channel('project.create', { name, ...(repo === undefined ? {} : { repo }) }), threads: ({ project } = {}) => channel('thread.list', project === undefined ? {} : { project }), createThread: ({ project, name, instance }) => channel('thread.create', { project, name, ...(instance === undefined ? {} : { instance }) }), sessions: ({ thread }) => channel('session.list', { thread }), createSession: ({ thread, name, op }) => channel('session.create', { thread, name, op }), clearSession: ({ thread, session, revision, confirm, op }) => channel('session.clear', { thread, session, revision, confirm, op }), cancelSession: ({ thread, op, confirm }) => channel('session.cancel', { thread, op, confirm }), sessionOperation: ({ thread, op }) => channel('session.operation', { thread, op }), messages: ({ thread, session, after, limit }) => channel('thread.messages', { thread, ...(session ? { session } : {}), ...(after ? { after } : {}), limit }), send: ({ thread, session, body }) => channel('thread.send', { thread, ...(session ? { session } : {}), body, class: 'REQUEST' }), open: ({ thread, session }) => channel('thread.open', { thread, ...(session ? { session } : {}) }), }); }