myaiforone 1.0.0

package/src/channels/discord.ts

@@ -0,0 +1,129 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { Client, GatewayIntentBits, AttachmentBuilder } from "discord.js";
+import type { Message as DiscordMessage } from "discord.js";
+import type { ChannelDriver, InboundMessage, OutboundMessage } from "./types.js";
+import { splitText } from "./types.js";
+import { log } from "../logger.js";
+
+export class DiscordDriver implements ChannelDriver {
+  readonly channelId = "discord";
+
+  private client: Client;
+  private botToken: string;
+  private messageHandler: ((msg: InboundMessage) => Promise<void>) | null = null;
+  private botUserId: string | null = null;
+
+  constructor(config: Record<string, unknown>) {
+    const botToken = config.botToken as string;
+    if (!botToken) {
+      throw new Error("Discord driver requires botToken in config");
+    }
+    this.botToken = botToken;
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+      ],
+    });
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.client.once("ready", () => {
+        this.botUserId = this.client.user?.id ?? null;
+        log.info(`Discord bot authenticated as ${this.client.user?.tag} (${this.botUserId})`);
+        resolve();
+      });
+
+      this.client.on("messageCreate", (msg) => this.handleMessage(msg));
+
+      this.client.on("error", (err) => {
+        log.error(`Discord error: ${err.message}`);
+      });
+
+      this.client.login(this.botToken).catch(reject);
+      log.info("Discord driver started — listening for messages");
+    });
+  }
+
+  async stop(): Promise<void> {
+    await this.client.destroy();
+    log.info("Discord driver stopped");
+  }
+
+  onMessage(handler: (msg: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  async send(msg: OutboundMessage): Promise<void> {
+    const channel = await this.client.channels.fetch(msg.chatId);
+    if (!channel?.isTextBased()) return;
+
+    const textChannel = channel as any;
+    const chunks = splitText(msg.text, 2000); // Discord limit
+    for (const chunk of chunks) {
+      await textChannel.send(chunk);
+    }
+  }
+
+  async sendTyping(chatId: string): Promise<void> {
+    try {
+      const channel = await this.client.channels.fetch(chatId);
+      if (channel?.isTextBased()) {
+        await (channel as any).sendTyping();
+      }
+    } catch { /* ignore */ }
+  }
+
+  async sendFile(chatId: string, filePath: string, caption?: string): Promise<void> {
+    try {
+      const channel = await this.client.channels.fetch(chatId);
+      if (!channel?.isTextBased()) return;
+
+      const attachment = new AttachmentBuilder(filePath);
+      await (channel as any).send({
+        content: caption || undefined,
+        files: [attachment],
+      });
+    } catch (err) {
+      log.warn(`Failed to send file to Discord: ${err}`);
+    }
+  }
+
+  private async handleMessage(msg: DiscordMessage): Promise<void> {
+    if (msg.author.id === this.botUserId) return;
+    if (msg.author.bot) return;
+    if (!msg.content?.trim()) return;
+
+    const isGroup = msg.guild !== null;
+
+    const inbound: InboundMessage = {
+      id: msg.id,
+      channel: this.channelId,
+      chatId: msg.channelId,
+      chatType: isGroup ? "group" : "dm",
+      sender: msg.author.id,
+      senderName: msg.author.displayName || msg.author.username,
+      text: msg.content,
+      timestamp: msg.createdTimestamp,
+      isFromMe: false,
+      isGroup,
+      groupName: msg.guild?.name,
+      replyTo: msg.reference?.messageId
+        ? { id: msg.reference.messageId, text: "" }
+        : undefined,
+      raw: msg,
+    };
+
+    log.debug(`Discord received from ${msg.author.username} in ${msg.channelId}: ${msg.content.slice(0, 100)}`);
+
+    if (this.messageHandler) {
+      this.messageHandler(inbound).catch((err) => {
+        log.error(`Discord message handler error: ${err}`);
+      });
+    }
+  }
+}

package/src/channels/imessage.ts

@@ -0,0 +1,261 @@
+import type { ChannelDriver, InboundMessage, OutboundMessage } from "./types.js";
+import { splitText } from "./types.js";
+import { ImsgRpcClient } from "../utils/imsg-rpc.js";
+import { getRecentMessages, getLatestRowId } from "../utils/imsg-db-reader.js";
+import { log } from "../logger.js";
+
+interface ImsgMessage {
+  id: number;
+  sender: string;
+  text: string;
+  chat_id: number;
+  chat_guid: string;
+  chat_name: string | null;
+  is_group: boolean;
+  is_from_me: boolean;
+  participants: string[];
+  created_at: string;
+  reply_to_text: string | null;
+  reply_to_sender: string | null;
+  reply_to_id: number | null;
+  attachments: Array<{ path: string; mime_type?: string }>;
+}
+
+interface DebounceEntry {
+  messages: ImsgMessage[];
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class IMessageDriver implements ChannelDriver {
+  readonly channelId = "imessage";
+
+  private client: ImsgRpcClient;
+  private messageHandler: ((msg: InboundMessage) => Promise<void>) | null = null;
+  private debounceMap = new Map<string, DebounceEntry>();
+  private debounceMs: number;
+  private dbPollInterval: ReturnType<typeof setInterval> | null = null;
+  private dbPollRowIds = new Map<number, number>(); // chatId -> lastRowId
+  private monitoredChatIds: number[] = [];
+  private recentlySent = new Map<string, number>(); // text -> timestamp (for echo filtering)
+
+  constructor(config: Record<string, unknown>) {
+    const cliPath = (config.cliPath as string) ?? "imsg";
+    this.debounceMs = (config.debounceMs as number) ?? 2000;
+    this.monitoredChatIds = ((config.monitoredChatIds as number[]) ?? []);
+    this.client = new ImsgRpcClient(cliPath);
+  }
+
+  async start(): Promise<void> {
+    await this.client.start();
+
+    this.client.onNotification((notification) => {
+      if (notification.method === "message") {
+        const raw = (notification.params as { message: ImsgMessage }).message;
+        this.handleRawMessage(raw);
+      }
+    });
+
+    // Subscribe to message watch (attachments enabled for image support)
+    await this.client.request("watch.subscribe", { attachments: true });
+
+    // DB polling fallback — macOS 15+ stores text in attributedBody, not text column
+    // imsg watch may miss these messages, so we poll the DB directly
+    this.startDbPolling();
+
+    log.info("iMessage driver started — watching for messages + DB polling");
+  }
+
+  async stop(): Promise<void> {
+    if (this.dbPollInterval) {
+      clearInterval(this.dbPollInterval);
+      this.dbPollInterval = null;
+    }
+    for (const [, entry] of this.debounceMap) {
+      clearTimeout(entry.timer);
+    }
+    this.debounceMap.clear();
+
+    await this.client.stop();
+    log.info("iMessage driver stopped");
+  }
+
+  private startDbPolling(): void {
+    // Discover chat IDs to monitor from config routes
+    // If monitoredChatIds not set, we'll pick them up dynamically
+    // Initialize last-seen rowid for each chat
+    for (const chatId of this.monitoredChatIds) {
+      this.dbPollRowIds.set(chatId, getLatestRowId(chatId));
+    }
+
+    // Poll every 3 seconds
+    this.dbPollInterval = setInterval(() => {
+      this.pollDb();
+    }, 3000);
+  }
+
+  private pollDb(): void {
+    // Also discover chat IDs dynamically from recent messages if not configured
+    if (this.monitoredChatIds.length === 0) return;
+
+    for (const chatId of this.monitoredChatIds) {
+      const lastRowId = this.dbPollRowIds.get(chatId) || 0;
+      const messages = getRecentMessages(chatId, lastRowId);
+
+      for (const msg of messages) {
+        // Update last seen
+        if (msg.rowid > (this.dbPollRowIds.get(chatId) || 0)) {
+          this.dbPollRowIds.set(chatId, msg.rowid);
+        }
+
+        // Skip empty
+        if (!msg.text.trim()) continue;
+
+        // Skip bot's own messages — check against recently sent texts
+        // Use fuzzy match: attributedBody extraction can prepend/append garbage bytes
+        const msgTrimmed = msg.text.trim();
+        let isEcho = false;
+        for (const [sentText, ts] of this.recentlySent) {
+          // Match if either contains the other, or first 30 chars match
+          if (sentText === msgTrimmed ||
+              sentText.includes(msgTrimmed) ||
+              msgTrimmed.includes(sentText) ||
+              (msgTrimmed.length > 30 && sentText.startsWith(msgTrimmed.slice(0, 30))) ||
+              (msgTrimmed.length > 30 && sentText.includes(msgTrimmed.slice(1, 31)))) {
+            this.recentlySent.delete(sentText);
+            isEcho = true;
+            break;
+          }
+        }
+        if (isEcho) {
+          log.debug(`iMessage DB poll: skipping echo "${msg.text.slice(0, 40)}..."`);
+          continue;
+        }
+
+        // Build an InboundMessage and pass to handler
+        const inbound: InboundMessage = {
+          id: String(msg.rowid),
+          channel: this.channelId,
+          chatId: String(chatId),
+          chatType: "group",
+          sender: msg.sender || "unknown",
+          text: msg.text,
+          timestamp: new Date(msg.createdAt).getTime(),
+          // Always false — user's phone shares Apple ID with this Mac,
+          // so all messages appear as is_from_me in the DB.
+          // Echo prevention is handled in index.ts via recentBotMessages.
+          isFromMe: false,
+          isGroup: true,
+          raw: msg,
+        };
+
+        log.debug(`iMessage DB poll: ${msg.sender} in chat ${chatId}: ${msg.text.slice(0, 80)}`);
+
+        if (this.messageHandler) {
+          this.messageHandler(inbound).catch((err) => {
+            log.error(`iMessage DB poll handler error: ${err}`);
+          });
+        }
+      }
+    }
+  }
+
+  onMessage(handler: (msg: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  async send(msg: OutboundMessage): Promise<void> {
+    // iMessage doesn't have a strict char limit but long messages are unwieldy on phones
+    const chunks = splitText(msg.text, 3000);
+    for (const chunk of chunks) {
+      // Track what we send so DB poller can filter echoes
+      this.recentlySent.set(chunk.trim(), Date.now());
+      await this.client.request("send", {
+        text: chunk,
+        chat_id: Number(msg.chatId),
+      }, 30_000);
+    }
+    // Prune old entries (>60s) to prevent memory leak
+    const cutoff = Date.now() - 60_000;
+    for (const [text, ts] of this.recentlySent) {
+      if (ts < cutoff) this.recentlySent.delete(text);
+    }
+  }
+
+  private handleRawMessage(raw: ImsgMessage): void {
+    // Note: can't filter is_from_me here because the user's phone shares
+    // the same Apple ID as this Mac, so all messages appear as is_from_me.
+    // Echo prevention is handled in index.ts via recentBotMessages tracking.
+    if (!raw.text?.trim() && !raw.attachments?.length) return;
+
+    // Debounce: coalesce rapid messages from same sender in same chat
+    const key = `${raw.chat_id}:${raw.sender}`;
+    const existing = this.debounceMap.get(key);
+
+    if (existing) {
+      clearTimeout(existing.timer);
+      existing.messages.push(raw);
+      existing.timer = setTimeout(() => this.flushDebounce(key), this.debounceMs);
+    } else {
+      this.debounceMap.set(key, {
+        messages: [raw],
+        timer: setTimeout(() => this.flushDebounce(key), this.debounceMs),
+      });
+    }
+  }
+
+  private flushDebounce(key: string): void {
+    const entry = this.debounceMap.get(key);
+    if (!entry) return;
+    this.debounceMap.delete(key);
+
+    // Coalesce multiple messages into one
+    const messages = entry.messages;
+    const first = messages[0];
+    const text = messages.map((m) => m.text).join("\n");
+
+    const inbound: InboundMessage = {
+      id: String(first.id),
+      channel: this.channelId,
+      chatId: String(first.chat_id),
+      chatType: first.is_group ? "group" : "dm",
+      sender: first.sender,
+      text,
+      timestamp: new Date(first.created_at).getTime(),
+      isFromMe: first.is_from_me,
+      isGroup: first.is_group,
+      groupName: first.chat_name ?? undefined,
+      participants: first.participants,
+      replyTo: first.reply_to_id
+        ? {
+            id: String(first.reply_to_id),
+            text: first.reply_to_text ?? "",
+            sender: first.reply_to_sender ?? undefined,
+          }
+        : undefined,
+      attachments: this.collectImageAttachments(messages),
+      raw: messages.length === 1 ? first : messages,
+    };
+
+    if (this.messageHandler) {
+      this.messageHandler(inbound).catch((err) => {
+        log.error(`Message handler error: ${err}`);
+      });
+    }
+  }
+
+  private collectImageAttachments(messages: ImsgMessage[]): Array<{ path: string; mimeType?: string }> | undefined {
+    const imageTypes = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/heic"];
+    const attachments: Array<{ path: string; mimeType?: string }> = [];
+
+    for (const msg of messages) {
+      if (!msg.attachments?.length) continue;
+      for (const a of msg.attachments) {
+        if (a.mime_type && imageTypes.includes(a.mime_type)) {
+          attachments.push({ path: a.path, mimeType: a.mime_type });
+        }
+      }
+    }
+
+    return attachments.length > 0 ? attachments : undefined;
+  }
+}

package/src/channels/slack.ts

@@ -0,0 +1,208 @@
+import { writeFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { tmpdir } from "node:os";
+import { WebClient } from "@slack/web-api";
+import { SocketModeClient } from "@slack/socket-mode";
+import type { ChannelDriver, InboundMessage, OutboundMessage } from "./types.js";
+import { splitText } from "./types.js";
+import { log } from "../logger.js";
+
+interface SlackFile {
+  id: string;
+  name?: string;
+  mimetype?: string;
+  filetype?: string;
+  url_private_download?: string;
+  size?: number;
+  file_access?: string;
+}
+
+interface SlackMessageEvent {
+  type: "message";
+  subtype?: string;
+  channel: string;
+  user: string;
+  text: string;
+  ts: string;
+  thread_ts?: string;
+  channel_type: "channel" | "group" | "im" | "mpim";
+  files?: SlackFile[];
+}
+
+export class SlackDriver implements ChannelDriver {
+  readonly channelId = "slack";
+
+  private web: WebClient;
+  private socket: SocketModeClient;
+  private botToken: string;
+  private messageHandler: ((msg: InboundMessage) => Promise<void>) | null = null;
+  private botUserId: string | null = null;
+
+  constructor(config: Record<string, unknown>) {
+    const botToken = config.botToken as string;
+    const appToken = config.appToken as string;
+
+    if (!botToken || !appToken) {
+      throw new Error("Slack driver requires botToken and appToken in config");
+    }
+
+    this.botToken = botToken;
+    this.web = new WebClient(botToken);
+    this.socket = new SocketModeClient({
+      appToken,
+      clientPingTimeout: 30_000,
+      serverPingTimeout: 30_000,
+      pingPongLoggingEnabled: false,
+    });
+  }
+
+  async start(): Promise<void> {
+    const auth = await this.web.auth.test();
+    this.botUserId = auth.user_id as string;
+    log.info(`Slack bot authenticated as ${auth.user} (${this.botUserId})`);
+
+    this.socket.on("message", async ({ event, ack }) => {
+      await ack();
+      this.handleEvent(event as SlackMessageEvent);
+    });
+
+    this.socket.on("connected", () => {
+      log.info("Slack socket mode connected");
+    });
+
+    this.socket.on("disconnected", () => {
+      log.warn("Slack socket mode disconnected");
+    });
+
+    await this.socket.start();
+    log.info("Slack driver started — listening for messages");
+  }
+
+  async stop(): Promise<void> {
+    await this.socket.disconnect();
+    log.info("Slack driver stopped");
+  }
+
+  onMessage(handler: (msg: InboundMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  async send(msg: OutboundMessage): Promise<void> {
+    // Slack limit is ~4000 chars (with some overhead for formatting)
+    const chunks = splitText(msg.text, 3900);
+    for (const chunk of chunks) {
+      await this.web.chat.postMessage({
+        channel: msg.chatId,
+        text: chunk,
+        ...(msg.replyToId ? { thread_ts: msg.replyToId } : {}),
+      });
+    }
+  }
+
+  async sendTyping(chatId: string): Promise<void> {
+    try {
+      // Slack doesn't have a direct typing indicator API for bots,
+      // but we can use a subtle reaction or just skip
+      // The "On it..." message in index.ts serves this purpose
+    } catch { /* ignore */ }
+  }
+
+  async sendFile(chatId: string, filePath: string, caption?: string): Promise<void> {
+    try {
+      const content = readFileSync(filePath);
+      await this.web.filesUploadV2({
+        channel_id: chatId,
+        file: content,
+        filename: basename(filePath),
+        initial_comment: caption || undefined,
+      });
+    } catch (err) {
+      log.warn(`Failed to send file to Slack: ${err}`);
+    }
+  }
+
+  private async handleEvent(event: SlackMessageEvent): Promise<void> {
+    if (event.user === this.botUserId) return;
+    if (event.subtype && event.subtype !== "file_share") return;
+    if (!event.text?.trim() && !event.files?.length) return;
+
+    const isGroup = event.channel_type === "channel" || event.channel_type === "group";
+    const attachments = await this.downloadFiles(event.files);
+
+    const inbound: InboundMessage = {
+      id: event.ts,
+      channel: this.channelId,
+      chatId: event.channel,
+      chatType: isGroup ? "group" : "dm",
+      sender: event.user,
+      text: event.text || "",
+      timestamp: Math.floor(parseFloat(event.ts) * 1000),
+      isFromMe: false,
+      isGroup,
+      replyTo: event.thread_ts
+        ? { id: event.thread_ts, text: "" }
+        : undefined,
+      attachments: attachments.length > 0 ? attachments : undefined,
+      raw: event,
+    };
+
+    log.debug(`Slack received from ${event.user} in ${event.channel}: ${(event.text || "").slice(0, 100)}${attachments.length ? ` [${attachments.length} image(s)]` : ""}`);
+
+    if (this.messageHandler) {
+      this.messageHandler(inbound).catch((err) => {
+        log.error(`Slack message handler error: ${err}`);
+      });
+    }
+  }
+
+  private async downloadFiles(files?: SlackFile[]): Promise<Array<{ path: string; mimeType?: string }>> {
+    if (!files?.length) return [];
+
+    const imageTypes = ["png", "jpg", "jpeg", "gif", "webp", "heic", "bmp"];
+    const downloadDir = join(tmpdir(), "channelToAgent-slack-images");
+    mkdirSync(downloadDir, { recursive: true });
+
+    const results: Array<{ path: string; mimeType?: string }> = [];
+
+    for (const file of files) {
+      try {
+        const info = await this.web.files.info({ file: file.id });
+        const fullFile = info.file as Record<string, unknown> | undefined;
+        if (!fullFile) {
+          log.warn(`Slack files.info returned no file for ${file.id}`);
+          continue;
+        }
+
+        const mimetype = fullFile.mimetype as string | undefined;
+        const filetype = fullFile.filetype as string | undefined;
+        const name = (fullFile.name as string) || `${file.id}.${filetype || "png"}`;
+        const size = fullFile.size as number | undefined;
+        const downloadUrl = fullFile.url_private_download as string | undefined;
+
+        if (!mimetype?.startsWith("image/") && !imageTypes.includes(filetype || "")) continue;
+        if ((size || 0) > 10_000_000) continue;
+        if (!downloadUrl) {
+          log.warn(`No download URL for Slack file ${name}`);
+          continue;
+        }
+
+        const resp = await fetch(downloadUrl, {
+          headers: { Authorization: `Bearer ${this.botToken}` },
+        });
+        if (!resp.ok) {
+          log.warn(`Failed to download Slack file ${name}: ${resp.status}`);
+          continue;
+        }
+        const buffer = Buffer.from(await resp.arrayBuffer());
+        const localPath = join(downloadDir, `${file.id}-${name}`);
+        writeFileSync(localPath, buffer);
+        results.push({ path: localPath, mimeType: mimetype });
+        log.debug(`Downloaded Slack file: ${name} (${buffer.length} bytes)`);
+      } catch (err) {
+        log.warn(`Error downloading Slack file ${file.id}: ${err}`);
+      }
+    }
+
+    return results;
+  }
+}