@lobu/gateway 2.8.0

package/dist/connections/chat-instance-manager.js

@@ -0,0 +1,886 @@
+"use strict";
+/**
+ * ChatInstanceManager — manages Chat SDK instances for API-driven platform connections.
+ * Owns Redis persistence, Chat lifecycle, and webhook dispatch.
+ */
+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.ChatInstanceManager = exports.ADAPTER_FACTORIES = void 0;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@lobu/core");
+const types_1 = require("./types");
+const logger = (0, core_1.createLogger)("chat-instance-manager");
+const SLACK_SYSTEM_AGENT_PREFIX = "system:connection:slack";
+exports.ADAPTER_FACTORIES = {
+    telegram: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/telegram")))).createTelegramAdapter(c),
+    slack: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/slack")))).createSlackAdapter(c),
+    discord: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/discord")))).createDiscordAdapter(c),
+    whatsapp: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/whatsapp")))).createWhatsAppAdapter(c),
+    teams: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/teams")))).createTeamsAdapter(c),
+    gchat: async (c) => (await Promise.resolve().then(() => __importStar(require("@chat-adapter/gchat")))).createGoogleChatAdapter(c),
+};
+class ChatInstanceManager {
+    constructor() {
+        this.instances = new Map();
+        this.publicGatewayUrl = "";
+    }
+    async initialize(services) {
+        var _a, _b;
+        this.services = services;
+        this.redis = services.getQueue().getRedisClient();
+        this.publicGatewayUrl = services.getPublicGatewayUrl();
+        // Load all connections from Redis and start active ones
+        const connectionIds = await this.redis.smembers("connections:all");
+        logger.debug({ count: connectionIds.length }, "Loading connections from Redis");
+        for (const id of connectionIds) {
+            try {
+                const raw = await this.redis.get(`connection:${id}`);
+                if (!raw) {
+                    await this.redis.srem("connections:all", id);
+                    continue;
+                }
+                const connection = JSON.parse(raw);
+                try {
+                    connection.config = this.decryptConfig(connection.config);
+                }
+                catch (decryptError) {
+                    // ENCRYPTION_KEY changed — remove stale connection so the seeder can recreate it
+                    logger.warn({ id, platform: connection.platform, error: String(decryptError) }, "Removing connection with undecryptable config (ENCRYPTION_KEY changed?)");
+                    await this.redis.del(`connection:${id}`);
+                    await this.redis.srem("connections:all", id);
+                    if (connection.templateAgentId) {
+                        await this.redis.srem(`connections:agent:${connection.templateAgentId}`, id);
+                    }
+                    continue;
+                }
+                // Migrate legacy agentId → templateAgentId
+                const legacy = connection;
+                if (legacy.agentId && !connection.templateAgentId) {
+                    connection.templateAgentId = legacy.agentId;
+                    delete legacy.agentId;
+                    await this.persistConnection(connection);
+                    logger.info({ id, templateAgentId: connection.templateAgentId }, "Migrated agentId → templateAgentId");
+                }
+                // Migrate legacy scope values: "mcp-servers"/"tools" → "skills"
+                if ((_b = (_a = connection.settings) === null || _a === void 0 ? void 0 : _a.userConfigScopes) === null || _b === void 0 ? void 0 : _b.length) {
+                    const oldScopes = connection.settings.userConfigScopes;
+                    const hasLegacy = oldScopes.some((s) => s === "mcp-servers" || s === "tools");
+                    if (hasLegacy) {
+                        const migrated = new Set();
+                        for (const s of oldScopes) {
+                            if (s === "mcp-servers" || s === "tools") {
+                                migrated.add("skills");
+                            }
+                            else {
+                                migrated.add(s);
+                            }
+                        }
+                        connection.settings.userConfigScopes = [...migrated];
+                        await this.persistConnection(connection);
+                        logger.info({ id }, "Migrated legacy scopes → skills");
+                    }
+                }
+                if (connection.status === "active") {
+                    await this.startInstance(connection);
+                }
+            }
+            catch (error) {
+                logger.error({ id, error: String(error) }, "Failed to load connection");
+            }
+        }
+    }
+    async shutdown() {
+        logger.info({ count: this.instances.size }, "Shutting down all connections");
+        const shutdownPromises = Array.from(this.instances.values()).map(async (instance) => {
+            var _a, _b;
+            try {
+                (_a = instance.interactionCleanup) === null || _a === void 0 ? void 0 : _a.call(instance);
+                await ((_b = instance.cleanup) === null || _b === void 0 ? void 0 : _b.call(instance));
+            }
+            catch (error) {
+                logger.error({ id: instance.connection.id, error: String(error) }, "Error shutting down connection");
+            }
+        });
+        await Promise.allSettled(shutdownPromises);
+        this.instances.clear();
+    }
+    async addConnection(platform, templateAgentId, config, settings, metadata = {}) {
+        if (!(platform in exports.ADAPTER_FACTORIES)) {
+            throw new Error(`Unsupported platform: ${platform}`);
+        }
+        if (config.platform !== platform) {
+            throw new Error(`Config platform mismatch: expected ${platform}, got ${config.platform}`);
+        }
+        const id = (0, node_crypto_1.randomUUID)().replace(/-/g, "").slice(0, 16);
+        const now = Date.now();
+        const connection = Object.assign(Object.assign({ id,
+            platform }, (templateAgentId ? { templateAgentId } : {})), { config, settings: settings !== null && settings !== void 0 ? settings : { allowGroups: true }, metadata, status: "active", createdAt: now, updatedAt: now });
+        // Start the Chat SDK instance
+        await this.startInstance(connection);
+        // Persist (secrets encrypted)
+        await this.persistConnection(connection);
+        logger.info({ id, platform, templateAgentId }, "Connection added");
+        return connection;
+    }
+    async removeConnection(id) {
+        var _a, _b;
+        const instance = this.instances.get(id);
+        if (instance) {
+            (_a = instance.interactionCleanup) === null || _a === void 0 ? void 0 : _a.call(instance);
+            await ((_b = instance.cleanup) === null || _b === void 0 ? void 0 : _b.call(instance));
+            this.instances.delete(id);
+        }
+        // Clean up Redis
+        const raw = await this.redis.get(`connection:${id}`);
+        if (raw) {
+            const conn = JSON.parse(raw);
+            if (conn.templateAgentId) {
+                await this.redis.srem(`connections:agent:${conn.templateAgentId}`, id);
+            }
+        }
+        await this.redis.del(`connection:${id}`);
+        await this.redis.srem("connections:all", id);
+        logger.info({ id }, "Connection removed");
+    }
+    async restartConnection(id) {
+        var _a, _b;
+        const instance = this.instances.get(id);
+        if (instance) {
+            (_a = instance.interactionCleanup) === null || _a === void 0 ? void 0 : _a.call(instance);
+            await ((_b = instance.cleanup) === null || _b === void 0 ? void 0 : _b.call(instance));
+            this.instances.delete(id);
+        }
+        const raw = await this.redis.get(`connection:${id}`);
+        if (!raw)
+            throw new Error(`Connection ${id} not found`);
+        const connection = JSON.parse(raw);
+        connection.config = this.decryptConfig(connection.config);
+        connection.status = "active";
+        connection.errorMessage = undefined;
+        connection.updatedAt = Date.now();
+        try {
+            await this.startInstance(connection);
+        }
+        catch (error) {
+            // startInstance sets connection.status = "error" — persist so UI reflects it
+            await this.persistConnection(connection);
+            throw error;
+        }
+        await this.persistConnection(connection);
+        logger.info({ id }, "Connection restarted");
+    }
+    async stopConnection(id) {
+        var _a, _b;
+        const instance = this.instances.get(id);
+        if (instance) {
+            (_a = instance.interactionCleanup) === null || _a === void 0 ? void 0 : _a.call(instance);
+            await ((_b = instance.cleanup) === null || _b === void 0 ? void 0 : _b.call(instance));
+            this.instances.delete(id);
+        }
+        const raw = await this.redis.get(`connection:${id}`);
+        if (!raw)
+            throw new Error(`Connection ${id} not found`);
+        const connection = JSON.parse(raw);
+        connection.config = this.decryptConfig(connection.config);
+        connection.status = "stopped";
+        connection.updatedAt = Date.now();
+        await this.persistConnection(connection);
+        logger.info({ id }, "Connection stopped");
+    }
+    async updateConnection(id, updates) {
+        var _a, _b;
+        const raw = await this.redis.get(`connection:${id}`);
+        if (!raw)
+            throw new Error(`Connection ${id} not found`);
+        const connection = JSON.parse(raw);
+        connection.config = this.decryptConfig(connection.config);
+        const needsRestart = updates.config !== undefined &&
+            JSON.stringify(updates.config) !== JSON.stringify(connection.config);
+        if (updates.templateAgentId !== undefined) {
+            // Update agent index — remove old, add new
+            if (connection.templateAgentId) {
+                await this.redis.srem(`connections:agent:${connection.templateAgentId}`, id);
+            }
+            if (updates.templateAgentId) {
+                connection.templateAgentId = updates.templateAgentId;
+                await this.redis.sadd(`connections:agent:${connection.templateAgentId}`, id);
+            }
+            else {
+                delete connection.templateAgentId;
+            }
+        }
+        if (updates.config !== undefined) {
+            const merged = Object.assign({}, connection.config);
+            for (const [key, value] of Object.entries(updates.config)) {
+                if (typeof value === "string" && value.startsWith("***"))
+                    continue;
+                merged[key] = value;
+            }
+            merged.platform = updates.config.platform;
+            connection.config = merged;
+        }
+        if (updates.settings !== undefined) {
+            connection.settings = Object.assign(Object.assign({}, connection.settings), updates.settings);
+        }
+        if (updates.metadata !== undefined) {
+            connection.metadata = Object.assign(Object.assign({}, (connection.metadata || {})), updates.metadata);
+        }
+        connection.updatedAt = Date.now();
+        if (needsRestart && connection.status === "active") {
+            const instance = this.instances.get(id);
+            if (instance) {
+                (_a = instance.interactionCleanup) === null || _a === void 0 ? void 0 : _a.call(instance);
+                await ((_b = instance.cleanup) === null || _b === void 0 ? void 0 : _b.call(instance));
+                this.instances.delete(id);
+            }
+            await this.startInstance(connection);
+        }
+        else {
+            const instance = this.instances.get(id);
+            if (instance) {
+                instance.connection = connection;
+            }
+        }
+        await this.persistConnection(connection);
+        return this.sanitizeConnection(connection);
+    }
+    async listConnections(filter) {
+        let ids;
+        if (filter === null || filter === void 0 ? void 0 : filter.templateAgentId) {
+            ids = await this.redis.smembers(`connections:agent:${filter.templateAgentId}`);
+        }
+        else {
+            ids = await this.redis.smembers("connections:all");
+        }
+        const connections = [];
+        for (const id of ids) {
+            const raw = await this.redis.get(`connection:${id}`);
+            if (!raw)
+                continue;
+            const conn = JSON.parse(raw);
+            if ((filter === null || filter === void 0 ? void 0 : filter.platform) && conn.platform !== filter.platform)
+                continue;
+            connections.push(this.sanitizeConnection(conn));
+        }
+        return connections;
+    }
+    async getConnection(id) {
+        const raw = await this.redis.get(`connection:${id}`);
+        if (!raw)
+            return null;
+        return this.sanitizeConnection(JSON.parse(raw));
+    }
+    has(id) {
+        return this.instances.has(id);
+    }
+    getInstance(id) {
+        return this.instances.get(id);
+    }
+    /** Get a decrypted secret from a running connection's config. */
+    getConnectionConfigSecret(connectionId, field) {
+        const instance = this.instances.get(connectionId);
+        if (!instance)
+            return undefined;
+        const config = instance.connection.config;
+        const val = config[field];
+        return typeof val === "string" ? val : undefined;
+    }
+    async handleWebhook(connectionId, request) {
+        var _a;
+        const instance = this.instances.get(connectionId);
+        if (!instance) {
+            return new Response("Connection not found", { status: 404 });
+        }
+        const { platform } = instance.connection;
+        const webhookHandler = (_a = instance.chat.webhooks) === null || _a === void 0 ? void 0 : _a[platform];
+        if (!webhookHandler) {
+            logger.warn({ connectionId, platform }, "No webhook handler found for platform");
+            return new Response("No webhook handler", { status: 404 });
+        }
+        try {
+            return await webhookHandler(request);
+        }
+        catch (error) {
+            logger.error({ connectionId, platform, error: String(error) }, "Webhook handling failed");
+            return new Response("Internal error", { status: 500 });
+        }
+    }
+    getServices() {
+        return this.services;
+    }
+    async findSlackConnectionByTeamId(teamId) {
+        const connections = await this.listConnections({ platform: "slack" });
+        return (connections.find((connection) => { var _a; return ((_a = connection.metadata) === null || _a === void 0 ? void 0 : _a.teamId) === teamId; }) || null);
+    }
+    async getDefaultSlackConnection() {
+        const connections = await this.listConnections({ platform: "slack" });
+        if (connections.length === 1) {
+            return connections[0] || null;
+        }
+        return (connections.find((connection) => { var _a; return !((_a = connection.metadata) === null || _a === void 0 ? void 0 : _a.teamId); }) || null);
+    }
+    async ensureSlackWorkspaceConnection(teamId, installation) {
+        const baseConfig = this.resolveSlackAdapterConfig({
+            requireOAuth: true,
+        });
+        const config = Object.assign(Object.assign(Object.assign({}, baseConfig), { botToken: installation.botToken }), (installation.botUserId ? { botUserId: installation.botUserId } : {}));
+        const agentId = `${SLACK_SYSTEM_AGENT_PREFIX}:${teamId}`;
+        const metadata = {
+            teamId,
+            teamName: installation.teamName,
+            botUserId: installation.botUserId,
+        };
+        const existing = await this.findSlackConnectionByTeamId(teamId);
+        if (existing) {
+            const updated = await this.updateConnection(existing.id, {
+                templateAgentId: agentId,
+                config,
+                metadata,
+            });
+            if (!this.has(existing.id)) {
+                await this.restartConnection(existing.id);
+            }
+            return updated;
+        }
+        return this.addConnection("slack", agentId, config, { allowGroups: true }, metadata);
+    }
+    async completeSlackOAuthInstall(request, redirectUri) {
+        const { chat, adapter } = await this.createSlackOAuthChat({
+            requireOAuth: true,
+        });
+        try {
+            const url = new URL(request.url);
+            if (redirectUri) {
+                url.searchParams.set("redirect_uri", redirectUri);
+            }
+            const callbackRequest = new Request(url.toString(), {
+                method: request.method,
+                headers: request.headers,
+            });
+            const { teamId, installation } = await adapter.handleOAuthCallback(callbackRequest);
+            let connection;
+            try {
+                connection = await this.ensureSlackWorkspaceConnection(teamId, installation);
+            }
+            catch (error) {
+                await adapter.deleteInstallation(teamId).catch((err) => {
+                    logger.warn({ teamId, error: String(err) }, "Failed to delete Slack installation after connection error");
+                });
+                throw error;
+            }
+            return {
+                teamId,
+                teamName: installation.teamName,
+                connectionId: connection.id,
+            };
+        }
+        finally {
+            await chat.shutdown().catch((err) => {
+                logger.warn({ error: String(err) }, "Failed to shut down Slack OAuth chat");
+            });
+        }
+    }
+    async handleSlackAppWebhook(request) {
+        const body = await request.text();
+        const teamId = this.extractSlackTeamId(body, request.headers.get("content-type") || "");
+        if (teamId) {
+            const connection = await this.findSlackConnectionByTeamId(teamId);
+            if (connection) {
+                if (!(await this.ensureConnectionRunning(connection.id))) {
+                    return new Response("Slack connection unavailable", { status: 503 });
+                }
+                return this.handleWebhook(connection.id, this.cloneRequestWithBody(request, body));
+            }
+        }
+        const fallbackConnection = await this.getDefaultSlackConnection();
+        if (fallbackConnection) {
+            if (!(await this.ensureConnectionRunning(fallbackConnection.id))) {
+                return new Response("Slack connection unavailable", { status: 503 });
+            }
+            return this.handleWebhook(fallbackConnection.id, this.cloneRequestWithBody(request, body));
+        }
+        const { chat, adapter } = await this.createSlackOAuthChat();
+        try {
+            return await adapter.handleWebhook(this.cloneRequestWithBody(request, body));
+        }
+        finally {
+            await chat.shutdown().catch((err) => {
+                logger.warn({ error: String(err) }, "Failed to shut down Slack webhook chat");
+            });
+        }
+    }
+    // --- Private ---
+    async startInstance(connection) {
+        var _a;
+        try {
+            const { Chat } = await Promise.resolve().then(() => __importStar(require("chat")));
+            const adapter = await this.createAdapter(connection);
+            const stateAdapter = await this.createStateAdapter();
+            const adapterKey = connection.platform;
+            const chat = new Chat({
+                userName: connection.metadata.botUsername || `bot-${connection.id}`,
+                adapters: { [adapterKey]: adapter },
+                state: stateAdapter,
+                logger: "warn",
+            });
+            // Register message handlers (imported lazily to avoid circular deps)
+            const { registerMessageHandlers } = await Promise.resolve().then(() => __importStar(require("./message-handler-bridge")));
+            const { CommandDispatcher } = await Promise.resolve().then(() => __importStar(require("../commands/command-dispatcher")));
+            const commandDispatcher = new CommandDispatcher({
+                registry: this.services.getCommandRegistry(),
+                channelBindingService: this.services.getChannelBindingService(),
+            });
+            registerMessageHandlers(chat, connection, this.services, this, commandDispatcher);
+            chat.registerSingleton();
+            // Initialize adapters (starts long-polling for Telegram, etc.)
+            await chat.initialize();
+            // Set webhook URL if applicable
+            const mode = (_a = connection.config.mode) !== null && _a !== void 0 ? _a : "auto";
+            const useWebhook = mode === "webhook" || (mode === "auto" && !!this.publicGatewayUrl);
+            if (useWebhook && this.publicGatewayUrl) {
+                const webhookUrl = `${this.publicGatewayUrl}/api/v1/webhooks/${connection.id}`;
+                logger.info({ id: connection.id, webhookUrl }, "Setting webhook");
+            }
+            const cleanup = async () => {
+                try {
+                    await chat.shutdown();
+                }
+                catch (_a) {
+                    // best effort
+                }
+            };
+            // Populate metadata (bot username etc.) from adapter properties
+            if (!connection.metadata.botUsername) {
+                try {
+                    const userName = adapter.userName || adapter.botUsername;
+                    if (userName) {
+                        connection.metadata.botUsername = userName;
+                        await this.updateConnection(connection.id, {
+                            metadata: { botUsername: userName },
+                        });
+                    }
+                }
+                catch (_b) {
+                    // non-critical
+                }
+            }
+            this.instances.set(connection.id, { connection, chat, cleanup });
+            const { registerInteractionBridge } = await Promise.resolve().then(() => __importStar(require("./interaction-bridge")));
+            const interactionCleanup = registerInteractionBridge(this.services.getInteractionService(), this, connection, chat, this.services.getGrantStore(), this.services.getAgentSettingsStore());
+            this.instances.get(connection.id).interactionCleanup =
+                interactionCleanup;
+            // Register slash commands with the platform (e.g. Telegram menu)
+            this.registerPlatformCommands(connection).catch((err) => {
+                logger.warn({ id: connection.id, error: String(err) }, "Failed to register platform commands");
+            });
+            logger.info({ id: connection.id, platform: connection.platform }, "Chat instance started");
+        }
+        catch (error) {
+            connection.status = "error";
+            connection.errorMessage = String(error);
+            logger.error({ id: connection.id, error: String(error) }, "Failed to start Chat instance");
+            throw error;
+        }
+    }
+    async createAdapter(connection) {
+        const factory = exports.ADAPTER_FACTORIES[connection.platform];
+        if (!factory) {
+            throw new Error(`No adapter factory for: ${connection.platform}`);
+        }
+        return factory(connection.config);
+    }
+    async createStateAdapter() {
+        const { createIoRedisState } = await Promise.resolve().then(() => __importStar(require("@chat-adapter/state-ioredis")));
+        return createIoRedisState({
+            client: this.redis,
+            keyPrefix: "chat-conn",
+            logger: "warn",
+        });
+    }
+    /**
+     * Register slash commands with the platform's native command menu.
+     * Currently supports Telegram (setMyCommands) and Slack (via manifest).
+     */
+    async registerPlatformCommands(connection) {
+        const commands = this.services
+            .getCommandRegistry()
+            .getAll()
+            .map((cmd) => ({
+            command: cmd.name,
+            description: cmd.description,
+        }));
+        if (connection.platform === "telegram") {
+            const botToken = connection.config.botToken;
+            if (!botToken)
+                return;
+            const apiBase = connection.config.apiBaseUrl || "https://api.telegram.org";
+            const resp = await fetch(`${apiBase}/bot${botToken}/setMyCommands`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ commands }),
+            });
+            if (!resp.ok) {
+                const text = await resp.text();
+                throw new Error(`Telegram setMyCommands failed: ${resp.status} ${text}`);
+            }
+            logger.info({ id: connection.id, count: commands.length }, "Telegram bot commands menu registered");
+        }
+    }
+    resolveSlackAdapterConfig(options) {
+        var _a;
+        const slackInstance = Array.from(this.instances.values()).find((instance) => instance.connection.platform === "slack");
+        const currentConfig = ((slackInstance === null || slackInstance === void 0 ? void 0 : slackInstance.connection.config) || {});
+        const signingSecret = process.env.SLACK_SIGNING_SECRET || currentConfig.signingSecret;
+        const clientId = process.env.SLACK_CLIENT_ID || currentConfig.clientId;
+        const clientSecret = process.env.SLACK_CLIENT_SECRET || currentConfig.clientSecret;
+        const encryptionKey = process.env.SLACK_ENCRYPTION_KEY || currentConfig.encryptionKey;
+        const installationKeyPrefix = process.env.SLACK_INSTALLATION_KEY_PREFIX ||
+            currentConfig.installationKeyPrefix;
+        const userName = process.env.SLACK_BOT_USERNAME ||
+            currentConfig.userName ||
+            ((_a = slackInstance === null || slackInstance === void 0 ? void 0 : slackInstance.connection.metadata) === null || _a === void 0 ? void 0 : _a.botUsername);
+        if (!signingSecret) {
+            throw new Error("Slack signing secret is not configured");
+        }
+        if (options === null || options === void 0 ? void 0 : options.requireOAuth) {
+            if (!clientId || !clientSecret) {
+                throw new Error("Slack OAuth is not configured. Set SLACK_CLIENT_ID and SLACK_CLIENT_SECRET.");
+            }
+            return Object.assign(Object.assign(Object.assign({ platform: "slack", signingSecret,
+                clientId,
+                clientSecret }, (encryptionKey ? { encryptionKey } : {})), (installationKeyPrefix ? { installationKeyPrefix } : {})), (userName ? { userName } : {}));
+        }
+        const botToken = process.env.SLACK_BOT_TOKEN || currentConfig.botToken;
+        if (!botToken && (!clientId || !clientSecret)) {
+            throw new Error("Slack adapter is not configured. Provide SLACK_BOT_TOKEN or Slack OAuth credentials.");
+        }
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ platform: "slack", signingSecret }, (botToken ? { botToken } : {})), (clientId ? { clientId } : {})), (clientSecret ? { clientSecret } : {})), (encryptionKey ? { encryptionKey } : {})), (installationKeyPrefix ? { installationKeyPrefix } : {})), (userName ? { userName } : {}));
+    }
+    async createSlackOAuthChat(options) {
+        const { Chat } = await Promise.resolve().then(() => __importStar(require("chat")));
+        const { createSlackAdapter } = await Promise.resolve().then(() => __importStar(require("@chat-adapter/slack")));
+        const adapter = createSlackAdapter(this.resolveSlackAdapterConfig(options));
+        const state = await this.createStateAdapter();
+        const chat = new Chat({
+            userName: "lobu-slack-oauth",
+            adapters: { slack: adapter },
+            state,
+            logger: "warn",
+        });
+        await chat.initialize();
+        return { chat, adapter };
+    }
+    cloneRequestWithBody(request, body) {
+        return new Request(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.method === "GET" || request.method === "HEAD"
+                ? undefined
+                : body,
+        });
+    }
+    extractSlackTeamId(body, contentType) {
+        var _a, _b, _c;
+        if (contentType.includes("application/x-www-form-urlencoded")) {
+            const params = new URLSearchParams(body);
+            const directTeamId = params.get("team_id");
+            if (directTeamId) {
+                return directTeamId;
+            }
+            const payloadStr = params.get("payload");
+            if (!payloadStr) {
+                return null;
+            }
+            try {
+                const payload = JSON.parse(payloadStr);
+                return ((_a = payload.team) === null || _a === void 0 ? void 0 : _a.id) || payload.team_id || null;
+            }
+            catch (_d) {
+                return null;
+            }
+        }
+        try {
+            const payload = JSON.parse(body);
+            return (payload.team_id ||
+                payload.team ||
+                ((_b = payload.event) === null || _b === void 0 ? void 0 : _b.team_id) ||
+                ((_c = payload.event) === null || _c === void 0 ? void 0 : _c.team) ||
+                null);
+        }
+        catch (_e) {
+            return null;
+        }
+    }
+    async ensureConnectionRunning(id) {
+        if (this.has(id)) {
+            return true;
+        }
+        // Don't auto-restart intentionally stopped connections
+        const raw = await this.redis.get(`connection:${id}`);
+        if (raw) {
+            const connection = JSON.parse(raw);
+            if (connection.status === "stopped") {
+                logger.info({ id }, "Connection is stopped, not auto-restarting");
+                return false;
+            }
+        }
+        try {
+            await this.restartConnection(id);
+            return this.has(id);
+        }
+        catch (error) {
+            logger.error({ id, error: String(error) }, "Failed to restart connection");
+            return false;
+        }
+    }
+    async persistConnection(connection) {
+        const encrypted = Object.assign(Object.assign({}, connection), { config: this.encryptConfig(connection.config) });
+        const json = JSON.stringify(encrypted);
+        const pipeline = this.redis
+            .pipeline()
+            .set(`connection:${connection.id}`, json)
+            .sadd("connections:all", connection.id);
+        if (connection.templateAgentId) {
+            pipeline.sadd(`connections:agent:${connection.templateAgentId}`, connection.id);
+        }
+        await pipeline.exec();
+    }
+    encryptConfig(config) {
+        const encrypted = Object.assign({}, config);
+        for (const field of Object.keys(encrypted)) {
+            if ((0, types_1.isSecretField)(field) && typeof encrypted[field] === "string") {
+                try {
+                    encrypted[field] = `enc:v1:${(0, core_1.encrypt)(encrypted[field])}`;
+                }
+                catch (_a) {
+                    // encryption not available — store as-is (dev mode)
+                }
+            }
+        }
+        return encrypted;
+    }
+    decryptConfig(config) {
+        const decrypted = Object.assign({}, config);
+        for (const field of Object.keys(decrypted)) {
+            const val = decrypted[field];
+            if ((0, types_1.isSecretField)(field) &&
+                typeof val === "string" &&
+                val.startsWith("enc:v1:")) {
+                try {
+                    decrypted[field] = (0, core_1.decrypt)(val.slice(7));
+                }
+                catch (_a) {
+                    throw new Error(`Failed to decrypt field "${field}" — ENCRYPTION_KEY may have changed`);
+                }
+            }
+        }
+        return decrypted;
+    }
+    /** Return connection with secrets redacted for API responses. */
+    sanitizeConnection(connection) {
+        const sanitized = Object.assign(Object.assign({}, connection), { config: Object.assign({}, connection.config) });
+        for (const field of Object.keys(sanitized.config)) {
+            if ((0, types_1.isSecretField)(field) && sanitized.config[field]) {
+                const val = String(sanitized.config[field]);
+                sanitized.config[field] = `***${val.slice(-4)}`;
+            }
+        }
+        return sanitized;
+    }
+    // ============================================================================
+    // Platform adapter methods (used via PlatformRegistry)
+    // ============================================================================
+    /**
+     * Create PlatformAdapter objects for each chat platform.
+     * These are lightweight adapters that delegate to this manager.
+     */
+    createPlatformAdapters() {
+        return Object.keys(exports.ADAPTER_FACTORIES).map((name) => this.createPlatformAdapter(name));
+    }
+    createPlatformAdapter(name) {
+        return {
+            name,
+            initialize: async () => {
+                /* no-op: lifecycle managed by ChatInstanceManager */
+            },
+            start: async () => {
+                /* no-op: lifecycle managed by ChatInstanceManager */
+            },
+            stop: async () => {
+                /* no-op: lifecycle managed by ChatInstanceManager */
+            },
+            isHealthy: () => true,
+            buildDeploymentMetadata: (conversationId, channelId, platformMetadata) => (Object.assign({ platform: name, channelId,
+                conversationId }, (typeof platformMetadata.connectionId === "string"
+                ? { connectionId: platformMetadata.connectionId }
+                : {}))),
+            extractRoutingInfo: (body) => this.extractPlatformRoutingInfo(name, body),
+            sendMessage: (_token, message, options) => this.sendPlatformMessage(name, message, options),
+            getConversationHistory: (channelId, conversationId, limit, before) => this.getPlatformConversationHistory(name, channelId, conversationId, limit, before),
+        };
+    }
+    extractPlatformRoutingInfo(name, body) {
+        if (name === "slack") {
+            const slack = body.slack;
+            if (!(slack === null || slack === void 0 ? void 0 : slack.channel))
+                return null;
+            return {
+                channelId: slack.channel,
+                conversationId: slack.thread,
+                teamId: slack.team,
+            };
+        }
+        if (name === "telegram") {
+            const telegram = body.telegram;
+            if (!(telegram === null || telegram === void 0 ? void 0 : telegram.chatId))
+                return null;
+            return {
+                channelId: String(telegram.chatId),
+                conversationId: String(telegram.chatId),
+            };
+        }
+        const whatsapp = body.whatsapp;
+        if (!(whatsapp === null || whatsapp === void 0 ? void 0 : whatsapp.chat))
+            return null;
+        return {
+            channelId: whatsapp.chat,
+            conversationId: whatsapp.chat,
+        };
+    }
+    async sendPlatformMessage(name, message, options) {
+        var _a, _b, _c, _d, _e;
+        if ((_a = options.files) === null || _a === void 0 ? void 0 : _a.length) {
+            throw new Error(`Platform "${name}" does not support file uploads via Chat SDK routing yet`);
+        }
+        const connection = await this.selectConnectionForPlatform(name, options.channelId, options.teamId);
+        if (!connection) {
+            throw new Error(`No active ${name} connection is available`);
+        }
+        const instance = this.getInstance(connection.id);
+        if (!instance) {
+            throw new Error(`Connection ${connection.id} is not running`);
+        }
+        const content = name === "slack" ? message : message.replace(/@me\s*/g, "").trim();
+        if (!content) {
+            throw new Error("Cannot send an empty message");
+        }
+        const useThread = name === "slack" && !!options.conversationId;
+        let sent;
+        if (useThread) {
+            const adapter = (_c = (_b = instance.chat).getAdapter) === null || _c === void 0 ? void 0 : _c.call(_b, connection.platform);
+            const createThread = instance.chat.createThread;
+            const threadId = `${connection.platform}:${options.channelId}:${options.conversationId}`;
+            const thread = adapter && typeof createThread === "function"
+                ? await createThread.call(instance.chat, adapter, threadId, {}, false)
+                : null;
+            if (!thread) {
+                throw new Error(`Unable to resolve ${name} thread`);
+            }
+            sent = await thread.post(content);
+        }
+        else {
+            const channel = (_e = (_d = instance.chat).channel) === null || _e === void 0 ? void 0 : _e.call(_d, `${connection.platform}:${options.channelId}`);
+            if (!channel) {
+                throw new Error(`Unable to resolve ${name} channel`);
+            }
+            sent = await channel.post(content);
+        }
+        return {
+            messageId: String((sent === null || sent === void 0 ? void 0 : sent.id) || (sent === null || sent === void 0 ? void 0 : sent.messageId) || (sent === null || sent === void 0 ? void 0 : sent.ts) || Date.now()),
+        };
+    }
+    async getPlatformConversationHistory(name, channelId, _conversationId, limit, before) {
+        const connection = await this.selectConnectionForPlatform(name, channelId);
+        if (!connection) {
+            return { messages: [], nextCursor: null, hasMore: false };
+        }
+        const redis = this.services.getQueue().getRedisClient();
+        const key = `chat:history:${connection.id}:${channelId}`;
+        const raw = await redis.lrange(key, 0, -1);
+        const parsed = [];
+        for (const entry of raw) {
+            try {
+                parsed.push(JSON.parse(entry));
+            }
+            catch (err) {
+                logger.warn({ key, error: String(err) }, "Skipping corrupt history entry");
+            }
+        }
+        let entries = parsed;
+        if (before) {
+            const cutoff = Date.parse(before);
+            if (!Number.isNaN(cutoff)) {
+                entries = entries.filter((entry) => entry.timestamp < cutoff);
+            }
+        }
+        const hasMore = entries.length > limit;
+        const selected = entries.slice(-limit);
+        const nextCursor = hasMore && selected[0]
+            ? new Date(selected[0].timestamp).toISOString()
+            : null;
+        return {
+            messages: selected.map((entry) => ({
+                timestamp: new Date(entry.timestamp).toISOString(),
+                user: entry.authorName ||
+                    (entry.role === "assistant" ? "assistant" : "user"),
+                text: entry.content,
+                isBot: entry.role === "assistant",
+            })),
+            nextCursor,
+            hasMore,
+        };
+    }
+    async selectConnectionForPlatform(name, channelId, teamId) {
+        const connections = await this.listConnections({ platform: name });
+        const activeConnections = connections.filter((connection) => this.has(connection.id));
+        if (activeConnections.length === 0)
+            return null;
+        if (activeConnections.length === 1)
+            return activeConnections[0] || null;
+        const teamMatch = activeConnections.find((connection) => { var _a; return ((_a = connection.metadata) === null || _a === void 0 ? void 0 : _a.teamId) === teamId; });
+        if (teamMatch)
+            return teamMatch;
+        const redis = this.services.getQueue().getRedisClient();
+        for (const connection of activeConnections) {
+            const exists = await redis.exists(`chat:history:${connection.id}:${channelId}`);
+            if (exists === 1) {
+                return connection;
+            }
+        }
+        return activeConnections[0] || null;
+    }
+}
+exports.ChatInstanceManager = ChatInstanceManager;
+//# sourceMappingURL=chat-instance-manager.js.map