@dobby.ai/dobby 0.1.0 → 0.1.2

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

@@ -1,350 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,19 +0,0 @@
-{
-  "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

@@ -1,18 +0,0 @@
-{
-  "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

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