@dobby.ai/dobby 0.1.0

package/plugins/connector-discord/src/connector.ts

@@ -0,0 +1,350 @@
+import {
+  AttachmentBuilder,
+  Client,
+  GatewayIntentBits,
+  Partials,
+  type Message,
+  type MessageCreateOptions,
+  type SendableChannels,
+} from "discord.js";
+import type {
+  ConnectorCapabilities,
+  ConnectorContext,
+  ConnectorPlugin,
+  ConnectorSendResult,
+  ConnectorTypingEnvelope,
+  GatewayLogger,
+  OutboundEnvelope,
+} from "@dobby.ai/plugin-sdk";
+import { mapDiscordMessage } from "./mapper.js";
+
+const DISCORD_MAX_CONTENT_LENGTH = 2000;
+const DEFAULT_RECONNECT_STALE_MS = 60_000;
+const DEFAULT_RECONNECT_CHECK_INTERVAL_MS = 10_000;
+
+export interface DiscordConnectorConfig {
+  botName: string;
+  botToken: string;
+  reconnectStaleMs?: number;
+  reconnectCheckIntervalMs?: number;
+}
+
+function clampDiscordContent(text: string): string {
+  if (text.length <= DISCORD_MAX_CONTENT_LENGTH) {
+    return text;
+  }
+
+  const suffix = "\n...(truncated)";
+  const budget = DISCORD_MAX_CONTENT_LENGTH - suffix.length;
+  if (budget <= 0) {
+    return text.slice(0, DISCORD_MAX_CONTENT_LENGTH);
+  }
+
+  return `${text.slice(0, budget)}${suffix}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object";
+}
+
+export class DiscordConnector implements ConnectorPlugin {
+  readonly id: string;
+  readonly platform = "discord" as const;
+  readonly name = "discord";
+  readonly capabilities: ConnectorCapabilities = {
+    updateStrategy: "edit",
+    supportedSources: ["channel"],
+    supportsThread: true,
+    supportsTyping: true,
+    supportsFileUpload: true,
+    maxTextLength: DISCORD_MAX_CONTENT_LENGTH,
+  };
+
+  private client: Client | null = null;
+  private ctx: ConnectorContext | null = null;
+  private botUserId: string | null = null;
+  private botToken: string | null = null;
+  private reconnectWatchdog: NodeJS.Timeout | null = null;
+  private reconnectInFlight = false;
+  private lastHealthyAtMs = 0;
+  private stopped = false;
+
+  constructor(
+    id: string,
+    private readonly config: DiscordConnectorConfig,
+    private readonly attachmentsRoot: string,
+    private readonly logger: GatewayLogger,
+  ) {
+    this.id = id;
+  }
+
+  async start(ctx: ConnectorContext): Promise<void> {
+    if (this.client) {
+      this.logger.warn({ connectorId: this.id }, "Discord connector start called while already started");
+      return;
+    }
+
+    const token = this.config.botToken.trim();
+    if (!token) {
+      throw new Error("Discord bot token is empty");
+    }
+
+    this.ctx = ctx;
+    this.botToken = token;
+    this.stopped = false;
+    this.lastHealthyAtMs = Date.now();
+
+    this.client = this.createClient();
+    this.bindClientEventHandlers(this.client);
+    await this.client.login(token);
+    this.startReconnectWatchdog();
+  }
+
+  async send(message: OutboundEnvelope): Promise<ConnectorSendResult> {
+    if (!this.client) {
+      throw new Error("Discord connector is not started");
+    }
+
+    const channel = await this.fetchTextChannel(message.chatId);
+    const content = clampDiscordContent(message.text);
+    if (content !== message.text) {
+      this.logger.warn(
+        {
+          originalLength: message.text.length,
+          truncatedLength: content.length,
+          mode: message.mode,
+          chatId: message.chatId,
+        },
+        "Outbound Discord message exceeded 2000 characters and was truncated",
+      );
+    }
+
+    if (message.mode === "update") {
+      if (!message.targetMessageId) {
+        throw new Error("targetMessageId is required for update mode");
+      }
+
+      const existing = await channel.messages.fetch(message.targetMessageId);
+      const edited = await existing.edit({ content });
+      return { messageId: edited.id };
+    }
+
+    const options: MessageCreateOptions = {
+      content,
+    };
+
+    if (message.replyToMessageId) {
+      options.reply = { messageReference: message.replyToMessageId, failIfNotExists: false };
+    }
+
+    if (message.attachments && message.attachments.length > 0) {
+      options.files = message.attachments.map((attachment) =>
+        attachment.title
+          ? new AttachmentBuilder(attachment.localPath, { name: attachment.title })
+          : new AttachmentBuilder(attachment.localPath),
+      );
+    }
+
+    const sent = await channel.send(options);
+    return { messageId: sent.id };
+  }
+
+  async sendTyping(message: ConnectorTypingEnvelope): Promise<void> {
+    if (!this.client) {
+      throw new Error("Discord connector is not started");
+    }
+
+    const channel = await this.fetchTextChannel(message.chatId);
+    await channel.sendTyping();
+  }
+
+  async stop(): Promise<void> {
+    this.stopped = true;
+    this.stopReconnectWatchdog();
+    this.reconnectInFlight = false;
+    if (!this.client) return;
+
+    const client = this.client;
+    this.client = null;
+    client.removeAllListeners();
+    client.destroy();
+    this.ctx = null;
+    this.botUserId = null;
+    this.botToken = null;
+    this.lastHealthyAtMs = 0;
+  }
+
+  private createClient(): Client {
+    return new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+      ],
+      partials: [Partials.Channel, Partials.Message],
+    });
+  }
+
+  private bindClientEventHandlers(client: Client): void {
+    client.once("clientReady", () => {
+      if (client !== this.client || !client.user) return;
+      this.botUserId = client.user.id;
+      this.lastHealthyAtMs = Date.now();
+      this.logger.info(
+        {
+          userId: this.botUserId,
+          userName: client.user.username,
+          configuredBotName: this.config.botName,
+        },
+        "Discord connector ready",
+      );
+    });
+
+    client.on("shardDisconnect", (event, shardId) => {
+      if (client !== this.client) return;
+      this.logger.warn(
+        {
+          shardId,
+          reconnecting: client.ws.shards.get(shardId)?.status === 5,
+          ...this.parseCloseEvent(event),
+        },
+        "Discord shard disconnected",
+      );
+    });
+
+    client.on("shardReconnecting", (shardId) => {
+      if (client !== this.client) return;
+      this.logger.warn({ shardId }, "Discord shard reconnecting");
+    });
+
+    client.on("shardResume", (shardId, replayedEvents) => {
+      if (client !== this.client) return;
+      this.lastHealthyAtMs = Date.now();
+      this.logger.info({ shardId, replayedEvents }, "Discord shard resumed");
+    });
+
+    client.on("error", (error) => {
+      if (client !== this.client) return;
+      this.logger.warn({ err: error }, "Discord client error");
+    });
+
+    client.on("shardError", (error, shardId) => {
+      if (client !== this.client) return;
+      this.logger.warn({ err: error, shardId }, "Discord shard error");
+    });
+
+    client.on("invalidated", () => {
+      if (client !== this.client) return;
+      this.logger.error("Discord session invalidated; forcing reconnect");
+      void this.forceReconnect("session_invalidated");
+    });
+
+    client.on("messageCreate", async (message: Message) => {
+      if (client !== this.client || !client.user || !this.ctx || !this.botUserId) return;
+
+      // v1 explicitly disables DM handling; only bound guild channels are processed.
+      if (!message.guildId) {
+        return;
+      }
+
+      if (message.author.bot) return;
+
+      const sourceId = message.channel.isThread() && message.channel.parentId ? message.channel.parentId : message.channelId;
+
+      const inbound = await mapDiscordMessage(
+        message,
+        this.id,
+        this.botUserId,
+        sourceId,
+        this.attachmentsRoot,
+        this.logger,
+      );
+      if (!inbound) return;
+
+      await this.ctx.emitInbound(inbound);
+    });
+  }
+
+  private startReconnectWatchdog(): void {
+    if (this.reconnectWatchdog) return;
+    const intervalMs = this.config.reconnectCheckIntervalMs ?? DEFAULT_RECONNECT_CHECK_INTERVAL_MS;
+    this.reconnectWatchdog = setInterval(() => {
+      void this.ensureConnected();
+    }, intervalMs);
+  }
+
+  private stopReconnectWatchdog(): void {
+    if (!this.reconnectWatchdog) return;
+    clearInterval(this.reconnectWatchdog);
+    this.reconnectWatchdog = null;
+  }
+
+  private async ensureConnected(): Promise<void> {
+    const client = this.client;
+    if (!client || this.stopped || this.reconnectInFlight) return;
+
+    if (client.isReady()) {
+      this.lastHealthyAtMs = Date.now();
+      return;
+    }
+
+    const staleMs = Date.now() - this.lastHealthyAtMs;
+    const thresholdMs = this.config.reconnectStaleMs ?? DEFAULT_RECONNECT_STALE_MS;
+    if (staleMs < thresholdMs) {
+      return;
+    }
+
+    this.logger.warn({ staleMs, thresholdMs }, "Discord connector remained not-ready for too long; forcing reconnect");
+    await this.forceReconnect("watchdog_not_ready");
+  }
+
+  private async forceReconnect(reason: string): Promise<void> {
+    if (this.stopped || this.reconnectInFlight || !this.botToken) {
+      return;
+    }
+
+    this.reconnectInFlight = true;
+    const previousClient = this.client;
+
+    try {
+      if (previousClient) {
+        previousClient.removeAllListeners();
+        previousClient.destroy();
+      }
+
+      this.botUserId = null;
+      this.lastHealthyAtMs = Date.now();
+
+      const nextClient = this.createClient();
+      this.client = nextClient;
+      this.bindClientEventHandlers(nextClient);
+      await nextClient.login(this.botToken);
+      this.logger.info({ reason }, "Discord reconnect login submitted");
+    } catch (error) {
+      this.logger.error({ err: error, reason }, "Failed to force Discord reconnect");
+    } finally {
+      this.reconnectInFlight = false;
+    }
+  }
+
+  private parseCloseEvent(event: unknown): Record<string, unknown> {
+    if (!isRecord(event)) return {};
+    const result: Record<string, unknown> = {};
+    if (typeof event.code === "number") result.code = event.code;
+    if (typeof event.reason === "string" && event.reason.length > 0) result.reason = event.reason;
+    if (typeof event.wasClean === "boolean") result.wasClean = event.wasClean;
+    return result;
+  }
+
+  private async fetchTextChannel(channelId: string): Promise<SendableChannels> {
+    if (!this.client) throw new Error("Discord connector is not started");
+
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel || !channel.isSendable()) {
+      throw new Error(`Discord channel '${channelId}' is not text-based`);
+    }
+
+    return channel;
+  }
+}

package/plugins/connector-discord/src/contribution.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { ConnectorContributionModule } from "@dobby.ai/plugin-sdk";
+import { DiscordConnector, type DiscordConnectorConfig } from "./connector.js";
+
+const discordConnectorConfigSchema = z.object({
+  botName: z.string().min(1),
+  botToken: z.string().min(1),
+  reconnectStaleMs: z.number().int().positive().default(60_000),
+  reconnectCheckIntervalMs: z.number().int().positive().default(10_000),
+});
+
+export const connectorDiscordContribution: ConnectorContributionModule = {
+  kind: "connector",
+  configSchema: z.toJSONSchema(discordConnectorConfigSchema),
+  createInstance(options) {
+    const config = discordConnectorConfigSchema.parse(options.config) as DiscordConnectorConfig;
+    return new DiscordConnector(options.instanceId, config, options.attachmentsRoot, options.host.logger);
+  },
+};
+
+export default connectorDiscordContribution;

package/plugins/connector-discord/src/mapper.ts

@@ -0,0 +1,102 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Message } from "discord.js";
+import type { GatewayLogger, InboundAttachment, InboundEnvelope } from "@dobby.ai/plugin-sdk";
+
+function stripBotMention(text: string, botUserId: string): string {
+  const mentionRegex = new RegExp(`<@!?${botUserId}>`, "g");
+  return text.replace(mentionRegex, "").trim();
+}
+
+function sanitizeFileName(value: string): string {
+  return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+async function downloadAttachment(url: string, targetPath: string): Promise<void> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download attachment from ${url}: ${response.status}`);
+  }
+
+  const data = await response.arrayBuffer();
+  await writeFile(targetPath, Buffer.from(data));
+}
+
+function mapAttachmentBase(messageAttachment: {
+  id: string;
+  name: string | null;
+  contentType: string | null;
+  size: number;
+  url: string;
+}): InboundAttachment {
+  return {
+    id: messageAttachment.id,
+    size: messageAttachment.size,
+    remoteUrl: messageAttachment.url,
+    ...(messageAttachment.name ? { fileName: messageAttachment.name } : {}),
+    ...(messageAttachment.contentType ? { mimeType: messageAttachment.contentType } : {}),
+  };
+}
+
+export async function mapDiscordMessage(
+  message: Message,
+  connectorId: string,
+  botUserId: string,
+  sourceId: string,
+  attachmentsRoot: string,
+  logger: GatewayLogger,
+): Promise<InboundEnvelope | null> {
+  if (message.author.bot) return null;
+
+  const isDirectMessage = message.guildId == null;
+  const mentionedBot = message.mentions.users.has(botUserId);
+
+  const chatId = message.channelId;
+  const threadId = message.channel.isThread() ? message.channelId : undefined;
+
+  const cleanedText = stripBotMention(message.content ?? "", botUserId);
+
+  const attachmentDir = join(attachmentsRoot, sourceId, message.id);
+  await mkdir(attachmentDir, { recursive: true });
+
+  const attachments: InboundAttachment[] = [];
+
+  for (const attachment of message.attachments.values()) {
+    const base = mapAttachmentBase(attachment);
+    const fileName = sanitizeFileName(attachment.name ?? attachment.id);
+    const localPath = join(attachmentDir, fileName);
+
+    try {
+      await downloadAttachment(attachment.url, localPath);
+      attachments.push({
+        ...base,
+        localPath,
+      });
+    } catch (error) {
+      logger.warn({ err: error, attachmentUrl: attachment.url }, "Failed to download Discord attachment; keeping metadata only");
+      attachments.push(base);
+    }
+  }
+
+  return {
+    connectorId,
+    platform: "discord",
+    accountId: botUserId,
+    source: {
+      type: "channel",
+      id: sourceId,
+    },
+    chatId,
+    messageId: message.id,
+    userId: message.author.id,
+    userName: message.author.username,
+    text: cleanedText,
+    attachments,
+    timestampMs: message.createdTimestamp,
+    raw: message.toJSON(),
+    isDirectMessage,
+    mentionedBot,
+    ...(message.guildId ? { guildId: message.guildId } : {}),
+    ...(threadId ? { threadId } : {}),
+  };
+}

package/plugins/connector-discord/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/plugins/connector-feishu/dobby.manifest.json

@@ -0,0 +1,18 @@
+{
+  "apiVersion": "1.0",
+  "name": "@dobby.ai/connector-feishu",
+  "version": "0.1.0",
+  "contributions": [
+    {
+      "id": "connector.feishu",
+      "kind": "connector",
+      "entry": "./dist/contribution.js",
+      "capabilities": {
+        "updateStrategy": "edit",
+        "supportsThread": true,
+        "supportsTyping": false,
+        "supportsFileUpload": false
+      }
+    }
+  ]
+}

package/plugins/connector-feishu/index.js

@@ -0,0 +1 @@
+export { connectorFeishuContribution as contribution, connectorFeishuContribution as default } from "./dist/contribution.js";