@a5c-ai/genty-platform 5.1.1-staging.0007199a1cb2

package/dist/interaction/typedEffectPatterns.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Typed effect interaction patterns (GAP-UX-010).
+ *
+ * Defines interaction patterns for each effect kind — input schemas,
+ * output schemas, and rendering hints — so UIs can present effects
+ * consistently and validate user input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILT_IN_PATTERNS = void 0;
+exports.getPatternForEffect = getPatternForEffect;
+exports.validateEffectInput = validateEffectInput;
+exports.formatEffectSummary = formatEffectSummary;
+// ---------------------------------------------------------------------------
+// Built-in patterns
+// ---------------------------------------------------------------------------
+exports.BUILT_IN_PATTERNS = [
+    {
+        kind: 'agent',
+        inputSchema: [
+            { name: 'prompt', type: 'string', required: true, description: 'Prompt to send to the agent' },
+            { name: 'model', type: 'string', required: false, description: 'Target model override' },
+        ],
+        outputSchema: [
+            { name: 'response', type: 'string', required: true, description: 'Agent response text' },
+            { name: 'tokenUsage', type: 'object', required: false, description: 'Token usage stats' },
+        ],
+        renderHints: {
+            widget: 'panel',
+            streaming: true,
+            requiresConfirmation: false,
+            icon: 'robot',
+        },
+    },
+    {
+        kind: 'shell',
+        inputSchema: [
+            { name: 'command', type: 'string', required: true, description: 'Shell command to execute' },
+            { name: 'cwd', type: 'string', required: false, description: 'Working directory' },
+            { name: 'timeout', type: 'number', required: false, description: 'Timeout in ms' },
+        ],
+        outputSchema: [
+            { name: 'stdout', type: 'string', required: true, description: 'Standard output' },
+            { name: 'stderr', type: 'string', required: false, description: 'Standard error' },
+            { name: 'exitCode', type: 'number', required: true, description: 'Exit code' },
+        ],
+        renderHints: {
+            widget: 'terminal',
+            streaming: true,
+            requiresConfirmation: true,
+            icon: 'terminal',
+        },
+    },
+    {
+        kind: 'breakpoint',
+        inputSchema: [
+            { name: 'message', type: 'string', required: true, description: 'Message to show at breakpoint' },
+            { name: 'choices', type: 'array', required: false, description: 'Available choices' },
+        ],
+        outputSchema: [
+            { name: 'selection', type: 'string', required: true, description: 'User selection or input' },
+        ],
+        renderHints: {
+            widget: 'dialog',
+            streaming: false,
+            requiresConfirmation: true,
+            icon: 'pause',
+        },
+    },
+    {
+        kind: 'sleep',
+        inputSchema: [
+            { name: 'durationMs', type: 'number', required: true, description: 'Duration in milliseconds' },
+            { name: 'reason', type: 'string', required: false, description: 'Reason for waiting' },
+        ],
+        outputSchema: [
+            { name: 'elapsed', type: 'number', required: true, description: 'Actual elapsed time in ms' },
+        ],
+        renderHints: {
+            widget: 'inline',
+            streaming: false,
+            requiresConfirmation: false,
+            icon: 'clock',
+        },
+    },
+    {
+        kind: 'mcp',
+        inputSchema: [
+            { name: 'server', type: 'string', required: true, description: 'MCP server name' },
+            { name: 'tool', type: 'string', required: true, description: 'Tool to invoke' },
+            { name: 'args', type: 'object', required: false, description: 'Tool arguments' },
+        ],
+        outputSchema: [
+            { name: 'result', type: 'object', required: true, description: 'Tool result' },
+            { name: 'error', type: 'string', required: false, description: 'Error message if failed' },
+        ],
+        renderHints: {
+            widget: 'panel',
+            streaming: false,
+            requiresConfirmation: false,
+            icon: 'plug',
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// getPatternForEffect
+// ---------------------------------------------------------------------------
+/**
+ * Find the interaction pattern for a given effect.
+ */
+function getPatternForEffect(effect) {
+    return exports.BUILT_IN_PATTERNS.find((p) => p.kind === effect.kind);
+}
+/**
+ * Validate input data against a pattern's input schema.
+ */
+function validateEffectInput(pattern, input) {
+    const errors = [];
+    for (const field of pattern.inputSchema) {
+        const value = input[field.name];
+        // Required check
+        if (field.required && (value === undefined || value === null)) {
+            errors.push({ field: field.name, message: `Required field "${field.name}" is missing` });
+            continue;
+        }
+        // Type check (only if value is present)
+        if (value !== undefined && value !== null) {
+            const actualType = Array.isArray(value) ? 'array' : typeof value;
+            if (actualType !== field.type) {
+                errors.push({
+                    field: field.name,
+                    message: `Expected ${field.type} for "${field.name}", got ${actualType}`,
+                });
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ---------------------------------------------------------------------------
+// formatEffectSummary
+// ---------------------------------------------------------------------------
+/**
+ * Format a human-readable summary of an effect result.
+ */
+function formatEffectSummary(pattern, result) {
+    const parts = [`[${pattern.kind}]`];
+    switch (pattern.kind) {
+        case 'shell': {
+            const code = result.exitCode ?? '?';
+            const cmd = typeof result.command === 'string' ? result.command : '';
+            parts.push(`exit=${code}`);
+            if (cmd)
+                parts.push(cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd);
+            break;
+        }
+        case 'agent': {
+            const resp = typeof result.response === 'string' ? result.response : '';
+            const preview = resp.length > 80 ? resp.slice(0, 77) + '...' : resp;
+            if (preview)
+                parts.push(preview);
+            break;
+        }
+        case 'breakpoint': {
+            const sel = typeof result.selection === 'string' ? result.selection : 'n/a';
+            parts.push(`selected: ${sel}`);
+            break;
+        }
+        case 'sleep': {
+            const elapsed = typeof result.elapsed === 'number' ? result.elapsed : 0;
+            parts.push(`waited ${elapsed}ms`);
+            break;
+        }
+        case 'mcp': {
+            const tool = typeof result.tool === 'string' ? result.tool : '';
+            const err = typeof result.error === 'string' ? result.error : '';
+            if (tool)
+                parts.push(tool);
+            if (err)
+                parts.push(`ERROR: ${err}`);
+            break;
+        }
+        default: {
+            // Generic: show keys
+            const keys = Object.keys(result).slice(0, 3);
+            if (keys.length > 0)
+                parts.push(`keys: ${keys.join(', ')}`);
+        }
+    }
+    return parts.join(' ');
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+import type { ChannelConfig, ChannelAllowlistFile } from "./types";
+export declare function getChannelAllowlistPath(stateDir: string): string;
+export declare function readChannelAllowlist(stateDir: string): Promise<ChannelAllowlistFile>;
+export declare function writeChannelAllowlist(stateDir: string, allowlist: ChannelAllowlistFile): Promise<void>;
+/** Add or update a channel in the allowlist. */
+export declare function upsertChannel(stateDir: string, channel: ChannelConfig): Promise<ChannelAllowlistFile>;
+/** Remove a channel from the allowlist. Returns true if removed. */
+export declare function removeChannel(stateDir: string, serverName: string, channelId: string): Promise<boolean>;
+/** Toggle a channel's enabled state. Returns the new enabled state. */
+export declare function toggleChannel(stateDir: string, serverName: string, channelId: string, enabled?: boolean): Promise<boolean | undefined>;
+/** Get all enabled channels. */
+export declare function getEnabledChannels(allowlist: ChannelAllowlistFile): ChannelConfig[];
+//# sourceMappingURL=allowlist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"allowlist.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/allowlist.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAenE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA+B1F;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,oBAAoB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,gDAAgD;AAChD,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAa/B;AAED,oEAAoE;AACpE,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED,uEAAuE;AACvE,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAU9B;AAED,gCAAgC;AAChC,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,aAAa,EAAE,CAEnF"}

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"}