@idleware/ringi 0.5.0 → 0.6.0

package/target/esm/app/hubs.js

@@ -1,76 +0,0 @@
-// hubs: the operator's hubs on this machine: list, create, switch, add a signed replica, amend the shared contract.
-import fs from 'node:fs';
-import path from 'node:path';
-import { DEFAULT_PROFILE, PROFILES_CAPABILITY, parseProfile } from '../domain/profiles.js';
-import { HOME, OPERATOR, config, ensureHome, setConfig } from '../home/index.js';
-import { createHub, hubNames, openHub, roomNames } from '../hub/index.js';
-import { fail, strictJson, words } from '../lib/index.js';
-import { ID_RE, compose } from '../protocol/index.js';
-import * as Remote from '../store/git/remote.js';
-// The operator's terminal context picks the hub unless one is named.
-export const hubOf = (name) => openHub(name ?? config().hub);
-export const hubs = () => {
-    ensureHome();
-    if (!hubNames().length)
-        openHub('local');
-    const cur = config().hub;
-    return hubNames().map(n => {
-        const H = openHub(n);
-        return { name: H.name, current: H.name === cur, store: H.d.store.type, trust: H.contract.trust, contract: H.contract.version,
-            rooms: roomNames(H).length, remote: H.d.store.remote ?? null, dir: H.dir };
-    });
-};
-// A new hub; a signed one makes its root key here and returns what other machines need to pin it.
-export const create = (name, { signed = false, url } = {}) => {
-    if (!ID_RE.test(name))
-        fail('usage: ringi hub create <name> [--signed [--url <git url>]]');
-    createHub(name, { signed, url });
-    const H = openHub(name);
-    return { H, rootKey: H.signed ? path.join(HOME, 'keys', name, OPERATOR) : null,
-        add: H.signed ? `ringi hub add ${name} ${H.d.store.remote ?? '<url>'} --root '${H.d.root}' --genesis ${H.d.genesis}` : null };
-};
-export const use = (name) => {
-    openHub(name);
-    setConfig({ hub: name, room: null });
-};
-// A replica of a signed hub. The root key comes from the operator, out of band: a key the hub advertises proves nothing.
-export const add = (name, url, { root, genesis }) => {
-    if (!ID_RE.test(name) || !url)
-        fail('usage: ringi hub add <name> <git url> --root <public key|file> [--genesis <sha>]');
-    ensureHome();
-    Remote.hubAdd({ home: HOME, name, url, root, genesis });
-    return openHub(name);
-};
-// A new version of the shared contract on `main`. Rooms keep their base until moved (rooms.rebase).
-export const amend = (H, x) => {
-    const name = H.store.contractFile(H.main, 'contract.json') !== null ? 'contract.json' : 'hub.json';
-    const contract = strictJson(H.store.contractFile(H.main, name), name);
-    for (const kv of x.set ?? []) {
-        const [k, v] = kv.split(/=(.*)/s);
-        if (!['version', 'capabilities', 'protocol', 'profile'].includes(k))
-            fail(`contract keys that can be set: version, capabilities, protocol, profile (not ${k})`);
-        contract[k] = k === 'capabilities' ? words(v) : k === 'protocol' ? Number(v) : v;
-    }
-    const files = { [name]: JSON.stringify(contract, null, 2) + '\n' };
-    if (x.authority)
-        files['authority.json'] = JSON.stringify(strictJson(fs.readFileSync(x.authority, 'utf8'), x.authority), null, 2) + '\n';
-    for (const f of x.files ?? []) {
-        // A profile is checked before it reaches the contract.
-        if (/^profiles\/[^/]+\.json$/.test(f.path))
-            parseProfile(f.content.toString('utf8'), f.path);
-        files[f.path] = f.content;
-    }
-    if (typeof contract.profile === 'string' && contract.profile !== DEFAULT_PROFILE && !files[`profiles/${contract.profile}.json`] && H.store.contractFile(H.main, `profiles/${contract.profile}.json`) === null) {
-        fail(`the default profile ${contract.profile} is not in the hub; attach it: --attach <file>:profiles/${contract.profile}.json`);
-    }
-    // Profiles other than the built-in A2A rules need clients that read them: the contract says so.
-    if (Object.keys(files).some(f => f.startsWith('profiles/')) || (x.set ?? []).some(kv => kv.startsWith('profile='))) {
-        const caps = Array.isArray(contract.capabilities) ? contract.capabilities : [];
-        if (!caps.includes(PROFILES_CAPABILITY))
-            contract.capabilities = [...caps, PROFILES_CAPABILITY];
-        files[name] = JSON.stringify(contract, null, 2) + '\n';
-    }
-    H.store.amendContract(OPERATOR, compose(x.text, [['To', '*'], ['Kind', 'hub']]), files);
-    return { version: String(contract.version) };
-};
-//# sourceMappingURL=hubs.js.map

package/target/esm/app/room.js

@@ -1,181 +0,0 @@
-// room: what any participant (the operator or an agent) does in a room: write messages and read them, follow work,
-// check signals. Each operation takes who acts and typed input, and returns data; interfaces print it.
-import fs from 'node:fs';
-import * as D from '../domain/decisions.js';
-import { isOpen, tasksIn } from '../domain/profiles.js';
-import * as Signals from '../domain/signals.js';
-import { OPERATOR } from '../home/index.js';
-import { HIDDEN, append } from '../hub/index.js';
-import * as HubSignals from '../hub/signals.js';
-import { fail, note, short } from '../lib/index.js';
-import { checkCollisions } from '../protocol/files.js';
-import { ID_RE, TOKEN_RE, checkOutgoing, compose, link, lookup, ordered, rootOf, under } from '../protocol/index.js';
-import { linked, loadRoomUnlocked, loadState, readerLock, saveState } from '../runtime/reader.js';
-import { taskView } from './view.js';
-export const isRef = (R) => (x) => R.hub.store.isRef(x);
-// Staging, like git's index: add takes a file's content into the store now, and the actor's next message carries it,
-// whatever happens to the file meanwhile. Results and state travel only so, never through a shared directory. The store
-// keeps staged contents reachable (`retain`); it grows before the list does and shrinks after, so a crash in between
-// leaks an object rather than loses one.
-export const FILE_MAX = 64 << 20;
-const tooBig = (path, size) => size > FILE_MAX && fail(`${path} is ${Math.ceil(size / (1 << 20))} MiB; an attachment is at most ${FILE_MAX >> 20} MiB`);
-// What retain keeps: each staged content once, named by its id, so two snapshots of one path both stay.
-const kept = (all) => [...new Set(all.map(s => s.blob))].map(blob => ({ path: blob, blob, mode: '100644' }));
-export const staged = ({ R, me }) => loadState(R, me).staged ?? [];
-export const stage = ({ R, me }, files) => {
-    const taken = files.map(e => {
-        if (!e.file)
-            fail(`${e.path}: add takes files`);
-        tooBig(e.path, fs.statSync(e.file).size);
-        const b = R.hub.store.blob(e.file);
-        tooBig(e.path, b.size);
-        return { path: e.path, blob: b.id, mode: e.mode, size: b.size };
-    });
-    return readerLock(R, me, () => {
-        const st = loadState(R, me);
-        const next = new Map((st.staged ?? []).map(s => [s.path, s]));
-        for (const s of taken)
-            next.set(s.path, s);
-        const all = [...next.values()];
-        checkCollisions(all.map(s => s.path));
-        R.hub.store.retain(R.s, me, kept([...all, ...st.staged ?? []]));
-        saveState(R, me, { ...st, staged: all });
-        R.hub.store.retain(R.s, me, kept(all));
-        return all;
-    });
-};
-const shrink = ({ R, me }, keep) => {
-    const st = loadState(R, me);
-    const left = (st.staged ?? []).filter(keep);
-    saveState(R, me, { ...st, staged: left });
-    R.hub.store.retain(R.s, me, kept(left));
-    return left;
-};
-// Unstages the given paths, or everything.
-export const unstage = (a, paths) => readerLock(a.R, a.me, () => {
-    const missing = (paths ?? []).filter(p => !staged(a).some(s => s.path === p));
-    if (missing.length)
-        fail(`not staged: ${missing.join(', ')}`);
-    return shrink(a, s => paths !== null && !paths.includes(s.path));
-});
-// A message from the actor. The operator may omit `to`: the room, or the assignees when there are any.
-export const send = ({ R, me }, x) => {
-    const P = R.profile;
-    const { all } = linked(R, me);
-    const re = x.re ? lookup(all, x.re) : null;
-    let to = [...new Set(x.to ?? [])];
-    const assign = x.assign ? [...new Set(x.assign)] : null;
-    if (!to.length && x.reply && re)
-        to = re.from === me ? re.to : [re.from, ...(x.all ? re.to.filter(t => t !== me) : [])];
-    if (!to.length && assign)
-        to = assign;
-    if (!to.length && me === OPERATOR)
-        to = ['*'];
-    if (!to.length)
-        fail('--to is required: agent ids, comma-separated, or *');
-    for (const t of to)
-        if (t !== '*' && !ID_RE.test(t))
-            fail(`bad recipient ${t}`);
-    if (x.state && !P.states.includes(x.state))
-        fail(`--state must be one of profile ${P.name}: ${P.states.join(', ')}`);
-    if (x.state && !re)
-        fail('--state belongs to a reply inside a piece of work; pass --re <message>');
-    for (const a of assign ?? [])
-        if (!ID_RE.test(a))
-            fail(`bad assignee ${a}`);
-    if (x.roles && !x.roles.split(',').every(r => {
-        const parts = r.split('=').map(v => v.trim());
-        return parts.length === 2 && ID_RE.test(parts[0]) && TOKEN_RE.test(parts[1]);
-    }))
-        fail('--roles takes "<id>=<label>, …"; labels mean what the room profile says');
-    let grant = null;
-    if (x.grant) {
-        const d = lookup(all, x.grant);
-        const g = D.grantOf(all, R.authorityAt, d.id) ?? fail(`${short(d.id)} is not an approved decision with a budget`);
-        if (g.revoked)
-            fail(`grant ${short(g.id)} was revoked`);
-        grant = g.id;
-    }
-    // What the actor staged goes along, an explicit attachment of the same path in its place.
-    const stagedNow = staged({ R, me }), explicit = x.files ?? [];
-    for (const e of explicit)
-        if (e.file)
-            tooBig(e.path, fs.statSync(e.file).size);
-    const named = new Set(explicit.map(e => e.path));
-    const entries = [...stagedNow.filter(s => !named.has(s.path)).map(s => ({ path: s.path, blob: s.blob, mode: s.mode })), ...explicit];
-    checkCollisions(entries.map(e => e.path));
-    const text = compose(x.text, [
-        ['To', to.join(', ')], ['Re', re?.id], ['Kind', x.task && P.opens], ['State', x.state], ['Assign', assign?.join(', ')],
-        ['Roles', x.roles], ['Grant', grant], ['Hop', re && String(re.hopEff + 1)],
-    ]);
-    checkOutgoing(text, isRef(R));
-    const id = append(R, me, text, entries);
-    if (stagedNow.length)
-        readerLock(R, me, () => shrink({ R, me }, s => !stagedNow.some(t => t.path === s.path && t.blob === s.blob)));
-    if (to.length === 1 && to[0] === '*')
-        note(`addressed to the whole room: this ${x.task ? P.opens : 'message'} wakes nobody; name recipients (--to or --assign) to start work`);
-    return { id, to, files: entries.length };
-};
-// --- reading ---
-// Who marked a message how (read, taken), from the marks that pass their check.
-export const marks = (R, all) => Signals.marksOn(Signals.check(R, all, R.hub.store.signals(R.s)));
-export const message = ({ R, me }, ref) => {
-    const { all } = linked(R, me);
-    const m = lookup(all, ref);
-    return { all, m, replies: [...all.values()].filter(x => x.reId === m.id), marks: marks(R, all).get(m.id) };
-};
-export const thread = ({ R, me }, ref) => {
-    const { all } = linked(R, me);
-    return { all, msgs: under(all, rootOf(all, lookup(all, ref))) };
-};
-// Open work that concerns the actor (the operator: all open work); with `all`, every piece of work.
-export const tasks = ({ R, me }, { all: everything = false } = {}) => {
-    const P = R.profile;
-    const { all } = linked(R, me);
-    let ts = tasksIn(all, P);
-    if (!everything)
-        ts = ts.filter(t => isOpen(t, P) && (me === OPERATOR || t.requester === me || t.assignees.includes(me) || (!t.assignees.length && (t.root.to.includes(me) || t.root.to.includes('*')))));
-    ts.sort((a, b) => a.at - b.at);
-    const m = marks(R, all);
-    return { tasks: ts, views: ts.map(t => taskView(t, m.get(t.root.id)?.taken ?? [])) };
-};
-export const log = ({ R, me }, { agent, all: everything = false, n = 20 } = {}) => {
-    const { all } = linked(R, me);
-    return ordered([...all.values()].filter(m => (!agent || m.from === agent) && (everything || !(m.kind && HIDDEN.has(m.kind))))).slice(-n);
-};
-// The files of a message: one named path, or all of them.
-export const files = ({ R, me }, ref, path) => {
-    const { all } = linked(R, me);
-    const m = lookup(all, ref);
-    if (path && !m.files.some(f => f.path === path))
-        fail(`no ${path} in ${short(m.id)}`);
-    return { m, files: m.files.filter(f => !path || f.path === path).map(f => ({ path: f.path, content: R.hub.store.file(m.id, f.path) })) };
-};
-export const members = ({ R, me }) => {
-    const { logs, all } = linked(R, me);
-    const cards = new Map(ordered([...all.values()].filter(m => m.kind === 'card' && !m.bad)).map(m => [m.from, m]));
-    return Object.entries(R.members).map(([id, info]) => ({ id, role: info.role ?? 'member',
-        messages: (logs.get(id) ?? []).filter(m => !(m.kind && HIDDEN.has(m.kind))).length, card: cards.get(id)?.subject ?? null }));
-};
-// --- signals ---
-// The room's signals, each checked against its message and against what this reader accepted before; `repair` first
-// restores the missing signals of the actor's own messages.
-export const signals = ({ R, me }, { repair = false } = {}) => readerLock(R, me, () => {
-    const { logs, st } = loadRoomUnlocked(R, me);
-    const all = link(logs);
-    let repaired = null;
-    if (repair) {
-        repaired = 0;
-        for (const m of logs.get(me) ?? [])
-            repaired += HubSignals.emit(R, me, all, m);
-    }
-    const records = R.hub.store.signals(R.s);
-    const checked = Signals.check(R, all, records);
-    const p = Signals.pins(records, checked, st.signals);
-    saveState(R, me, { ...loadState(R, me), signals: p.accepted });
-    return { all, checked, alarms: [...p.alarms, ...checked.filter(c => !c.ok).map(c => `signal ${c.ref}: ${c.why}`)], repaired };
-});
-// What interfaces need to show and store a message's files: their sizes, and a path safe to write under.
-export { withSizes } from '../hub/index.js';
-export { checkPath } from '../protocol/files.js';
-//# sourceMappingURL=room.js.map

package/target/esm/app/session.js

@@ -1,99 +0,0 @@
-// Session use cases preserve the operator's identity, seat and delegated scope.
-import { OPERATOR, ensureHome, locked } from '../home/index.js';
-import { controlChange, openHub, room as roomOf, start } from '../hub/index.js';
-import { AGENT_RE } from '../protocol/index.js';
-import { allSessions, bound, dropSession, liveness, ownSession, parseSelector, pidAlive, readSession, saveSession, seatHolder, whoAmI } from '../runtime/session.js';
-import { fail, note, stamp } from '../lib/index.js';
-import { inbox } from './agent.js';
-import { tasks } from './room.js';
-export { bound } from '../runtime/session.js';
-// A room still waiting for its agents is not read: nothing is marked seen before its work starts.
-export const briefing = (s) => {
-    const actor = bound();
-    const st = start(actor.R);
-    return { session: s, actor, start: st, tasks: st.started ? tasks(actor).views : [], inbox: st.started ? inbox(actor) : null };
-};
-export const join = ({ hub, room, agent: id, scope }) => {
-    const me = whoAmI();
-    const agent = id ?? me.product ?? fail('--as <id> is required: this session\'s product is unknown');
-    if (!AGENT_RE.test(agent) || agent === OPERATOR)
-        fail(`bad agent id ${agent}: lowercase letters, digits, - and _, no dot`);
-    const H = openHub(hub), R = roomOf(H, room);
-    if (R.archived)
-        fail(`${room} is archived`);
-    if (H.signed) {
-        if (!H.store.joinKey)
-            fail(`hub ${H.name}: its store cannot make keys`);
-        const key = H.store.joinKey(R.s, agent);
-        if (!key.admitted)
-            return { agent, hub: H.name, room: R.name, session: null, key };
-    }
-    locked('sessions', () => {
-        const holder = seatHolder(H.name, R.genesis, agent, me.handle);
-        if (holder)
-            fail(`${room}/${agent} is held by another session (${holder.handle}, ${liveness(holder)}). A seat ends only with leave, or the operator's takeover: "continue ${room}/${agent}" in this chat`);
-        const mine = ownSession(me.handle);
-        if (mine?.product === 'watch' && mine.pid && pidAlive(mine.pid))
-            fail('this chat handed its seat to a live watcher; stop or leave it before joining another room');
-        if (mine && mine.handle !== me.handle)
-            dropSession(mine.handle);
-        const same = !!mine && mine.hub === H.name && mine.genesis === R.genesis && mine.agent === agent;
-        if (!R.members[agent]) {
-            if (H.signed)
-                fail(`${agent} is not in the roster of ${room}; the root admits its key first`);
-            controlChange(R, OPERATOR, `join ${agent}`, m => { m[agent] = { role: 'member', since: stamp() }; });
-        }
-        if (mine && !same)
-            note(`left ${mine.hub}/${mine.room} as ${mine.agent}: one room per session`);
-        saveSession({ handle: me.handle, product: me.product, hub: H.name, room: R.name, genesis: R.genesis, agent,
-            scope: scope ?? (same ? mine.scope : null), state: 'active', since: same ? mine.since : stamp(), lastSeen: stamp(), pid: me.pid });
-    });
-    return { agent, hub: H.name, room: R.name, session: readSession(me.handle), key: null };
-};
-export const resume = (selector) => {
-    const me = whoAmI();
-    ensureHome();
-    return locked('sessions', () => {
-        let target;
-        if (!selector) {
-            const mine = ownSession(me.handle);
-            if (!mine) {
-                const cands = allSessions().filter(s => liveness(s) !== 'active').sort((a, b) => Number(b.product === me.product) - Number(a.product === me.product));
-                if (!cands.length)
-                    fail('nothing to continue: this chat was never joined, and no paused or gone session waits. The operator says "join <room> as <id>"');
-                fail(`this chat has no binding of its own. Say which one to take over:\n${cands.map(s => `  ringi continue ${s.hub}:${s.room}/${s.agent}   (${liveness(s)}, ${s.product ?? '?'}, ${s.handle}${s.scope ? `, scope: ${s.scope}` : ''})`).join('\n')}`);
-            }
-            target = mine;
-        }
-        else {
-            const sel = parseSelector(selector);
-            const hits = allSessions().filter(s => s.room === sel.room && s.agent === sel.agent && (!sel.hub || s.hub === sel.hub));
-            if (hits.length > 1)
-                fail(`several hubs have ${sel.room}/${sel.agent}; name one: <hub>:${sel.room}/${sel.agent}`);
-            target = hits[0] ?? fail(`no session holds ${selector}; the operator joins this chat with ringi join`);
-        }
-        if (target.handle !== me.handle) {
-            if (liveness(target) === 'active' || (target.product === 'watch' && target.pid && pidAlive(target.pid)))
-                fail(`${target.room}/${target.agent} is held by a live session (${target.handle}); it is not taken over`);
-            dropSession(target.handle);
-            note(`took over ${target.hub}/${target.room}/${target.agent} from ${target.handle}`);
-        }
-        const session = { ...target, handle: me.handle, product: target.handle === me.handle ? target.product : me.product, state: 'active',
-            since: target.handle === me.handle ? target.since : stamp(), lastSeen: stamp(), pid: me.pid ?? (target.handle === me.handle ? target.pid : null),
-            takenFrom: target.handle === me.handle ? target.takenFrom : undefined };
-        saveSession(session);
-        return session;
-    });
-};
-export const stop = () => locked('sessions', () => {
-    const s = ownSession(whoAmI().handle) ?? fail('this session is in no room');
-    const stopped = { ...s, state: 'stopped', lastSeen: stamp() };
-    saveSession(stopped);
-    return stopped;
-});
-export const leave = () => locked('sessions', () => {
-    const s = ownSession(whoAmI().handle) ?? fail('this session is in no room');
-    dropSession(s.handle);
-    return s;
-});
-//# sourceMappingURL=session.js.map

package/target/esm/cli/context.js

@@ -1,8 +0,0 @@
-// context: who runs a command and in which room, from the command line.
-import * as Context from '../app/context.js';
-import { words } from '../lib/index.js';
-import { opt } from './args.js';
-export { isRef } from '../app/room.js';
-export const parseTo = (v) => [...new Set(words(v))];
-export const operatorCtx = (o) => Context.operator({ hub: opt(o, 'hub'), room: opt(o, 'room') });
-//# sourceMappingURL=context.js.map

package/target/esm/cli/operator.js

@@ -1,185 +0,0 @@
-// operator: what the human runs in a terminal: where things stand, sessions, hubs and rooms. Each command parses its
-// arguments, calls app operations and prints the result.
-import fs from 'node:fs';
-import * as Hubs from '../app/hubs.js';
-import * as Heartbeat from '../app/heartbeat.js';
-import * as Overview from '../app/overview.js';
-import * as Rooms from '../app/rooms.js';
-import { oneLine, render } from '../app/view.js';
-import { config } from '../app/context.js';
-import { withSizes } from '../app/room.js';
-import { fail, short, sleep } from '../lib/index.js';
-import { attachments, dump, flag, list, opt, out, textOf } from './args.js';
-import { taskLine } from './shared.js';
-// --- where things stand, sessions, forget ---
-export const sessionLine = (s) => `${s.agent.padEnd(12)} ${s.liveness.padEnd(8)} ${(s.product ?? '?').padEnd(7)} ${s.handle}${s.scope ? `  scope: ${s.scope}` : ''}`;
-export const where = async (o) => {
-    const H = Hubs.hubOf(opt(o, 'hub'));
-    const w = Overview.where(H, opt(o, 'room') ?? config().room);
-    out(`hub ${H.name}: ${H.d.store.type} store, ${H.contract.trust} senders, contract ${H.contract.version}, protocol ${H.contract.protocol}${H.contract.capabilities?.length ? `, ${H.contract.capabilities.join(' ')}` : ''}`);
-    const R = w.room;
-    if (!R)
-        return out('no current room: ringi room create <id> | ringi room switch <id>');
-    const agents = Object.values(R.members).filter(m => m.role !== 'root').length;
-    out(`room ${R.name}${R.archived ? ' (archived, read-only)' : ''}, genesis ${short(R.genesis)}, profile ${R.profile.name}; members: ${Object.entries(R.members).map(([id, i]) => i.role === 'root' ? `${id} (root)` : id).join(', ')}`
-        + (R.quorum === null ? '' : agents >= R.quorum ? `; started at its quorum of ${R.quorum} agents` : `; waiting for a quorum of ${R.quorum} agents, has ${agents}`));
-    out(w.sessions.length ? `sessions:\n${w.sessions.map(s => `  ${sessionLine(s)}`).join('\n')}` : 'sessions: none joined');
-    out(w.work.length ? `open work:\n${w.work.map(t => `  ${taskLine(t)}`).join('\n')}` : 'open work: none');
-    if (w.proposals.length)
-        out(`open proposals:\n${w.proposals.map(x => `  ${short(x.proposal.id)} ${x.state} → ${x.decider}  ${x.proposal.subject}`).join('\n')}`);
-    const n = Number(opt(o, 'n') ?? (flag(o, 'short') ? 10 : 5));
-    out(`last ${Math.min(n, w.messages.length)} of ${w.messages.length} messages:`);
-    const show = (all, m) => out(flag(o, 'short') ? `  ${oneLine(m)}` : `\n${render(all, m, { max: 2000, files: () => withSizes(R, m) })}`);
-    for (const m of w.messages.slice(-n))
-        show(w.all, m);
-    if (!flag(o, 'follow'))
-        return;
-    out('following; new messages appear as they land (Ctrl-C to stop)');
-    const seen = new Set(w.all.keys());
-    for (;;) {
-        await sleep(Number(opt(o, 'interval') ?? 2) * 1000);
-        const now = Overview.arrived(H, R, seen);
-        for (const m of now.messages)
-            show(now.all, m);
-    }
-};
-// Each session's pulse on this machine, judged without the model.
-export const heartbeats = async (o) => {
-    if (flag(o, 'published')) {
-        const R = Rooms.roomIn(Hubs.hubOf(opt(o, 'hub')), opt(o, 'room'));
-        const hs = Heartbeat.published(R);
-        if (flag(o, 'json'))
-            return dump(hs);
-        if (!hs.length)
-            return out(`no heartbeats in ${R.name}`);
-        for (const h of hs)
-            out(`${h.agent.padEnd(12)} ${(h.waits ? `${h.state} (${h.waits})` : h.state).padEnd(22)} ${h.age}s ago${h.overdue ? ', overdue' : ''}  on ${short(h.target)}`);
-        return;
-    }
-    const ps = await Heartbeat.heartbeats();
-    if (flag(o, 'json'))
-        return dump(ps);
-    if (!ps.length)
-        return out('no sessions');
-    for (const { session: s, tool, beat: b } of ps) {
-        const state = b.waits ? `${b.state} (${b.waits})` : b.state;
-        out(`${s.agent.padEnd(12)} ${`${s.hub}/${s.room}`.padEnd(24)} ${state.padEnd(22)} alive ${b.alive === null ? '?' : b.alive ? 'yes' : 'no'}  quiet ${b.quiet}s${b.cpu === null ? '' : `  cpu ${b.cpu.toFixed(1)}s`}  ${tool}  ${s.handle}`);
-    }
-};
-// The process that beats for every session here; `join` and `continue` start it.
-export const pulse = async (o) => {
-    process.exitCode = await Heartbeat.pulse({ every: Number(opt(o, 'beat') ?? 30), once: flag(o, 'once'), log: s => process.stderr.write(`ringi: ${s}\n`) });
-};
-export const sessions = (o) => {
-    if (o._[0] === 'forget') {
-        const handle = o._[1] ?? fail('usage: ringi sessions forget <handle>');
-        Overview.forgetSession(handle);
-        return out(`forgot session ${handle}; its seat is free`);
-    }
-    const ss = Overview.sessions();
-    if (flag(o, 'json'))
-        return dump(ss);
-    if (!ss.length)
-        return out('no sessions');
-    for (const s of ss)
-        out(`${s.hub}/${s.room}  ${sessionLine(s)}`);
-};
-export const forget = (o) => {
-    const [name, id] = (o._[0] ?? '').split('/');
-    if (!name || !id)
-        fail('usage: ringi forget <room>/<log>');
-    const H = Hubs.hubOf(opt(o, 'hub'));
-    const n = Rooms.forgetLog(H, Rooms.roomIn(H, name), id);
-    out(`forgot the accepted history of ${name}/${id} for ${n} reader(s); the next read accepts what is there now`);
-};
-// --- hubs and rooms ---
-export const hub = (o) => {
-    const [sub, arg] = o._;
-    if (!sub || sub === 'list') {
-        for (const h of Hubs.hubs())
-            out(`${h.current ? '*' : ' '} ${h.name.padEnd(12)} ${h.store}, ${h.trust}, contract ${h.contract}, ${h.rooms} room(s)${h.remote ? `  remote ${h.remote}` : ''}  ${h.dir}`);
-        return;
-    }
-    if (sub === 'create') {
-        const r = Hubs.create(arg ?? '', { signed: flag(o, 'signed'), url: opt(o, 'url') });
-        if (!r.add)
-            return out(`created hub ${arg} (${r.H.dir})`);
-        return out(`created signed hub ${arg}${r.H.d.store.remote ? `, published to ${r.H.d.store.remote}` : ''}. Its root key stays on this machine (${r.rootKey}).
-Give every machine that joins it, out of band:
-  ${r.add}`);
-    }
-    if (sub === 'switch') {
-        Hubs.use(arg ?? fail('usage: ringi hub switch <name>'));
-        return out(`current hub: ${arg}; agents keep their own rooms`);
-    }
-    if (sub === 'add') {
-        const H = Hubs.add(arg ?? '', o._[2] ?? '', { root: opt(o, 'root'), genesis: opt(o, 'genesis') });
-        return out(`added signed hub ${arg} from ${o._[2]}: contract ${H.contract.version}, ${Rooms.rooms(H).length} room(s), root pinned`);
-    }
-    if (sub === 'amend') {
-        const H = Hubs.hubOf(opt(o, 'hub'));
-        const files = list(o, 'attach').flatMap(attachments).map(e => ({ path: e.path, content: fs.readFileSync(e.file) }));
-        const r = Hubs.amend(H, { text: textOf(o), set: list(o, 'set'), authority: opt(o, 'authority'), files });
-        return out(`amended hub ${H.name}: contract ${r.version}; rooms keep their base until ringi room rebase-contract <room>`);
-    }
-    fail(`unknown: hub ${sub}`);
-};
-export const roomCmd = (o) => {
-    const [sub, arg] = o._;
-    const H = Hubs.hubOf(opt(o, 'hub'));
-    if (!sub || sub === 'list') {
-        const rs = Rooms.rooms(H, { archived: flag(o, 'archived') });
-        for (const r of rs.filter(r => !r.archived))
-            out(`${r.current ? '*' : ' '} ${r.name.padEnd(16)} ${r.members} member(s), ${r.active} active session(s), profile ${r.profile}  genesis ${short(r.genesis)}`);
-        for (const r of rs.filter(r => r.archived))
-            out(`  ${r.name.padEnd(16)} archived, read-only`);
-        if (!rs.length && !flag(o, 'archived'))
-            out(`no rooms in hub ${H.name}: ringi room create <id>`);
-        return;
-    }
-    if (sub === 'create') {
-        const quorum = opt(o, 'quorum');
-        const r = Rooms.create(H, arg ?? '', { profile: opt(o, 'profile'), quorum: quorum === undefined ? undefined : Number(quorum) });
-        if (quorum !== undefined)
-            return out(`created room ${arg} in hub ${H.name} with profile ${r.profile}; it is the current room. Its work starts by itself at a quorum of ${quorum} agent(s): in each chat that should take part, say "join ${arg} as <id>"`);
-        return out(`created room ${arg} in hub ${H.name} with profile ${r.profile}; it is the current room. In each chat that should take part, say: "join ${arg} as <id>; <what to accept>"`);
-    }
-    if (sub === 'migrate') {
-        const rev = Rooms.migrate(H, arg ?? fail('usage: ringi room migrate <id>'));
-        return out(`room ${arg} uses one branch; its genesis, message ids and session bindings are kept (${short(rev)})`);
-    }
-    if (sub === 'switch') {
-        const R = Rooms.use(H, arg ?? fail('usage: ringi room switch <id>'));
-        return out(`current room: ${H.name}/${R.name}; agents keep their own rooms`);
-    }
-    if (sub === 'admit') {
-        const R = Rooms.roomIn(H, opt(o, 'room'));
-        Rooms.admit(H, R, arg ?? fail('usage: ringi room admit <agent> <public key|file>'), o._[2] ?? fail('usage: ringi room admit <agent> <public key|file>'));
-        return out(`admitted ${arg} to ${H.name}/${R.name}: its signed messages are accepted from now on; it can join`);
-    }
-    if (sub === 'remove') {
-        const R = Rooms.roomIn(H, opt(o, 'room'));
-        Rooms.remove(H, R, arg ?? fail('usage: ringi room remove <agent>'));
-        return out(`removed ${arg} from ${R.name}: it can no longer write or be woken there; returning needs a fresh join`);
-    }
-    if (sub === 'archive') {
-        // Without an id, the room of the current context.
-        const R = Rooms.roomIn(H, arg ?? opt(o, 'room'));
-        const name = Rooms.archive(H, R);
-        return out(`archived ${R.name} as ${name}: read-only, wakes nobody; its sessions end. Read it with --room ${name}`);
-    }
-    if (sub === 'delete') {
-        const R = Rooms.roomIn(H, arg ?? opt(o, 'room'));
-        if (!flag(o, 'yes'))
-            fail(`deleting ${R.name} in hub ${H.name} erases it and everything kept for it, for good. Run again with --yes, or archive it instead`);
-        Rooms.erase(H, R);
-        return out(`deleted room ${R.name}: its branch, signals, pins, evidence and readers' state. Sessions bound to it leave it on their next turn`);
-    }
-    if (sub === 'rebase-contract') {
-        const R = Rooms.roomIn(H, arg ?? fail('usage: ringi room rebase-contract <id>'));
-        Rooms.rebase(H, R);
-        return out(`room ${R.name} now follows the hub contract at ${short(H.main)} (${H.contract.version})`);
-    }
-    fail(`unknown: room ${sub}`);
-};
-//# sourceMappingURL=operator.js.map