import { join } from 'node:path'; import { fileURLToPath } from 'node:url'; import { Store } from './store.mjs'; import * as projectModule from '../../project/src/index.mjs'; import { Broker, BusError } from './broker.mjs'; import { Credentials } from './credentials.mjs'; import { serve } from './server.mjs'; import { launchSettings } from '../../business/src/launch-settings.mjs'; import { readSessions } from '../../seat/src/session.mjs'; import { createLoader, hasModule } from '../../plugins/src/loader.mjs'; import { pluginSettings } from '../../business/src/plugin-settings.mjs'; import { webService } from './web.mjs'; import { verifyHuman } from './human.mjs'; import { createUsage } from './usage.mjs'; import { verifyTester } from './tester.mjs'; // Trusted host API. S1 supplies resolved definitions, S6 supplies launch records and ends them. // Human limits writes use the shared organization writer behind the verified transport. // `tasks` is S3's adapter factory: ({broker, credentials, businesses}) => {handle, timeout, close}. // REQ-HARN-2, REQ-PLUG-2 (decision 0b81b0c5): one web service per business. Its search source is // the "search-source" plug-in the business's organization file switches on: searxng-url (the // business var web.searxng) or searxng-bundled. With none, web.search refuses "not configured" and // web.fetch still works. A plug-in that refuses to load is logged and leaves search off; it never // stops the broker. Under harness-builtin the harness serves web itself, so the broker gets no // service and refuses the web verbs. export async function webServices(businesses, { log = (e) => process.stderr.write(`plugins: ${JSON.stringify(e)}\n`), deps } = {}) { const services = new Map(); for (const [name, b] of Object.entries(businesses)) { const loader = createLoader({ log }); await loader.load(b.plugins ?? {}); const [source] = loader.modules('search-source'); // "harness-builtin" is served by the harness itself, not the broker: no broker web verbs. if (loader.loaded()['search-source'][0] === 'harness-builtin') continue; // The module takes the business var web.searxng; "searxng-bundled" ignores it. const settings = { searxng: b.vars?.['web.searxng'] }; const search = source ? { search: async (query, opts) => source.search(settings, query, deps, opts) } : null; services.set(name, webService({ search, deps })); } return services; } export async function startBroker({ dataRoot, businesses, launches = [], readers = [], repoRoots = [], tasks = null, organization = null, }) { let store, credentials, server, adapter; try { const references = {}; for (const [business, b] of Object.entries(businesses)) { for (const [role, r] of Object.entries(b.roles)) if (r.credentials) references[business + '/' + role] = r.credentials; if (b.tracker?.sync?.credentials) references[business + '/@sync'] = b.tracker.sync.credentials; } const protectedRoots = [ fileURLToPath(new URL('../../../', import.meta.url)), ...repoRoots, ...Object.values(businesses).flatMap((b) => Object.values(b.projects ?? {}).map((p) => p.root)), ]; credentials = new Credentials({ references, repoRoots: protectedRoots, dataRoot }); store = new Store(dataRoot); // vikunja:19/305: the plug-in switch through the same human-only path as the limits: the verbs // plugins and plugins.set, logged in changes.jsonl with the actor, a missing module refused. const plugins=organization?pluginSettings({dir:organization.dir,rolesDir:organization.rolesDir,exists:hasModule}):null; const settings=organization?launchSettings({...organization,sessions:()=>readSessions(dataRoot)}):null; const usage = await createUsage({ store, dataRoot, businesses, log: entry => process.stderr.write(`usage: ${JSON.stringify(entry)}\n`) }); const broker = new Broker({ usage, store, businesses, project: { readSpec: context => projectModule.readSpec({ ...context, dataRoot }), writeRecord: context => projectModule.writeRecord({ ...context, dataRoot }), listFiles: context => projectModule.listProjectFiles({ ...context, dataRoot }), readFile: context => projectModule.readProjectFile({ ...context, dataRoot }), writeFile: context => projectModule.writeHumanFile({ ...context, dataRoot }), ProjectError: projectModule.ProjectError, }, organization:settings?(id,verb,args,actor)=>verb==='limits'?settings.read(id):verb==='limits.set'?settings.set(id,args,actor):verb==='plugins'?plugins.read(id):plugins.set(id,args,actor):null, secretCheck: (value) => credentials.assertClean(value), credentialStatus: () => credentials.status(), }); // Process identities must be supplied for every managed run when using the human transport. const launchRecords = []; function bindLaunch(r) { if ( !Number.isSafeInteger(r.pid) || r.pid < 2 || typeof r.startTime !== 'string' || !/^\d+$/.test(r.startTime) ) throw new BusError('invalid-launch-process'); const cap = broker.bindLaunch(r); launchRecords.push({ ...r }); return { business: r.business, run: r.run, cap }; } const bound = launches.map(bindLaunch); const readCaps = readers.map((business) => ({ business, cap: broker.bindReader({ business }) })); if (tasks) { adapter = await tasks({ broker, credentials, businesses }); if (typeof adapter?.handle !== 'function' || !Number.isSafeInteger(adapter.timeout) || adapter.timeout < 1) throw new BusError('invalid-adapter'); } const web = await webServices(businesses); const path = join(store.directory, 'broker.sock'); server = await serve({ web: (business) => web.get(business) ?? null, tasks: adapter ? { handle: adapter.handle, timeout: adapter.timeout } : null, broker, path, authenticateHuman: (proof) => { const { business } = verifyHuman(proof, { cliPath: fileURLToPath(new URL('./human-cli.mjs', import.meta.url)), launches: launchRecords, }); const human = businesses[business]?.human; if (!human) throw new BusError('unknown-business'); return broker.bindHuman({ business, human, via: 'cli', outsideAgent: true }); }, // Row 110 (#1604): a tester proves its CLI process and that no managed run is above it. // The broker then binds only if the business sets `bus.tester` to true. authenticateTester: (proof) => { const { business } = verifyTester(proof, { cliPath: fileURLToPath(new URL('./tester-cli.mjs', import.meta.url)), launches: launchRecords, }); return broker.bindTester({ business }); }, }); // S6 launcher operations. The host decides capacity and the instance list; the broker // authorizes role.launch and keeps the evidence, refusals included. // A refusal is recorded against the caller, as request() records one. function refusing(cap, fn, subject = null) { try { return fn(); } catch (e) { if (!(e instanceof BusError)) throw e; broker.refuse(cap, e.code, subject); throw e; } } const authorizeLaunch = (cap, instance) => refusing(cap, () => broker.authorize(cap, 'role.launch', { target: instance })); // Row 93 (#1587): the host's git socket. A push is checked before the host takes the bundle // and recorded once the ref moved; a reviewer's fetch is checked against its review.requested. const checkPush = (cap, task_ref) => refusing(cap, () => broker.checkPush(cap, task_ref), task_ref); const reviewFetch = (cap, args) => refusing(cap, () => broker.reviewFetch(cap, args), args?.task_ref); // Row 137 (#1631): the git socket's land op. checkLand's refusal is the run's, like checkPush's. // A landing then ends in recordLand or landRefused under its ticket, which outlive the run's cap. const checkLand = (cap, args) => refusing(cap, () => broker.checkLand(cap, args), args?.task_ref); // Metadata only (service, date, state); the token stays in Credentials. function credentialStatus(business, role) { return credentials .status() .filter((c) => c.instance === business + '/' + role) .map(({ service, date, state }) => ({ service, date, state })); } return { broker, credentials, path, bindLaunch, endLaunch: (r) => broker.endLaunch(r), threadsState: (business) => broker.threadsState(business), threadIdle: (r) => broker.threadIdle(r), identity: (cap) => broker.identity(cap), authorizeLaunch, checkPush, recordPush: (cap, push) => refusing(cap, () => broker.recordPush(cap, push), push?.task_ref), reviewFetch, checkLand, recordLand: (ticket, land) => broker.recordLand(ticket, land), landRefused: (ticket, args) => broker.landRefused(ticket, args), landHeld: (record) => broker.landHeld(record), refuse: (cap, code, subject) => broker.refuse(cap, code, subject), credentialStatus, launches: bound, readers: readCaps, async close() { await server.close(); await adapter?.close?.(); store.close(); credentials.close(); }, }; } catch (e) { await server?.close(); await adapter?.close?.(); store?.close(); credentials?.close(); throw e; } }