@a5c-ai/genty-platform 5.1.1-staging.583e3d9a6ed7

package/dist/mcp/channels/allowlist.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Channel Allowlist.
+ *
+ * Controls which MCP channels are active. Channels require explicit opt-in.
+ * Uses atomic write pattern consistent with other SDK state modules.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelAllowlistPath = getChannelAllowlistPath;
+exports.readChannelAllowlist = readChannelAllowlist;
+exports.writeChannelAllowlist = writeChannelAllowlist;
+exports.upsertChannel = upsertChannel;
+exports.removeChannel = removeChannel;
+exports.toggleChannel = toggleChannel;
+exports.getEnabledChannels = getEnabledChannels;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const atomic_1 = require("../../storage/atomic");
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function emptyAllowlist() {
+    return { schemaVersion: types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION, channels: [] };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getChannelAllowlistPath(stateDir) {
+    return path.join(stateDir, "channel-allowlist.json");
+}
+async function readChannelAllowlist(stateDir) {
+    const filePath = getChannelAllowlistPath(stateDir);
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyAllowlist();
+        throw error;
+    }
+    try {
+        const data = JSON.parse(raw);
+        const rawChannels = Array.isArray(data.channels) ? data.channels : [];
+        const validChannels = rawChannels.filter((c) => {
+            if (typeof c !== "object" || c === null)
+                return false;
+            const obj = c;
+            return (typeof obj.serverName === "string" &&
+                typeof obj.channelId === "string" &&
+                typeof obj.enabled === "boolean");
+        });
+        return {
+            schemaVersion: typeof data.schemaVersion === "string" ? data.schemaVersion : types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION,
+            channels: validChannels,
+        };
+    }
+    catch {
+        return emptyAllowlist();
+    }
+}
+async function writeChannelAllowlist(stateDir, allowlist) {
+    const filePath = getChannelAllowlistPath(stateDir);
+    await (0, atomic_1.writeFileAtomic)(filePath, JSON.stringify(allowlist, null, 2));
+}
+/** Add or update a channel in the allowlist. */
+async function upsertChannel(stateDir, channel) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${channel.serverName}:${channel.channelId}`;
+    const idx = allowlist.channels.findIndex((c) => `${c.serverName}:${c.channelId}` === key);
+    if (idx >= 0) {
+        allowlist.channels[idx] = channel;
+    }
+    else {
+        allowlist.channels.push(channel);
+    }
+    await writeChannelAllowlist(stateDir, allowlist);
+    return allowlist;
+}
+/** Remove a channel from the allowlist. Returns true if removed. */
+async function removeChannel(stateDir, serverName, channelId) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${serverName}:${channelId}`;
+    const before = allowlist.channels.length;
+    allowlist.channels = allowlist.channels.filter((c) => `${c.serverName}:${c.channelId}` !== key);
+    if (allowlist.channels.length === before)
+        return false;
+    await writeChannelAllowlist(stateDir, allowlist);
+    return true;
+}
+/** Toggle a channel's enabled state. Returns the new enabled state. */
+async function toggleChannel(stateDir, serverName, channelId, enabled) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${serverName}:${channelId}`;
+    const channel = allowlist.channels.find((c) => `${c.serverName}:${c.channelId}` === key);
+    if (!channel)
+        return undefined;
+    channel.enabled = enabled ?? !channel.enabled;
+    await writeChannelAllowlist(stateDir, allowlist);
+    return channel.enabled;
+}
+/** Get all enabled channels. */
+function getEnabledChannels(allowlist) {
+    return allowlist.channels.filter((c) => c.enabled);
+}

package/dist/mcp/channels/channelManager.d.ts

@@ -0,0 +1,64 @@
+/**
+ * GAP-MCPC-001: Channel Manager.
+ *
+ * Detects channel capability on connected MCP servers and manages
+ * channel bindings. Integrates with McpClientManager and InboundMessageQueue.
+ */
+import type { ChannelCapability, ChannelConfig, ChannelMessage } from "./types";
+import type { McpClientManager } from "../client/manager";
+import { InboundMessageQueue, type WakeCallback } from "./inboundQueue";
+export interface ChannelManagerOptions {
+    /** State directory for reading allowlist. */
+    stateDir: string;
+    /** MCP client manager for server connections. */
+    clientManager: McpClientManager;
+    /** Wake callback for sleeping runs. */
+    onWake?: WakeCallback;
+    /** Maximum inbound queue size per run. */
+    maxQueueSize?: number;
+}
+/** Detected channel server. */
+export interface DetectedChannel {
+    serverName: string;
+    capability: ChannelCapability;
+}
+export declare class ChannelManager {
+    private readonly _stateDir;
+    private readonly _clientManager;
+    private readonly _queue;
+    private readonly _detectedChannels;
+    constructor(options: ChannelManagerOptions);
+    /**
+     * Detect channel capability on connected MCP servers.
+     * A server declares channel capability by exposing tools matching
+     * known channel patterns (e.g. slack_send_message, gmail_create_draft).
+     */
+    detectChannels(): Promise<DetectedChannel[]>;
+    /** Get detected channel capabilities. */
+    getDetectedChannels(): DetectedChannel[];
+    /** Check if a server has channel capability. */
+    hasChannelCapability(serverName: string): boolean;
+    /**
+     * Process an inbound channel message.
+     * Routes to bound run and queues for retrieval.
+     */
+    processInboundMessage(message: ChannelMessage): void;
+    /** Bind a channel to a run for message routing. */
+    bindChannelToRun(channelSource: string, runId: string): void;
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource: string): void;
+    /** Get messages for a run. */
+    getMessages(runId: string, limit?: number): ChannelMessage[];
+    /** Dequeue messages for a run. */
+    consumeMessages(runId: string, limit?: number): ChannelMessage[];
+    /** Check if a run has pending messages. */
+    hasMessages(runId: string): boolean;
+    /**
+     * Load enabled channels from the allowlist.
+     * Returns configs for channels that are both allowed and connected.
+     */
+    getActiveChannels(): Promise<ChannelConfig[]>;
+    /** Access the underlying queue (for advanced use). */
+    get queue(): InboundMessageQueue;
+}
+//# sourceMappingURL=channelManager.d.ts.map

package/dist/mcp/channels/channelManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelManager.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/channelManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACf,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAUxE,MAAM,WAAW,qBAAqB;IACpC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,aAAa,EAAE,gBAAgB,CAAC;IAChC,uCAAuC;IACvC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,+BAA+B;AAC/B,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAMD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwC;gBAE9D,OAAO,EAAE,qBAAqB;IAS1C;;;;OAIG;IACG,cAAc,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAuClD,yCAAyC;IACzC,mBAAmB,IAAI,eAAe,EAAE;IAOxC,gDAAgD;IAChD,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIjD;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIpD,mDAAmD;IACnD,gBAAgB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5D,qCAAqC;IACrC,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI1C,8BAA8B;IAC9B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAIxD,kCAAkC;IAClC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAI5D,2CAA2C;IAC3C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAYnD,sDAAsD;IACtD,IAAI,KAAK,IAAI,mBAAmB,CAE/B;CACF"}

package/dist/mcp/channels/channelManager.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Channel Manager.
+ *
+ * Detects channel capability on connected MCP servers and manages
+ * channel bindings. Integrates with McpClientManager and InboundMessageQueue.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+const inboundQueue_1 = require("./inboundQueue");
+const allowlist_1 = require("./allowlist");
+// ---------------------------------------------------------------------------
+// ChannelManager
+// ---------------------------------------------------------------------------
+class ChannelManager {
+    _stateDir;
+    _clientManager;
+    _queue;
+    _detectedChannels = new Map();
+    constructor(options) {
+        this._stateDir = options.stateDir;
+        this._clientManager = options.clientManager;
+        this._queue = new inboundQueue_1.InboundMessageQueue({
+            maxQueueSize: options.maxQueueSize,
+            onWake: options.onWake,
+        });
+    }
+    /**
+     * Detect channel capability on connected MCP servers.
+     * A server declares channel capability by exposing tools matching
+     * known channel patterns (e.g. slack_send_message, gmail_create_draft).
+     */
+    async detectChannels() {
+        const connections = this._clientManager.listConnections();
+        const detected = [];
+        for (const conn of connections) {
+            if (conn.status !== "connected")
+                continue;
+            try {
+                const tools = await this._clientManager.listTools(conn.name);
+                const toolNames = tools.map((t) => t.name);
+                const channelType = inferChannelType(toolNames);
+                // Only consider servers that match a known channel type
+                if (!channelType)
+                    continue;
+                const capability = {
+                    inbound: toolNames.some((n) => n.includes("read_channel") || n.includes("read_message") || n.includes("read_thread")),
+                    outbound: toolNames.some((n) => n.includes("send_message") || n.includes("create_draft")),
+                    permissionRelay: false,
+                    channelType,
+                };
+                if (capability.inbound || capability.outbound) {
+                    this._detectedChannels.set(conn.name, capability);
+                    detected.push({ serverName: conn.name, capability });
+                }
+            }
+            catch {
+                // Skip servers that fail to list tools
+            }
+        }
+        return detected;
+    }
+    /** Get detected channel capabilities. */
+    getDetectedChannels() {
+        return [...this._detectedChannels.entries()].map(([serverName, capability]) => ({
+            serverName,
+            capability,
+        }));
+    }
+    /** Check if a server has channel capability. */
+    hasChannelCapability(serverName) {
+        return this._detectedChannels.has(serverName);
+    }
+    /**
+     * Process an inbound channel message.
+     * Routes to bound run and queues for retrieval.
+     */
+    processInboundMessage(message) {
+        this._queue.enqueue(message);
+    }
+    /** Bind a channel to a run for message routing. */
+    bindChannelToRun(channelSource, runId) {
+        this._queue.bindChannel(channelSource, runId);
+    }
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource) {
+        this._queue.unbindChannel(channelSource);
+    }
+    /** Get messages for a run. */
+    getMessages(runId, limit = 10) {
+        return this._queue.peek(runId, limit);
+    }
+    /** Dequeue messages for a run. */
+    consumeMessages(runId, limit = 10) {
+        return this._queue.dequeue(runId, limit);
+    }
+    /** Check if a run has pending messages. */
+    hasMessages(runId) {
+        return this._queue.hasMessages(runId);
+    }
+    /**
+     * Load enabled channels from the allowlist.
+     * Returns configs for channels that are both allowed and connected.
+     */
+    async getActiveChannels() {
+        const allowlist = await (0, allowlist_1.readChannelAllowlist)(this._stateDir);
+        const enabled = (0, allowlist_1.getEnabledChannels)(allowlist);
+        const connected = new Set(this._clientManager
+            .listConnections()
+            .filter((c) => c.status === "connected")
+            .map((c) => c.name));
+        return enabled.filter((c) => connected.has(c.serverName));
+    }
+    /** Access the underlying queue (for advanced use). */
+    get queue() {
+        return this._queue;
+    }
+}
+exports.ChannelManager = ChannelManager;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Infer channel type from tool name prefixes. */
+function inferChannelType(toolNames) {
+    const hasPrefix = (prefix) => toolNames.some((n) => n.startsWith(prefix));
+    if (hasPrefix("slack_"))
+        return "slack";
+    if (hasPrefix("discord_"))
+        return "discord";
+    if (hasPrefix("gmail_") || hasPrefix("email_"))
+        return "email";
+    if (hasPrefix("telegram_"))
+        return "telegram";
+    if (hasPrefix("teams_"))
+        return "teams";
+    return undefined;
+}

package/dist/mcp/channels/inboundQueue.d.ts

@@ -0,0 +1,47 @@
+/**
+ * GAP-MCPC-001: Inbound Message Queue.
+ *
+ * Stores inbound channel messages in-memory and provides wake-up
+ * triggers for sleeping runs. Messages do not survive process restarts.
+ */
+import type { ChannelMessage, ChannelBinding } from "./types";
+export type WakeCallback = (runId: string, message: ChannelMessage) => void;
+export interface InboundQueueOptions {
+    /** Maximum messages to buffer per run before dropping oldest. */
+    maxQueueSize?: number;
+    /** Callback fired when a bound run receives a message (for wake-up). */
+    onWake?: WakeCallback;
+}
+export declare class InboundMessageQueue {
+    private readonly _queues;
+    private readonly _bindings;
+    private readonly _maxQueueSize;
+    private readonly _onWake;
+    constructor(options?: InboundQueueOptions);
+    /** Bind a channel to a run for message routing. */
+    bindChannel(channelSource: string, runId: string): void;
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource: string): void;
+    /** Get the run ID a channel is bound to (if any). */
+    getBoundRunId(channelSource: string): string | undefined;
+    /** Get all active bindings. */
+    getBindings(): ChannelBinding[];
+    /**
+     * Enqueue an inbound message. Routes to bound run if one exists.
+     * Fires the wake callback if a binding exists.
+     */
+    enqueue(message: ChannelMessage): void;
+    /** Peek at messages for a run (does not remove). */
+    peek(runId: string, limit?: number): ChannelMessage[];
+    /** Dequeue (remove and return) messages for a run. */
+    dequeue(runId: string, limit?: number): ChannelMessage[];
+    /** Get the number of queued messages for a run. */
+    queueSize(runId: string): number;
+    /** Check if there are any messages for a run. */
+    hasMessages(runId: string): boolean;
+    /** Get unbound messages (not routed to any run). */
+    getUnboundMessages(limit?: number): ChannelMessage[];
+    /** Clear all queues and bindings. */
+    clear(): void;
+}
+//# sourceMappingURL=inboundQueue.d.ts.map

package/dist/mcp/channels/inboundQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inboundQueue.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/inboundQueue.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM9D,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;AAE5E,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAMD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;gBAEvC,OAAO,CAAC,EAAE,mBAAmB;IAKzC,mDAAmD;IACnD,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAQvD,qCAAqC;IACrC,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI1C,qDAAqD;IACrD,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIxD,+BAA+B;IAC/B,WAAW,IAAI,cAAc,EAAE;IAI/B;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAuBtC,oDAAoD;IACpD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAMjD,sDAAsD;IACtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAMpD,mDAAmD;IACnD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIhC,iDAAiD;IACjD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC,oDAAoD;IACpD,kBAAkB,CAAC,KAAK,SAAK,GAAG,cAAc,EAAE;IAIhD,qCAAqC;IACrC,KAAK,IAAI,IAAI;CAId"}

package/dist/mcp/channels/inboundQueue.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Inbound Message Queue.
+ *
+ * Stores inbound channel messages in-memory and provides wake-up
+ * triggers for sleeping runs. Messages do not survive process restarts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboundMessageQueue = void 0;
+// ---------------------------------------------------------------------------
+// InboundMessageQueue
+// ---------------------------------------------------------------------------
+class InboundMessageQueue {
+    _queues = new Map();
+    _bindings = new Map();
+    _maxQueueSize;
+    _onWake;
+    constructor(options) {
+        this._maxQueueSize = options?.maxQueueSize ?? 100;
+        this._onWake = options?.onWake;
+    }
+    /** Bind a channel to a run for message routing. */
+    bindChannel(channelSource, runId) {
+        this._bindings.set(channelSource, {
+            channelSource,
+            runId,
+            boundAt: new Date().toISOString(),
+        });
+    }
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource) {
+        this._bindings.delete(channelSource);
+    }
+    /** Get the run ID a channel is bound to (if any). */
+    getBoundRunId(channelSource) {
+        return this._bindings.get(channelSource)?.runId;
+    }
+    /** Get all active bindings. */
+    getBindings() {
+        return [...this._bindings.values()];
+    }
+    /**
+     * Enqueue an inbound message. Routes to bound run if one exists.
+     * Fires the wake callback if a binding exists.
+     */
+    enqueue(message) {
+        const runId = this._bindings.get(message.source)?.runId;
+        const queueKey = runId ?? "__unbound__";
+        let queue = this._queues.get(queueKey);
+        if (!queue) {
+            queue = [];
+            this._queues.set(queueKey, queue);
+        }
+        queue.push(message);
+        // Trim if over max
+        if (queue.length > this._maxQueueSize) {
+            queue.shift();
+        }
+        // Fire wake callback for bound runs
+        if (runId && this._onWake) {
+            this._onWake(runId, message);
+        }
+    }
+    /** Peek at messages for a run (does not remove). */
+    peek(runId, limit = 10) {
+        const queue = this._queues.get(runId);
+        if (!queue)
+            return [];
+        return queue.slice(-limit);
+    }
+    /** Dequeue (remove and return) messages for a run. */
+    dequeue(runId, limit = 10) {
+        const queue = this._queues.get(runId);
+        if (!queue || queue.length === 0)
+            return [];
+        return queue.splice(0, Math.min(limit, queue.length));
+    }
+    /** Get the number of queued messages for a run. */
+    queueSize(runId) {
+        return this._queues.get(runId)?.length ?? 0;
+    }
+    /** Check if there are any messages for a run. */
+    hasMessages(runId) {
+        return this.queueSize(runId) > 0;
+    }
+    /** Get unbound messages (not routed to any run). */
+    getUnboundMessages(limit = 10) {
+        return this.peek("__unbound__", limit);
+    }
+    /** Clear all queues and bindings. */
+    clear() {
+        this._queues.clear();
+        this._bindings.clear();
+    }
+}
+exports.InboundMessageQueue = InboundMessageQueue;

package/dist/mcp/channels/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MCP Channels — interactive messaging and approval routing.
+ * Moved from @a5c-ai/babysitter-sdk.
+ *
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ *
+ * GAP-MCPC-001/002/003/004
+ */
+export type { ChannelCapability, ChannelConfig, ChannelMessage, ChannelBinding, OutboundMessageRequest, OutboundMessageResult, ChannelApprovalRequest, ChannelApprovalResponse, ApprovalClaim, ChannelAllowlistFile, ChannelApprovalSecurityConfig, } from "./types";
+export { CHANNEL_ALLOWLIST_SCHEMA_VERSION, DEFAULT_APPROVAL_SECURITY, } from "./types";
+export { getChannelAllowlistPath, readChannelAllowlist, writeChannelAllowlist, upsertChannel, removeChannel, toggleChannel, getEnabledChannels, } from "./allowlist";
+export { InboundMessageQueue, type WakeCallback, type InboundQueueOptions, } from "./inboundQueue";
+export { ChannelManager, type ChannelManagerOptions, type DetectedChannel, } from "./channelManager";
+export { OutboundChannelSender, formatTemplate, DEFAULT_CHANNEL_TOOL_MAPPINGS, type ChannelToolMapping, } from "./outbound";
+export { ChannelPermissionRelay, createApprovalRace, type PermissionRelayOptions, type RelayResult, } from "./permissionRelay";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/channels/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,gCAAgC,EAChC,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,6BAA6B,EAC7B,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC"}

package/dist/mcp/channels/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * MCP Channels — interactive messaging and approval routing.
+ * Moved from @a5c-ai/babysitter-sdk.
+ *
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ *
+ * GAP-MCPC-001/002/003/004
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApprovalRace = exports.ChannelPermissionRelay = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = exports.formatTemplate = exports.OutboundChannelSender = exports.ChannelManager = exports.InboundMessageQueue = exports.getEnabledChannels = exports.toggleChannel = exports.removeChannel = exports.upsertChannel = exports.writeChannelAllowlist = exports.readChannelAllowlist = exports.getChannelAllowlistPath = exports.DEFAULT_APPROVAL_SECURITY = exports.CHANNEL_ALLOWLIST_SCHEMA_VERSION = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "CHANNEL_ALLOWLIST_SCHEMA_VERSION", { enumerable: true, get: function () { return types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "DEFAULT_APPROVAL_SECURITY", { enumerable: true, get: function () { return types_1.DEFAULT_APPROVAL_SECURITY; } });
+// Allowlist
+var allowlist_1 = require("./allowlist");
+Object.defineProperty(exports, "getChannelAllowlistPath", { enumerable: true, get: function () { return allowlist_1.getChannelAllowlistPath; } });
+Object.defineProperty(exports, "readChannelAllowlist", { enumerable: true, get: function () { return allowlist_1.readChannelAllowlist; } });
+Object.defineProperty(exports, "writeChannelAllowlist", { enumerable: true, get: function () { return allowlist_1.writeChannelAllowlist; } });
+Object.defineProperty(exports, "upsertChannel", { enumerable: true, get: function () { return allowlist_1.upsertChannel; } });
+Object.defineProperty(exports, "removeChannel", { enumerable: true, get: function () { return allowlist_1.removeChannel; } });
+Object.defineProperty(exports, "toggleChannel", { enumerable: true, get: function () { return allowlist_1.toggleChannel; } });
+Object.defineProperty(exports, "getEnabledChannels", { enumerable: true, get: function () { return allowlist_1.getEnabledChannels; } });
+// Inbound queue
+var inboundQueue_1 = require("./inboundQueue");
+Object.defineProperty(exports, "InboundMessageQueue", { enumerable: true, get: function () { return inboundQueue_1.InboundMessageQueue; } });
+// Channel manager
+var channelManager_1 = require("./channelManager");
+Object.defineProperty(exports, "ChannelManager", { enumerable: true, get: function () { return channelManager_1.ChannelManager; } });
+// Outbound sender
+var outbound_1 = require("./outbound");
+Object.defineProperty(exports, "OutboundChannelSender", { enumerable: true, get: function () { return outbound_1.OutboundChannelSender; } });
+Object.defineProperty(exports, "formatTemplate", { enumerable: true, get: function () { return outbound_1.formatTemplate; } });
+Object.defineProperty(exports, "DEFAULT_CHANNEL_TOOL_MAPPINGS", { enumerable: true, get: function () { return outbound_1.DEFAULT_CHANNEL_TOOL_MAPPINGS; } });
+// Permission relay
+var permissionRelay_1 = require("./permissionRelay");
+Object.defineProperty(exports, "ChannelPermissionRelay", { enumerable: true, get: function () { return permissionRelay_1.ChannelPermissionRelay; } });
+Object.defineProperty(exports, "createApprovalRace", { enumerable: true, get: function () { return permissionRelay_1.createApprovalRace; } });

package/dist/mcp/channels/outbound.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GAP-MCPC-002: Outbound Channel Sender.
+ *
+ * Sends messages to channels via MCP server tools.
+ * Supports template-based message formatting.
+ */
+import type { OutboundMessageRequest, OutboundMessageResult } from "./types";
+import type { McpClientManager } from "../client/manager";
+/** Map of channel types to their send-message tool names. */
+export interface ChannelToolMapping {
+    /** MCP tool name used for sending messages on this channel type. */
+    sendToolName: string;
+    /** Argument mapping: which parameter receives the channel ID. */
+    channelArg: string;
+    /** Argument mapping: which parameter receives the message text. */
+    textArg: string;
+}
+export declare const DEFAULT_CHANNEL_TOOL_MAPPINGS: Record<string, ChannelToolMapping>;
+/** Format a message with simple {{var}} template substitution. */
+export declare function formatTemplate(template: string, vars: Record<string, string>): string;
+export declare class OutboundChannelSender {
+    private readonly _clientManager;
+    private readonly _toolMappings;
+    constructor(clientManager: McpClientManager, toolMappings?: Record<string, ChannelToolMapping>);
+    /**
+     * Send a message to a channel.
+     * Resolves the channel source (serverName:channelId) to determine
+     * which MCP server and tool to use.
+     */
+    send(request: OutboundMessageRequest): Promise<OutboundMessageResult>;
+    private _resolveToolMapping;
+}
+//# sourceMappingURL=outbound.d.ts.map

package/dist/mcp/channels/outbound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbound.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/outbound.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAO1D,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAI5E,CAAC;AAMF,kEAAkE;AAClE,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,MAAM,CAER;AAMD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;gBAGjE,aAAa,EAAE,gBAAgB,EAC/B,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAiC;IAMlF;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;YAgD7D,mBAAmB;CAelC"}