@dobby.ai/dobby 0.1.0 → 0.1.2

package/src/core/gateway.ts

@@ -1,607 +0,0 @@
-import { readFile } from "node:fs/promises";
-import type { ImageContent } from "@mariozechner/pi-ai";
-import { EventForwarder } from "../agent/event-forwarder.js";
-import type { Executor } from "../sandbox/executor.js";
-import { parseControlCommand, type ControlCommand } from "./control-command.js";
-import type { DedupStore } from "./dedup-store.js";
-import { BindingResolver, RouteResolver } from "./routing.js";
-import { RuntimeRegistry } from "./runtime-registry.js";
-import { createTypingKeepAliveController } from "./typing-controller.js";
-import type {
-  BindingResolution,
-  ConnectorPlugin,
-  GatewayAgentRuntime,
-  GatewayConfig,
-  GatewayLogger,
-  InboundAttachment,
-  InboundEnvelope,
-  Platform,
-  PromptPayload,
-  ProviderInstance,
-  RouteResolution,
-} from "./types.js";
-
-interface GatewayOptions {
-  config: GatewayConfig;
-  connectors: ConnectorPlugin[];
-  providers: Map<string, ProviderInstance>;
-  executors: Map<string, Executor>;
-  routeResolver: RouteResolver;
-  bindingResolver: BindingResolver;
-  dedupStore: DedupStore;
-  runtimeRegistry: RuntimeRegistry;
-  logger: GatewayLogger;
-}
-
-interface MessageHandlingOptions {
-  origin: "connector" | "scheduled";
-  useDedup: boolean;
-  stateless: boolean;
-  includeReplyTo: boolean;
-  conversationKeyOverride?: string;
-  routeIdOverride?: string;
-  sessionPolicy?: "shared-session" | "ephemeral";
-  timeoutMs?: number;
-}
-
-interface StopControlEvent {
-  type: "stop";
-  connectorId: string;
-  platform: Platform;
-  accountId: string;
-  chatId: string;
-  threadId?: string;
-}
-
-interface ResolvedMessageRoute {
-  route: RouteResolution;
-  routeId: string;
-  binding?: BindingResolution;
-}
-
-export interface ScheduledExecutionRequest {
-  jobId: string;
-  runId: string;
-  connectorId: string;
-  routeId: string;
-  channelId: string;
-  threadId?: string;
-  prompt: string;
-  timeoutMs?: number;
-}
-
-function isImageAttachment(attachment: InboundAttachment): boolean {
-  return Boolean(attachment.mimeType?.startsWith("image/") && attachment.localPath);
-}
-
-function dedupKey(message: InboundEnvelope): string {
-  return `${message.connectorId}:${message.platform}:${message.accountId}:${message.chatId}:${message.messageId}`;
-}
-
-function conversationKey(message: InboundEnvelope): string {
-  return `${message.connectorId}:${message.platform}:${message.accountId}:${message.chatId}:${message.threadId ?? "root"}`;
-}
-
-export class Gateway {
-  private readonly connectorsById = new Map<string, ConnectorPlugin>();
-  private started = false;
-
-  constructor(private readonly options: GatewayOptions) {
-    for (const connector of options.connectors) {
-      this.connectorsById.set(connector.id, connector);
-    }
-  }
-
-  async start(): Promise<void> {
-    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(): Promise<void> {
-    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: ScheduledExecutionRequest): Promise<void> {
-    const connector = this.connectorsById.get(request.connectorId);
-    if (!connector) {
-      throw new Error(`No connector found for scheduled run '${request.runId}' (${request.connectorId})`);
-    }
-
-    const syntheticInbound: InboundEnvelope = {
-      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 } : {}),
-    });
-  }
-
-  private outboundBaseFromInbound(message: InboundEnvelope): {
-    platform: Platform;
-    accountId: string;
-    chatId: string;
-    threadId?: string;
-  } {
-    return {
-      platform: message.platform,
-      accountId: message.accountId,
-      chatId: message.chatId,
-      ...(message.threadId ? { threadId: message.threadId } : {}),
-    };
-  }
-
-  private outboundBaseFromControl(event: StopControlEvent): {
-    platform: Platform;
-    accountId: string;
-    chatId: string;
-    threadId?: string;
-  } {
-    return {
-      platform: event.platform,
-      accountId: event.accountId,
-      chatId: event.chatId,
-      ...(event.threadId ? { threadId: event.threadId } : {}),
-    };
-  }
-
-  private async sendCommandReply(
-    connector: ConnectorPlugin,
-    message: InboundEnvelope,
-    text: string,
-  ): Promise<void> {
-    await connector.send({
-      ...this.outboundBaseFromInbound(message),
-      mode: "create",
-      text,
-    });
-  }
-
-  private async handleInbound(message: InboundEnvelope): Promise<void> {
-    await this.handleMessage(message, {
-      origin: "connector",
-      useDedup: true,
-      stateless: false,
-      includeReplyTo: true,
-      sessionPolicy: "shared-session",
-    });
-  }
-
-  private resolveMessageRoute(message: InboundEnvelope, handling: MessageHandlingOptions): ResolvedMessageRoute | null {
-    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,
-    };
-  }
-
-  private async handleMessage(message: InboundEnvelope, handling: MessageHandlingOptions): Promise<void> {
-    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,
-        });
-      },
-    );
-  }
-
-  private async processMessage(
-    connector: ConnectorPlugin,
-    runtime: GatewayAgentRuntime,
-    route: RouteResolution,
-    message: InboundEnvelope,
-    options: {
-      includeReplyTo: boolean;
-      timeoutMs?: number;
-    },
-  ): Promise<void> {
-    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: (() => void) | null = 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();
-    }
-  }
-
-  private async promptWithOptionalTimeout(
-    runtime: GatewayAgentRuntime,
-    payload: PromptPayload,
-    timeoutMs?: number,
-  ): Promise<void> {
-    if (timeoutMs === undefined || timeoutMs <= 0) {
-      await runtime.prompt(payload.text, payload.images.length > 0 ? { images: payload.images } : undefined);
-      return;
-    }
-
-    let timer: NodeJS.Timeout | null = null;
-    try {
-      await Promise.race([
-        runtime.prompt(payload.text, payload.images.length > 0 ? { images: payload.images } : undefined),
-        new Promise<never>((_, 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);
-      }
-    }
-  }
-
-  private async buildPromptPayload(message: InboundEnvelope): Promise<PromptPayload> {
-    const textParts: string[] = [];
-    const baseText = message.text.trim();
-    textParts.push(baseText.length > 0 ? baseText : "(empty message)");
-
-    const images: ImageContent[] = [];
-    const otherAttachments: string[] = [];
-
-    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,
-    };
-  }
-
-  private async handleCommand(
-    connector: ConnectorPlugin,
-    message: InboundEnvelope,
-    command: ControlCommand,
-    route: RouteResolution,
-  ): Promise<void> {
-    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._");
-  }
-
-  private async handleControl(event: StopControlEvent): Promise<void> {
-    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");
-    }
-  }
-}