@dobby.ai/dobby 0.1.0

package/dist/src/core/gateway.js

@@ -0,0 +1,432 @@
+import { readFile } from "node:fs/promises";
+import { EventForwarder } from "../agent/event-forwarder.js";
+import { parseControlCommand } from "./control-command.js";
+import { createTypingKeepAliveController } from "./typing-controller.js";
+function isImageAttachment(attachment) {
+    return Boolean(attachment.mimeType?.startsWith("image/") && attachment.localPath);
+}
+function dedupKey(message) {
+    return `${message.connectorId}:${message.platform}:${message.accountId}:${message.chatId}:${message.messageId}`;
+}
+function conversationKey(message) {
+    return `${message.connectorId}:${message.platform}:${message.accountId}:${message.chatId}:${message.threadId ?? "root"}`;
+}
+export class Gateway {
+    options;
+    connectorsById = new Map();
+    started = false;
+    constructor(options) {
+        this.options = options;
+        for (const connector of options.connectors) {
+            this.connectorsById.set(connector.id, connector);
+        }
+    }
+    async start() {
+        if (this.started)
+            return;
+        await this.options.dedupStore.load();
+        this.options.dedupStore.startAutoFlush();
+        for (const connector of this.options.connectors) {
+            await connector.start({
+                emitInbound: async (message) => this.handleInbound(message),
+                emitControl: async (event) => this.handleControl(event),
+            });
+        }
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        for (const connector of this.options.connectors) {
+            await connector.stop();
+        }
+        this.options.dedupStore.stopAutoFlush();
+        await this.options.dedupStore.flush();
+        await this.options.runtimeRegistry.closeAll();
+        this.started = false;
+    }
+    async handleScheduled(request) {
+        const connector = this.connectorsById.get(request.connectorId);
+        if (!connector) {
+            throw new Error(`No connector found for scheduled run '${request.runId}' (${request.connectorId})`);
+        }
+        const syntheticInbound = {
+            connectorId: request.connectorId,
+            platform: connector.platform,
+            accountId: request.connectorId,
+            source: {
+                type: "chat",
+                id: request.channelId,
+            },
+            chatId: request.channelId,
+            ...(request.threadId ? { threadId: request.threadId } : {}),
+            messageId: `cron:${request.runId}`,
+            userId: "cron",
+            userName: "cron",
+            text: request.prompt,
+            attachments: [],
+            timestampMs: Date.now(),
+            raw: {
+                type: "cron",
+                jobId: request.jobId,
+                runId: request.runId,
+            },
+            isDirectMessage: false,
+            mentionedBot: true,
+        };
+        await this.handleMessage(syntheticInbound, {
+            origin: "scheduled",
+            useDedup: true,
+            stateless: true,
+            includeReplyTo: false,
+            conversationKeyOverride: `cron:${request.runId}`,
+            routeIdOverride: request.routeId,
+            sessionPolicy: "ephemeral",
+            ...(request.timeoutMs !== undefined ? { timeoutMs: request.timeoutMs } : {}),
+        });
+    }
+    outboundBaseFromInbound(message) {
+        return {
+            platform: message.platform,
+            accountId: message.accountId,
+            chatId: message.chatId,
+            ...(message.threadId ? { threadId: message.threadId } : {}),
+        };
+    }
+    outboundBaseFromControl(event) {
+        return {
+            platform: event.platform,
+            accountId: event.accountId,
+            chatId: event.chatId,
+            ...(event.threadId ? { threadId: event.threadId } : {}),
+        };
+    }
+    async sendCommandReply(connector, message, text) {
+        await connector.send({
+            ...this.outboundBaseFromInbound(message),
+            mode: "create",
+            text,
+        });
+    }
+    async handleInbound(message) {
+        await this.handleMessage(message, {
+            origin: "connector",
+            useDedup: true,
+            stateless: false,
+            includeReplyTo: true,
+            sessionPolicy: "shared-session",
+        });
+    }
+    resolveMessageRoute(message, handling) {
+        const overrideRouteId = handling.routeIdOverride?.trim();
+        if (overrideRouteId) {
+            const route = this.options.routeResolver.resolve(overrideRouteId);
+            if (!route) {
+                return null;
+            }
+            return {
+                routeId: overrideRouteId,
+                route,
+            };
+        }
+        const binding = this.options.bindingResolver.resolve(message.connectorId, message.source);
+        if (!binding) {
+            if (handling.origin === "connector") {
+                this.options.logger.debug({
+                    connectorId: message.connectorId,
+                    sourceType: message.source.type,
+                    sourceId: message.source.id,
+                }, "Ignoring inbound message from unbound source");
+            }
+            return null;
+        }
+        const route = this.options.routeResolver.resolve(binding.config.route);
+        if (!route) {
+            return null;
+        }
+        return {
+            routeId: binding.config.route,
+            route,
+            binding,
+        };
+    }
+    async handleMessage(message, handling) {
+        const connector = this.connectorsById.get(message.connectorId);
+        if (!connector) {
+            this.options.logger.warn({ connectorId: message.connectorId }, "No connector found for inbound message");
+            return;
+        }
+        if (handling.useDedup) {
+            const key = dedupKey(message);
+            if (this.options.dedupStore.has(key)) {
+                this.options.logger.debug({ dedupKey: key }, "Skipping duplicate message");
+                return;
+            }
+            this.options.dedupStore.add(key);
+        }
+        const resolvedRoute = this.resolveMessageRoute(message, handling);
+        if (!resolvedRoute) {
+            if (handling.routeIdOverride) {
+                await connector.send({
+                    ...this.outboundBaseFromInbound(message),
+                    mode: "create",
+                    ...(handling.includeReplyTo ? { replyToMessageId: message.messageId } : {}),
+                    text: `No route configured for route '${handling.routeIdOverride}'.`,
+                });
+            }
+            return;
+        }
+        if (handling.origin === "connector") {
+            const command = parseControlCommand(message.text);
+            if (command) {
+                try {
+                    await this.handleCommand(connector, message, command, resolvedRoute.route);
+                }
+                catch (error) {
+                    this.options.logger.error({ err: error, messageId: message.messageId }, "Failed to handle control command");
+                    await this.sendCommandReply(connector, message, `Error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
+            }
+        }
+        const { route } = resolvedRoute;
+        if (route.profile.mentions === "required" && !message.isDirectMessage && !message.mentionedBot) {
+            this.options.logger.debug({
+                sourceType: message.source.type,
+                sourceId: message.source.id,
+                routeId: route.routeId,
+            }, "Ignoring non-mention message");
+            return;
+        }
+        const providerId = route.profile.provider;
+        const sandboxId = route.profile.sandbox;
+        const provider = this.options.providers.get(providerId);
+        const executor = this.options.executors.get(sandboxId);
+        if (!provider || !executor) {
+            await connector.send({
+                ...this.outboundBaseFromInbound(message),
+                mode: "create",
+                ...(handling.includeReplyTo ? { replyToMessageId: message.messageId } : {}),
+                text: `Route runtime not available (provider='${providerId}', sandbox='${sandboxId}')`,
+            });
+            return;
+        }
+        const convKey = handling.conversationKeyOverride ?? conversationKey(message);
+        if (handling.stateless) {
+            const runtime = await provider.createRuntime({
+                conversationKey: convKey,
+                route,
+                inbound: message,
+                executor,
+                ...(handling.sessionPolicy ? { sessionPolicy: handling.sessionPolicy } : {}),
+            });
+            try {
+                await this.processMessage(connector, runtime, route, message, {
+                    includeReplyTo: handling.includeReplyTo,
+                    ...(handling.timeoutMs !== undefined ? { timeoutMs: handling.timeoutMs } : {}),
+                });
+            }
+            finally {
+                runtime.dispose();
+            }
+            return;
+        }
+        await this.options.runtimeRegistry.run(convKey, async () => {
+            const runtime = await provider.createRuntime({
+                conversationKey: convKey,
+                route,
+                inbound: message,
+                executor,
+                ...(handling.sessionPolicy ? { sessionPolicy: handling.sessionPolicy } : {}),
+            });
+            return {
+                key: convKey,
+                routeId: route.routeId,
+                route: route.profile,
+                providerId,
+                sandboxId,
+                runtime,
+                close: async () => {
+                    runtime.dispose();
+                },
+            };
+        }, async (runtime) => {
+            await this.processMessage(connector, runtime.runtime, route, message, {
+                includeReplyTo: handling.includeReplyTo,
+            });
+        });
+    }
+    async processMessage(connector, runtime, route, message, options) {
+        this.options.logger.info({
+            connectorId: message.connectorId,
+            routeId: route.routeId,
+            sourceType: message.source.type,
+            sourceId: message.source.id,
+            chatId: message.chatId,
+            threadId: message.threadId,
+            messageId: message.messageId,
+        }, "Processing inbound message");
+        const typingController = createTypingKeepAliveController(connector, message, this.options.logger);
+        let unsubscribe = null;
+        const forwarder = new EventForwarder(connector, message, null, this.options.logger, {
+            onOutboundActivity: typingController.markVisibleOutput,
+        });
+        try {
+            await typingController.prime();
+            unsubscribe = runtime.subscribe(forwarder.handleEvent);
+            const payload = await this.buildPromptPayload(message);
+            this.options.logger.info({
+                routeId: route.routeId,
+                messageId: message.messageId,
+                rootMessageId: forwarder.primaryMessageId() ?? null,
+                hasImages: payload.images.length > 0,
+                textLength: payload.text.length,
+            }, "Starting provider prompt");
+            await this.promptWithOptionalTimeout(runtime, payload, options.timeoutMs);
+            this.options.logger.info({
+                routeId: route.routeId,
+                messageId: message.messageId,
+                rootMessageId: forwarder.primaryMessageId() ?? null,
+            }, "Provider prompt finished");
+            await forwarder.finalize();
+            this.options.logger.info({ routeId: route.routeId, messageId: message.messageId }, "Inbound message processed");
+        }
+        catch (error) {
+            this.options.logger.error({ err: error, routeId: route.routeId }, "Failed to process inbound message");
+            const rootMessageId = forwarder.primaryMessageId();
+            const canEditExisting = connector.capabilities.updateStrategy === "edit" && rootMessageId !== null;
+            await connector.send(canEditExisting
+                ? {
+                    ...this.outboundBaseFromInbound(message),
+                    mode: "update",
+                    targetMessageId: rootMessageId,
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                }
+                : {
+                    ...this.outboundBaseFromInbound(message),
+                    mode: "create",
+                    ...(rootMessageId
+                        ? { replyToMessageId: rootMessageId }
+                        : options.includeReplyTo
+                            ? { replyToMessageId: message.messageId }
+                            : {}),
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                });
+        }
+        finally {
+            unsubscribe?.();
+            typingController.stop();
+        }
+    }
+    async promptWithOptionalTimeout(runtime, payload, timeoutMs) {
+        if (timeoutMs === undefined || timeoutMs <= 0) {
+            await runtime.prompt(payload.text, payload.images.length > 0 ? { images: payload.images } : undefined);
+            return;
+        }
+        let timer = null;
+        try {
+            await Promise.race([
+                runtime.prompt(payload.text, payload.images.length > 0 ? { images: payload.images } : undefined),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        void runtime.abort().catch(() => {
+                            // Best-effort abort on timeout.
+                        });
+                        reject(new Error(`Cron run timed out after ${timeoutMs}ms`));
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    async buildPromptPayload(message) {
+        const textParts = [];
+        const baseText = message.text.trim();
+        textParts.push(baseText.length > 0 ? baseText : "(empty message)");
+        const images = [];
+        const otherAttachments = [];
+        for (const attachment of message.attachments) {
+            if (isImageAttachment(attachment) && attachment.localPath && attachment.mimeType) {
+                try {
+                    const buffer = await readFile(attachment.localPath);
+                    images.push({
+                        type: "image",
+                        mimeType: attachment.mimeType,
+                        data: buffer.toString("base64"),
+                    });
+                    continue;
+                }
+                catch (error) {
+                    this.options.logger.warn({ err: error, attachment: attachment.localPath }, "Failed to read image attachment");
+                }
+            }
+            if (attachment.localPath) {
+                otherAttachments.push(attachment.localPath);
+            }
+            else if (attachment.remoteUrl) {
+                otherAttachments.push(attachment.remoteUrl);
+            }
+        }
+        if (otherAttachments.length > 0) {
+            textParts.push(`<attachments>\n${otherAttachments.join("\n")}\n</attachments>`);
+        }
+        return {
+            text: textParts.join("\n\n"),
+            images,
+        };
+    }
+    async handleCommand(connector, message, command, route) {
+        const convKey = conversationKey(message);
+        if (command === "cancel") {
+            const cancelled = await this.options.runtimeRegistry.cancel(convKey);
+            this.options.logger.info({ conversationKey: convKey, cancelled }, "Conversation cancel requested");
+            await this.sendCommandReply(connector, message, cancelled ? "_Cancelled current session tasks._" : "_No active or queued session tasks to cancel._");
+            return;
+        }
+        const providerId = route.profile.provider;
+        const provider = this.options.providers.get(providerId);
+        if (!provider) {
+            throw new Error(`Route provider not available (provider='${providerId}')`);
+        }
+        if (!provider.archiveSession) {
+            throw new Error(`Provider '${providerId}' does not support session archival`);
+        }
+        const hadRuntime = await this.options.runtimeRegistry.reset(convKey);
+        const archiveResult = await provider.archiveSession({
+            conversationKey: convKey,
+            inbound: message,
+            sessionPolicy: "shared-session",
+            archivedAtMs: message.timestampMs,
+        });
+        this.options.logger.info({
+            conversationKey: convKey,
+            providerId,
+            hadRuntime,
+            archived: archiveResult.archived,
+            archivePath: archiveResult.archivePath ?? null,
+        }, "New session requested");
+        await this.sendCommandReply(connector, message, "_Started a new session._");
+    }
+    async handleControl(event) {
+        const convKey = `${event.connectorId}:${event.platform}:${event.accountId}:${event.chatId}:${event.threadId ?? "root"}`;
+        const connector = this.connectorsById.get(event.connectorId);
+        const cancelled = await this.options.runtimeRegistry.cancel(convKey);
+        this.options.logger.info({ conversationKey: convKey, cancelled }, "Stop requested");
+        if (!connector)
+            return;
+        try {
+            await connector.send({
+                ...this.outboundBaseFromControl(event),
+                mode: "create",
+                text: cancelled ? "_Cancelled current session tasks._" : "_No active or queued session tasks to cancel._",
+            });
+        }
+        catch (error) {
+            this.options.logger.warn({ err: error, conversationKey: convKey }, "Failed to send stop acknowledgement");
+        }
+    }
+}