@botcord/daemon 0.1.1

package/dist/gateway/dispatcher.js

@@ -0,0 +1,431 @@
+import { resolveRoute } from "./router.js";
+import { sessionKey } from "./session-store.js";
+const DEFAULT_TURN_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Gateway dispatcher: consumes `GatewayInboundEnvelope` and drives a runtime
+ * turn per message, respecting queue mode, trust level, streaming, and
+ * session persistence rules from the plan (§7/§9/§10/§11/§12/§13).
+ *
+ * Deliberate deviation from daemon: this core does NOT wrap inbound text in
+ * BotCord-style XML envelopes for untrusted content. The channel adapter is
+ * responsible for any channel-specific sanitization; the dispatcher passes
+ * `message.text` through to the runtime as-is (plan §15).
+ */
+export class Dispatcher {
+    config;
+    channels;
+    runtimeFactory;
+    sessionStore;
+    log;
+    turnTimeoutMs;
+    buildSystemContext;
+    onInbound;
+    composeUserTurn;
+    managedRoutes;
+    queues = new Map();
+    constructor(opts) {
+        this.config = opts.config;
+        this.channels = opts.channels;
+        this.runtimeFactory = opts.runtime;
+        this.sessionStore = opts.sessionStore;
+        this.log = opts.log;
+        this.turnTimeoutMs = opts.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
+        this.buildSystemContext = opts.buildSystemContext;
+        this.onInbound = opts.onInbound;
+        this.composeUserTurn = opts.composeUserTurn;
+        this.managedRoutes = opts.managedRoutes;
+    }
+    /** Consume one inbound envelope, ack it once ownership is decided, then run its turn. */
+    async handle(envelope) {
+        const msg = envelope.message;
+        // Skip rule: empty/whitespace text.
+        const rawText = typeof msg.text === "string" ? msg.text.trim() : "";
+        if (!rawText) {
+            this.log.debug("dispatcher skip: empty text", { messageId: msg.id });
+            await this.safeAck(envelope);
+            return;
+        }
+        // Skip rule: echo from the agent itself (own agent output looped back).
+        // Owner/human messages in dashboard rooms share the agent's id as sender.id
+        // but carry sender.kind === "user", so we only skip when kind === "agent".
+        if (msg.sender.id === msg.accountId && msg.sender.kind === "agent") {
+            this.log.debug("dispatcher skip: own message", { messageId: msg.id });
+            await this.safeAck(envelope);
+            return;
+        }
+        // Compose the final user-turn text. The composer can enrich the raw
+        // message with sender label, room header, NO_REPLY hint, etc. — anything
+        // that should land in the runtime transcript. Failures fall back to the
+        // raw trimmed text so a buggy composer cannot drop turns.
+        let text = rawText;
+        if (this.composeUserTurn) {
+            try {
+                const composed = this.composeUserTurn(msg);
+                if (typeof composed === "string" && composed.length > 0) {
+                    text = composed;
+                }
+            }
+            catch (err) {
+                this.log.warn("dispatcher: composeUserTurn threw — using raw text", {
+                    messageId: msg.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        const managed = this.managedRoutes ? Array.from(this.managedRoutes.values()) : undefined;
+        const route = resolveRoute(msg, this.config, managed);
+        const mode = resolveQueueMode(route, msg.conversation.kind);
+        const queueKey = buildQueueKey(msg);
+        // Ack immediately: once the dispatcher has a route + queue key, ownership is decided.
+        await this.safeAck(envelope);
+        // Notify the optional observer (activity tracking, metrics, etc.) as soon
+        // as the dispatcher owns the message. Errors must not abort the turn.
+        if (this.onInbound) {
+            try {
+                await this.onInbound(msg);
+            }
+            catch (err) {
+                this.log.warn("dispatcher: onInbound threw — continuing", {
+                    messageId: msg.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        const channel = this.channels.get(msg.channel);
+        if (!channel) {
+            this.log.warn("dispatcher: unknown channel for outbound reply", {
+                channel: msg.channel,
+                messageId: msg.id,
+            });
+            return;
+        }
+        if (mode === "cancel-previous") {
+            await this.runCancelPrevious(queueKey, route, text, msg, channel);
+        }
+        else {
+            await this.runSerial(queueKey, route, text, msg, channel);
+        }
+    }
+    /** Snapshot of currently running turns keyed by queue key. */
+    turns() {
+        const out = {};
+        for (const [key, q] of this.queues) {
+            if (q.current)
+                out[key] = { ...q.current.snapshot };
+        }
+        return out;
+    }
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+    async safeAck(env) {
+        const accept = env.ack?.accept;
+        if (!accept)
+            return;
+        try {
+            await accept.call(env.ack);
+        }
+        catch (err) {
+            this.log.warn("dispatcher: ack.accept failed", {
+                messageId: env.message.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    getQueue(key) {
+        let q = this.queues.get(key);
+        if (!q) {
+            q = {
+                current: null,
+                tail: Promise.resolve(),
+                cancelGen: 0,
+            };
+            this.queues.set(key, q);
+        }
+        return q;
+    }
+    async runCancelPrevious(queueKey, route, text, msg, channel) {
+        const q = this.getQueue(queueKey);
+        // Bump the generation on every arrival. Older arrivals still awaiting
+        // the prior turn's teardown will observe `myGen !== q.cancelGen` when
+        // they resume and drop out, so only the newest message reaches runTurn.
+        q.cancelGen += 1;
+        const myGen = q.cancelGen;
+        const prev = q.current;
+        if (prev) {
+            this.log.info("dispatcher: cancelling previous turn", { queueKey });
+            prev.controller.abort();
+            // Wait for it to finish cleanup (it won't reply, won't persist).
+            await prev.done.catch(() => undefined);
+        }
+        // After the await, a newer cancel-previous may have arrived and either
+        // already fired its own abort + runTurn, or be mid-await itself. If so,
+        // drop out silently — the newest turn is the only one that should run.
+        if (myGen !== q.cancelGen) {
+            this.log.info("dispatcher: cancel-previous superseded", { queueKey });
+            return;
+        }
+        await this.runTurn(queueKey, route, text, msg, channel);
+    }
+    async runSerial(queueKey, route, text, msg, channel) {
+        const q = this.getQueue(queueKey);
+        const prev = q.tail;
+        const next = prev.then(() => this.runTurn(queueKey, route, text, msg, channel));
+        q.tail = next.catch(() => undefined);
+        return next;
+    }
+    async runTurn(queueKey, route, text, msg, channel) {
+        const q = this.getQueue(queueKey);
+        const controller = new AbortController();
+        const startedAt = Date.now();
+        const snapshot = {
+            key: queueKey,
+            channel: msg.channel,
+            accountId: msg.accountId,
+            conversationId: msg.conversation.id,
+            runtime: route.runtime,
+            cwd: route.cwd,
+            startedAt,
+        };
+        let resolveDone;
+        const done = new Promise((res) => {
+            resolveDone = res;
+        });
+        const slot = { controller, timedOut: false, snapshot, done };
+        q.current = slot;
+        // Hard-cap turn with a timeout.
+        const timer = setTimeout(() => {
+            slot.timedOut = true;
+            this.log.warn("dispatcher: turn timed out", {
+                queueKey,
+                timeoutMs: this.turnTimeoutMs,
+            });
+            controller.abort();
+        }, this.turnTimeoutMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        const key = sessionKey({
+            runtime: route.runtime,
+            channel: msg.channel,
+            accountId: msg.accountId,
+            conversationKind: msg.conversation.kind,
+            conversationId: msg.conversation.id,
+            threadId: msg.conversation.threadId ?? null,
+        });
+        const entry = this.sessionStore.get(key);
+        const sessionId = entry?.runtimeSessionId ?? null;
+        const trustLevel = route.trustLevel ?? "trusted";
+        const streamable = msg.trace?.streamable === true;
+        const traceId = msg.trace?.id;
+        const canStream = streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
+        const onBlock = canStream
+            ? (block) => {
+                // Fire-and-forget: stream errors must not break the turn.
+                channel
+                    .streamBlock({
+                    traceId: traceId,
+                    accountId: msg.accountId,
+                    conversationId: msg.conversation.id,
+                    block,
+                    log: this.log,
+                })
+                    .catch((err) => {
+                    this.log.warn("dispatcher: streamBlock failed", {
+                        traceId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
+            }
+            : undefined;
+        // Compute systemContext right before dispatch. The builder must NOT block
+        // the turn on failure — log and continue so a flaky memory read can't
+        // silence the agent.
+        let systemContext;
+        if (this.buildSystemContext) {
+            try {
+                const result = await this.buildSystemContext(msg);
+                if (typeof result === "string" && result.length > 0) {
+                    systemContext = result;
+                }
+            }
+            catch (err) {
+                this.log.warn("buildSystemContext threw — continuing without systemContext", {
+                    error: err instanceof Error ? err.message : String(err),
+                    messageId: msg.id,
+                });
+            }
+        }
+        const runtime = this.runtimeFactory(route.runtime, route.extraArgs);
+        let result;
+        let threw;
+        try {
+            try {
+                result = await runtime.run({
+                    text,
+                    sessionId,
+                    cwd: route.cwd,
+                    accountId: msg.accountId,
+                    extraArgs: route.extraArgs,
+                    signal: controller.signal,
+                    trustLevel,
+                    systemContext,
+                    onBlock,
+                });
+            }
+            catch (err) {
+                threw = err;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            // Re-check the abort signal AFTER runtime.run resolves but BEFORE any
+            // side effects (session write, reply send). This closes the race where
+            // a cancel-previous arrives between runtime.run resolving and the
+            // post-runtime block running: keeping `q.current` pointing at this slot
+            // until after the reply lets the new arrival trip our abort signal, and
+            // this check then drops us silently. Timed-out turns still fall through
+            // to send their error reply.
+            if (controller.signal.aborted && !slot.timedOut) {
+                return;
+            }
+            if (slot.timedOut) {
+                await this.sendReply(channel, {
+                    channel: msg.channel,
+                    accountId: msg.accountId,
+                    conversationId: msg.conversation.id,
+                    threadId: msg.conversation.threadId ?? null,
+                    text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
+                    replyTo: msg.id,
+                    traceId: msg.trace?.id ?? null,
+                });
+                return;
+            }
+            if (threw) {
+                this.log.error("dispatcher: runtime threw", {
+                    queueKey,
+                    runtime: route.runtime,
+                    error: threw instanceof Error ? threw.message : String(threw),
+                });
+                const shortMsg = threw instanceof Error ? threw.message : String(threw);
+                await this.sendReply(channel, {
+                    channel: msg.channel,
+                    accountId: msg.accountId,
+                    conversationId: msg.conversation.id,
+                    threadId: msg.conversation.threadId ?? null,
+                    text: `⚠️ Runtime error: ${truncate(shortMsg, 500)}`,
+                    replyTo: msg.id,
+                    traceId: msg.trace?.id ?? null,
+                });
+                return;
+            }
+            if (!result)
+                return;
+            // Persist session before reply so next turn sees the new id even if send fails.
+            //
+            // Adapter contract:
+            //   result.newSessionId truthy  → upsert the entry
+            //   result.newSessionId empty + had-inbound-sessionId + result.error
+            //                               → the prior session is dead (e.g. Claude Code
+            //                                 "--resume <missing-uuid>"); delete the entry so
+            //                                 we don't keep resuming a stale id every turn
+            //   otherwise                   → no-op (e.g. codex intentionally never persists)
+            if (result.newSessionId) {
+                const session = {
+                    key,
+                    runtime: route.runtime,
+                    runtimeSessionId: result.newSessionId,
+                    channel: msg.channel,
+                    accountId: msg.accountId,
+                    conversationKind: msg.conversation.kind,
+                    conversationId: msg.conversation.id,
+                    threadId: msg.conversation.threadId ?? null,
+                    cwd: route.cwd,
+                    updatedAt: Date.now(),
+                };
+                try {
+                    const prevRuntimeSessionId = sessionId;
+                    await this.sessionStore.set(session);
+                    this.log.debug("dispatcher: persisted runtime session", {
+                        key,
+                        prevRuntimeSessionId,
+                        nextRuntimeSessionId: result.newSessionId,
+                    });
+                }
+                catch (err) {
+                    this.log.warn("dispatcher: session-store.set failed", {
+                        key,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            else if (sessionId && result.error) {
+                try {
+                    await this.sessionStore.delete(key);
+                    this.log.info("dispatcher: dropped stale runtime session", {
+                        key,
+                        prevRuntimeSessionId: sessionId,
+                        error: result.error,
+                    });
+                }
+                catch (err) {
+                    this.log.warn("dispatcher: session-store.delete failed", {
+                        key,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            const replyText = (result.text || "").trim();
+            if (!replyText)
+                return;
+            // One last abort check immediately before the send. Narrows the window
+            // in which a cancel-previous arriving during session-store.set could
+            // still slip a stale reply past us.
+            if (controller.signal.aborted && !slot.timedOut) {
+                return;
+            }
+            await this.sendReply(channel, {
+                channel: msg.channel,
+                accountId: msg.accountId,
+                conversationId: msg.conversation.id,
+                threadId: msg.conversation.threadId ?? null,
+                text: replyText,
+                replyTo: msg.id,
+                traceId: msg.trace?.id ?? null,
+            });
+        }
+        finally {
+            // Clear slot ownership AFTER the reply has been sent (or skipped).
+            // Only then do cancel-previous arrivals stop finding this slot — which
+            // is exactly what we want: while we're in the post-runtime window, a
+            // newer arrival should find `q.current === slot`, call `abort()`, and
+            // let our abort-checks above drop this turn silently.
+            if (q.current === slot)
+                q.current = null;
+            resolveDone();
+        }
+    }
+    async sendReply(channel, outbound) {
+        try {
+            await channel.send({ message: outbound, log: this.log });
+        }
+        catch (err) {
+            this.log.warn("dispatcher: channel.send failed", {
+                channel: outbound.channel,
+                conversationId: outbound.conversationId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+function buildQueueKey(msg) {
+    const thread = msg.conversation.threadId ?? "";
+    return `${msg.channel}:${msg.accountId}:${msg.conversation.id}:${thread}`;
+}
+function resolveQueueMode(route, kind) {
+    if (route.queueMode)
+        return route.queueMode;
+    return kind === "direct" ? "cancel-previous" : "serial";
+}
+function truncate(s, max) {
+    return s.length <= max ? s : s.slice(0, max) + "…";
+}

package/dist/gateway/gateway.d.ts

@@ -0,0 +1,87 @@
+import { type ChannelBackoffOptions } from "./channel-manager.js";
+import { type RuntimeFactory } from "./dispatcher.js";
+import { type GatewayLogger } from "./log.js";
+import type { ChannelAdapter, GatewayChannelConfig, GatewayConfig, GatewayRoute, GatewayRuntimeSnapshot, InboundObserver, SystemContextBuilder, UserTurnBuilder } from "./types.js";
+/** Constructor options for `Gateway`. */
+export interface GatewayBootOptions {
+    config: GatewayConfig;
+    sessionStorePath: string;
+    /** Max age for persisted runtime session entries. Defaults to 30 days. */
+    sessionStoreMaxEntryAgeMs?: number;
+    createChannel: (cfg: GatewayChannelConfig) => ChannelAdapter;
+    createRuntime?: RuntimeFactory;
+    log?: GatewayLogger;
+    turnTimeoutMs?: number;
+    backoffMs?: ChannelBackoffOptions;
+    /**
+     * Hook that composes per-turn system context (working memory, cross-room
+     * digest, etc.). Forwarded to the dispatcher; errors are logged and do not
+     * abort the turn.
+     */
+    buildSystemContext?: SystemContextBuilder;
+    /**
+     * Observer called after the dispatcher acks each inbound message. Useful
+     * for activity tracking or metrics. Errors are logged and swallowed.
+     */
+    onInbound?: InboundObserver;
+    /**
+     * Optional composer that wraps the user-turn text with channel-specific
+     * metadata (sender label, room header, NO_REPLY hint…) before it is handed
+     * to the runtime. Forwarded to the dispatcher; see {@link UserTurnBuilder}.
+     */
+    composeUserTurn?: UserTurnBuilder;
+}
+/**
+ * Top-level gateway bootstrap. Wires `ChannelManager` → `Dispatcher` →
+ * `SessionStore` + runtime factory. Channel adapters are constructed from
+ * `opts.createChannel` per `config.channels[]` entry and keyed by adapter id.
+ */
+export declare class Gateway {
+    private readonly config;
+    private readonly log;
+    private readonly sessionStore;
+    private readonly dispatcher;
+    private readonly channelManager;
+    private readonly channelMap;
+    private readonly createChannelFn;
+    private readonly managedRoutes;
+    private started;
+    private stopped;
+    constructor(opts: GatewayBootOptions);
+    /** Load persisted sessions and start every configured channel. */
+    start(): Promise<void>;
+    /** Tear down every channel; idempotent. */
+    stop(reason?: string): Promise<void>;
+    /** Aggregate status snapshot combining channel and turn state. */
+    snapshot(): GatewayRuntimeSnapshot;
+    /**
+     * Read-only view of the synthesized per-agent routes. Exposed for
+     * snapshot/debug callers and tests; matching reads the live internal map.
+     */
+    listManagedRoutes(): GatewayRoute[];
+    /** Replace all managed routes atomically. Used by `reload_config`. */
+    replaceManagedRoutes(routes: Map<string, GatewayRoute>): void;
+    /** Add or update one managed route. Used by provision hot-add. */
+    upsertManagedRoute(accountId: string, route: GatewayRoute): void;
+    /** Drop one managed route. Used by revoke / removeChannel. */
+    removeManagedRoute(accountId: string): void;
+    /**
+     * Hot-plug a new channel without restarting the gateway. The daemon's
+     * control plane calls this after a `provision_agent` frame: it has already
+     * written the new agent's credentials to disk and updated `config.json`,
+     * and now needs the channel to come online without tearing down peers.
+     *
+     * The caller supplies a fully-constructed `GatewayChannelConfig` entry;
+     * `createChannel` (from the original `GatewayBootOptions`) is invoked to
+     * build the adapter. The config entry is appended to `config.channels`
+     * so status/router lookups see it; it is otherwise a pure in-memory op.
+     */
+    addChannel(cfg: GatewayChannelConfig): Promise<void>;
+    /**
+     * Remove a channel registered earlier (either at boot or via
+     * `addChannel`). Aborts the running turn loop, awaits the adapter's
+     * `stop()`, drops the entry from the channel map and config.channels.
+     * No-op on unknown id.
+     */
+    removeChannel(id: string, reason?: string): Promise<void>;
+}

package/dist/gateway/gateway.js

@@ -0,0 +1,158 @@
+import { ChannelManager } from "./channel-manager.js";
+import { Dispatcher } from "./dispatcher.js";
+import { consoleLogger } from "./log.js";
+import { createRuntime } from "./runtimes/registry.js";
+import { DEFAULT_SESSION_STORE_MAX_ENTRY_AGE_MS, SessionStore } from "./session-store.js";
+/** Default runtime factory: delegates to the built-in registry; ignores extraArgs at construction. */
+const defaultRuntimeFactory = (runtimeId) => createRuntime(runtimeId);
+/**
+ * Top-level gateway bootstrap. Wires `ChannelManager` → `Dispatcher` →
+ * `SessionStore` + runtime factory. Channel adapters are constructed from
+ * `opts.createChannel` per `config.channels[]` entry and keyed by adapter id.
+ */
+export class Gateway {
+    config;
+    log;
+    sessionStore;
+    dispatcher;
+    channelManager;
+    channelMap;
+    createChannelFn;
+    managedRoutes = new Map();
+    started = false;
+    stopped = false;
+    constructor(opts) {
+        this.config = opts.config;
+        this.log = opts.log ?? consoleLogger;
+        this.createChannelFn = opts.createChannel;
+        this.channelMap = new Map();
+        const channelList = [];
+        for (const cfg of opts.config.channels) {
+            const adapter = opts.createChannel(cfg);
+            this.channelMap.set(adapter.id, adapter);
+            channelList.push(adapter);
+        }
+        for (const route of opts.config.managedRoutes ?? []) {
+            const id = route.match?.accountId;
+            if (typeof id === "string") {
+                this.managedRoutes.set(id, route);
+            }
+            else {
+                // Defensive: buildManagedRoutes always sets match.accountId, so
+                // reaching here means a caller constructed GatewayConfig directly
+                // with a malformed entry. Log so it's not silently dropped.
+                this.log.warn("gateway: dropping seed managed route with no accountId", {
+                    runtime: route.runtime,
+                    cwd: route.cwd,
+                });
+            }
+        }
+        this.sessionStore = new SessionStore({
+            path: opts.sessionStorePath,
+            log: this.log,
+            maxEntryAgeMs: opts.sessionStoreMaxEntryAgeMs ?? DEFAULT_SESSION_STORE_MAX_ENTRY_AGE_MS,
+        });
+        const runtimeFactory = opts.createRuntime ?? defaultRuntimeFactory;
+        this.dispatcher = new Dispatcher({
+            config: this.config,
+            channels: this.channelMap,
+            runtime: runtimeFactory,
+            sessionStore: this.sessionStore,
+            log: this.log,
+            turnTimeoutMs: opts.turnTimeoutMs,
+            buildSystemContext: opts.buildSystemContext,
+            onInbound: opts.onInbound,
+            composeUserTurn: opts.composeUserTurn,
+            managedRoutes: this.managedRoutes,
+        });
+        this.channelManager = new ChannelManager({
+            config: this.config,
+            channels: channelList,
+            log: this.log,
+            emit: (env) => this.dispatcher.handle(env),
+            backoffMs: opts.backoffMs,
+        });
+    }
+    /** Load persisted sessions and start every configured channel. */
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        await this.sessionStore.load();
+        await this.channelManager.startAll();
+    }
+    /** Tear down every channel; idempotent. */
+    async stop(reason) {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        await this.channelManager.stopAll(reason);
+    }
+    /** Aggregate status snapshot combining channel and turn state. */
+    snapshot() {
+        return {
+            channels: this.channelManager.status(),
+            turns: this.dispatcher.turns(),
+        };
+    }
+    /**
+     * Read-only view of the synthesized per-agent routes. Exposed for
+     * snapshot/debug callers and tests; matching reads the live internal map.
+     */
+    listManagedRoutes() {
+        return Array.from(this.managedRoutes.values());
+    }
+    /** Replace all managed routes atomically. Used by `reload_config`. */
+    replaceManagedRoutes(routes) {
+        this.managedRoutes.clear();
+        for (const [id, route] of routes) {
+            this.managedRoutes.set(id, route);
+        }
+    }
+    /** Add or update one managed route. Used by provision hot-add. */
+    upsertManagedRoute(accountId, route) {
+        this.managedRoutes.set(accountId, route);
+    }
+    /** Drop one managed route. Used by revoke / removeChannel. */
+    removeManagedRoute(accountId) {
+        this.managedRoutes.delete(accountId);
+    }
+    /**
+     * Hot-plug a new channel without restarting the gateway. The daemon's
+     * control plane calls this after a `provision_agent` frame: it has already
+     * written the new agent's credentials to disk and updated `config.json`,
+     * and now needs the channel to come online without tearing down peers.
+     *
+     * The caller supplies a fully-constructed `GatewayChannelConfig` entry;
+     * `createChannel` (from the original `GatewayBootOptions`) is invoked to
+     * build the adapter. The config entry is appended to `config.channels`
+     * so status/router lookups see it; it is otherwise a pure in-memory op.
+     */
+    async addChannel(cfg) {
+        if (this.stopped) {
+            throw new Error("gateway already stopped");
+        }
+        if (this.channelMap.has(cfg.id)) {
+            throw new Error(`channel "${cfg.id}" already registered`);
+        }
+        this.config.channels.push(cfg);
+        const adapter = this.createChannelFn(cfg);
+        this.channelMap.set(adapter.id, adapter);
+        this.channelManager.addOne(adapter);
+    }
+    /**
+     * Remove a channel registered earlier (either at boot or via
+     * `addChannel`). Aborts the running turn loop, awaits the adapter's
+     * `stop()`, drops the entry from the channel map and config.channels.
+     * No-op on unknown id.
+     */
+    async removeChannel(id, reason) {
+        if (!this.channelMap.has(id))
+            return;
+        await this.channelManager.removeOne(id, reason);
+        this.channelMap.delete(id);
+        const idx = this.config.channels.findIndex((c) => c.id === id);
+        if (idx >= 0)
+            this.config.channels.splice(idx, 1);
+    }
+}

package/dist/gateway/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types.js";
+export * from "./log.js";
+export * from "./runtimes/registry.js";
+export * from "./channels/index.js";
+export { sanitizeUntrustedContent, sanitizeSenderName } from "./channels/sanitize.js";
+export { sessionKey, SessionStore, type SessionStoreOptions } from "./session-store.js";
+export { resolveRoute, matchesRoute } from "./router.js";
+export { ChannelManager, type ChannelManagerOptions, type ChannelBackoffOptions } from "./channel-manager.js";
+export { Dispatcher, type DispatcherOptions, type RuntimeFactory } from "./dispatcher.js";
+export { Gateway, type GatewayBootOptions } from "./gateway.js";
+export { ClaudeCodeAdapter, probeClaude, resolveClaudeCommand, } from "./runtimes/claude-code.js";
+export { CodexAdapter, probeCodex, resolveCodexCommand } from "./runtimes/codex.js";
+export { GeminiAdapter, probeGemini, resolveGeminiCommand } from "./runtimes/gemini.js";
+export { NdjsonStreamAdapter, type NdjsonEventCtx, type NdjsonRunState, } from "./runtimes/ndjson-stream.js";
+export { firstExistingPath, readCommandVersion, resolveCommandOnPath, resolveHomePath, type ProbeDeps, } from "./runtimes/probe.js";