@inetafrica/open-claudia 1.20.0 → 2.0.0

package/channels/telegram/adapter.js

@@ -0,0 +1,296 @@
+// TelegramAdapter — wraps node-telegram-bot-api so core never touches
+// the Telegram SDK directly. Inbound: normalises text/voice/audio/photo/
+// document/callback_query into envelopes. Outbound: send/edit/delete +
+// keyboard normalisation.
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const TelegramBot = require("node-telegram-bot-api");
+const { TEMP_DIR, FILES_DIR, CONFIG_DIR } = require("../../core/config");
+const { canonicalForChannel } = require("../../core/identity");
+const { portableToInlineKeyboard } = require("../types");
+
+class TelegramAdapter {
+  constructor({ id = "telegram", token, ownerChatId, chatIds }) {
+    this.id = id;
+    this.type = "telegram";
+    this.token = token;
+    this.ownerChatId = ownerChatId;
+    this.chatIds = chatIds || [];
+    this.bot = new TelegramBot(token, {
+      polling: { autoStart: false, params: { timeout: 30 } },
+    });
+    this._listeners = { message: new Set(), action: new Set() };
+    this._reconnectTimer = null;
+    this._wireInbound();
+  }
+
+  _emit(event, envelope) {
+    for (const fn of this._listeners[event] || []) {
+      try { Promise.resolve(fn(envelope)).catch((e) => console.error(`telegram ${event} handler:`, e.message)); }
+      catch (e) { console.error(`telegram ${event} handler:`, e.message); }
+    }
+  }
+
+  on(event, fn) {
+    if (!this._listeners[event]) return () => {};
+    this._listeners[event].add(fn);
+    return () => this._listeners[event].delete(fn);
+  }
+
+  async start() {
+    await this.bot.startPolling();
+  }
+
+  async stop() {
+    try { await this.bot.stopPolling(); } catch (e) {}
+  }
+
+  _wireInbound() {
+    this.bot.on("polling_error", (err) => {
+      const msg = err.message || "";
+      console.error("Polling error:", msg);
+      if (msg.includes("409 Conflict")) {
+        console.error("Another instance is polling. Exiting.");
+        process.exit(1);
+      }
+      if (msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET") || msg.includes("ENOTFOUND") || msg.includes("EFATAL")) {
+        if (this._reconnectTimer) return;
+        console.log("Network lost. Reconnecting in 10s...");
+        this._reconnectTimer = setTimeout(async () => {
+          this._reconnectTimer = null;
+          try {
+            await this.bot.stopPolling();
+            await new Promise((r) => setTimeout(r, 2000));
+            await this.bot.startPolling();
+            console.log("Reconnected.");
+          } catch (e) {
+            console.error("Reconnect failed:", e.message);
+            process.exit(1);
+          }
+        }, 10000);
+      }
+    });
+
+    this.bot.on("message", (msg) => {
+      if (!msg || !msg.text || msg.text.startsWith("/")) return;
+      // Skip media — those have dedicated handlers below.
+      if (msg.voice || msg.audio || msg.photo || msg.document || msg.video || msg.sticker) return;
+      this._emit("message", this._envelopeText(msg));
+    });
+
+    // Telegram delivers slash commands via the same `message` event but with
+    // text starting with "/". We fan them out separately so the router can
+    // dispatch via the registry instead of relying on bot.onText regexes.
+    this.bot.on("message", (msg) => {
+      if (!msg || !msg.text || !msg.text.startsWith("/")) return;
+      this._emit("message", this._envelopeText(msg, { isCommand: true }));
+    });
+
+    this.bot.on("voice", (msg) => this._emit("message", this._envelopeMedia(msg, "voice", msg.voice)));
+    this.bot.on("audio", (msg) => this._emit("message", this._envelopeMedia(msg, "audio", msg.audio)));
+    this.bot.on("photo", (msg) => {
+      const photo = msg.photo[msg.photo.length - 1];
+      this._emit("message", this._envelopeMedia(msg, "photo", photo));
+    });
+    this.bot.on("document", (msg) => this._emit("message", this._envelopeMedia(msg, "document", msg.document)));
+
+    this.bot.on("callback_query", (q) => {
+      const chatId = String(q.message?.chat?.id || q.from?.id);
+      const userId = String(q.from?.id || chatId);
+      this._emit("action", {
+        adapter: this,
+        channelId: chatId,
+        canonicalUserId: canonicalForChannel("telegram", chatId),
+        userId,
+        type: "action",
+        messageId: q.message?.message_id,
+        from: { id: userId, name: [q.from?.first_name, q.from?.last_name].filter(Boolean).join(" "), username: q.from?.username },
+        action: {
+          buttonId: q.data,
+          payload: q.data,
+          sourceMessageId: q.message?.message_id,
+          callbackId: q.id,
+        },
+        raw: q,
+      });
+    });
+  }
+
+  _envelopeText(msg, extra = {}) {
+    const chatId = String(msg.chat.id);
+    const userId = String(msg.from?.id || chatId);
+    return {
+      adapter: this,
+      channelId: chatId,
+      canonicalUserId: canonicalForChannel("telegram", chatId),
+      userId,
+      type: extra.isCommand ? "command" : "text",
+      text: msg.text,
+      messageId: msg.message_id,
+      replyToId: msg.reply_to_message?.message_id,
+      reply: msg.reply_to_message ? {
+        text: msg.reply_to_message.text,
+        caption: msg.reply_to_message.caption,
+        document: msg.reply_to_message.document,
+        photo: msg.reply_to_message.photo,
+        from: msg.reply_to_message.from,
+      } : null,
+      from: { id: userId, name: [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" "), username: msg.from?.username },
+      raw: msg,
+    };
+  }
+
+  _envelopeMedia(msg, kind, media) {
+    const chatId = String(msg.chat.id);
+    const userId = String(msg.from?.id || chatId);
+    return {
+      adapter: this,
+      channelId: chatId,
+      canonicalUserId: canonicalForChannel("telegram", chatId),
+      userId,
+      type: kind,
+      messageId: msg.message_id,
+      replyToId: msg.reply_to_message?.message_id,
+      caption: msg.caption,
+      from: { id: userId, name: [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" "), username: msg.from?.username },
+      media: [{
+        type: kind,
+        fileId: media.file_id,
+        fileName: media.file_name,
+        mimeType: media.mime_type,
+        size: media.file_size,
+      }],
+      raw: msg,
+    };
+  }
+
+  _normalizeKeyboard(keyboard) {
+    if (!keyboard) return null;
+    if (keyboard.inline_keyboard) return keyboard;
+    if (keyboard.buttons) {
+      return { inline_keyboard: portableToInlineKeyboard(keyboard.buttons) };
+    }
+    return null;
+  }
+
+  async send(channelId, text, opts = {}) {
+    const o = {};
+    if (opts.parseMode) o.parse_mode = opts.parseMode;
+    const kb = this._normalizeKeyboard(opts.keyboard);
+    if (kb) o.reply_markup = kb;
+    if (opts.replyTo) o.reply_to_message_id = opts.replyTo;
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const msg = await this.bot.sendMessage(channelId, text, o);
+        return msg.message_id;
+      } catch (e) {
+        const errMsg = e.message || "";
+        if (o.reply_to_message_id && errMsg.includes("message to be replied not found")) {
+          delete o.reply_to_message_id;
+          continue;
+        }
+        const retryMatch = errMsg.match(/retry after (\d+)/i);
+        if (retryMatch) {
+          const waitSec = Math.min(parseInt(retryMatch[1], 10), 30);
+          console.error(`Send: rate limited, waiting ${waitSec}s`);
+          await new Promise((r) => setTimeout(r, waitSec * 1000));
+          continue;
+        }
+        if (opts.parseMode && o.parse_mode) {
+          delete o.parse_mode;
+          continue;
+        }
+        console.error("Send error:", errMsg);
+        return null;
+      }
+    }
+    console.error("Send: exhausted retries");
+    return null;
+  }
+
+  async edit(channelId, messageId, text, opts = {}) {
+    try {
+      const o = { chat_id: channelId, message_id: messageId };
+      const kb = this._normalizeKeyboard(opts.keyboard);
+      if (kb) o.reply_markup = kb;
+      await this.bot.editMessageText(text, o);
+    } catch (e) {
+      const errMsg = e.message || "";
+      if (errMsg.includes("retry after")) return;
+      if (errMsg.includes("message is not modified")) return;
+      if (!errMsg.includes("message to edit not found")) console.error("Edit error:", errMsg);
+    }
+  }
+
+  async delete(channelId, messageId) {
+    try { await this.bot.deleteMessage(channelId, messageId); } catch (e) { /* ignore */ }
+  }
+
+  async sendVoice(channelId, oggPath) {
+    try {
+      await this.bot.sendVoice(channelId, oggPath);
+      try { fs.unlinkSync(oggPath); } catch (e) {}
+      return true;
+    } catch (e) {
+      console.error("Send voice error:", e.message);
+      try { fs.unlinkSync(oggPath); } catch (e2) {}
+      return false;
+    }
+  }
+
+  async sendFile(channelId, filePath, caption) {
+    try {
+      await this.bot.sendDocument(channelId, filePath, caption ? { caption } : {});
+      return true;
+    } catch (e) {
+      console.error("Send file error:", e.message);
+      return false;
+    }
+  }
+
+  async typing(channelId) {
+    try { await this.bot.sendChatAction(channelId, "typing"); } catch (e) {}
+  }
+
+  async downloadMedia(media) {
+    if (!media || !media.fileId) return null;
+    const file = await this.bot.getFile(media.fileId);
+    const fileUrl = `https://api.telegram.org/file/bot${this.token}/${file.file_path}`;
+    const ext = media.fileName ? path.extname(media.fileName) || ".bin"
+      : media.type === "voice" ? ".ogg"
+      : media.type === "audio" ? path.extname(media.fileName || "") || ".ogg"
+      : media.type === "photo" ? ".jpg"
+      : ".bin";
+    const baseDir = media.type === "document" ? FILES_DIR : TEMP_DIR;
+    const localPath = media.type === "document" && media.fileName
+      ? path.join(baseDir, media.fileName)
+      : path.join(baseDir, `tg-${Date.now()}${ext}`);
+    await new Promise((resolve, reject) => {
+      const out = fs.createWriteStream(localPath);
+      https.get(fileUrl, (res) => { res.pipe(out); out.on("finish", () => { out.close(); resolve(); }); }).on("error", reject);
+    });
+    return localPath;
+  }
+
+  async registerCommands(commands) {
+    // Telegram uses BotFather menus via setMyCommands. Strip leading
+    // slashes and clip to its 32-char name limit.
+    try {
+      const list = (commands || [])
+        .filter((c) => c && c.name)
+        .map((c) => ({
+          command: String(c.name).replace(/^\//, "").slice(0, 32),
+          description: String(c.description || c.name).slice(0, 256),
+        }))
+        .slice(0, 100);
+      await this.bot.setMyCommands(list);
+    } catch (e) {
+      console.error("Telegram setMyCommands failed:", e.message);
+    }
+  }
+}
+
+module.exports = { TelegramAdapter };

package/channels/telegram/format.js

@@ -0,0 +1,12 @@
+// Telegram MarkdownV1 quirks: single-asterisk bold, single-underscore
+// italic, backticks for code. Most callers send `parseMode: "Markdown"`
+// strings already authored for Telegram, so this module is mostly a
+// pass-through with a couple of helpers.
+
+function stripMarkdown(text) {
+  return String(text || "")
+    .replace(/[*_`~]/g, "")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+}
+
+module.exports = { stripMarkdown };

package/channels/types.js

@@ -0,0 +1,91 @@
+// JSDoc-only contract for ChannelAdapter. No runtime base class — every
+// channel implementation duck-types these methods. Core code never
+// touches a transport SDK directly; it goes through the adapter so the
+// same handlers run on Telegram, Kazee, and any future channel.
+//
+/**
+ * @typedef {Object} MediaRef
+ * @property {string} type        // "voice" | "audio" | "photo" | "document"
+ * @property {string} fileId      // adapter-specific
+ * @property {string} [fileName]
+ * @property {string} [mimeType]
+ * @property {number} [size]
+ *
+ * @typedef {Object} InboundEnvelope
+ * @property {ChannelAdapter} adapter
+ * @property {string} channelId       // raw transport id (telegram chatId, kazee chatId)
+ * @property {string} canonicalUserId // "telegram:123" | "kazee:abc" | "<email>"
+ * @property {string} userId          // raw transport user id
+ * @property {string} type            // "text" | "voice" | "audio" | "photo" | "document" | "action"
+ * @property {string} [text]          // command text or message body
+ * @property {string} [messageId]     // outer-channel message id
+ * @property {string} [replyToId]     // id of message being replied to
+ * @property {Object} [reply]         // {text, document, photo} for reply context
+ * @property {Array<MediaRef>} [media]
+ * @property {Object} [from]          // {id, name, username}
+ * @property {Object} [action]        // for type:"action" — {buttonId, payload, sourceMessageId}
+ * @property {any} raw                // original payload, adapter-specific
+ *
+ * @typedef {Object} PortableButton
+ * @property {string} id
+ * @property {string} label
+ * @property {string} [style]
+ * @property {any} [payload]
+ *
+ * @typedef {Object} SendOpts
+ * @property {string} [parseMode]
+ * @property {Object} [keyboard]      // either {inline_keyboard:[[{text,callback_data}]]}
+ *                                    // (telegram-native, accepted by both adapters)
+ *                                    // or {buttons:[PortableButton]} (portable)
+ * @property {string|number} [replyTo]
+ *
+ * @typedef {Object} CommandSpec
+ * @property {string} name            // no leading slash
+ * @property {string} description
+ * @property {string} [args]          // human-readable usage tail, e.g. "<model>"
+ *
+ * Every adapter implements:
+ *   id: string                                  // "telegram" | "kazee:<sub>" etc.
+ *   type: "telegram" | "kazee"
+ *   start(): Promise<void>
+ *   stop(): Promise<void>
+ *   on(event, fn): unsubscribe                  // events: "message" | "action"
+ *   send(channelId, text, opts): Promise<messageId|null>
+ *   edit(channelId, messageId, text, opts): Promise<void>
+ *   delete(channelId, messageId): Promise<void>
+ *   sendVoice(channelId, oggPath): Promise<boolean>
+ *   sendFile(channelId, filePath, caption?): Promise<boolean>
+ *   typing(channelId): Promise<void>
+ *   downloadMedia(mediaRef): Promise<localPath|null>
+ *   registerCommands(commands: CommandSpec[]): Promise<void>
+ */
+
+// Helpers shared by adapters for keyboard-shape conversion.
+
+function inlineKeyboardToPortable(inlineKeyboard) {
+  const buttons = [];
+  for (const row of inlineKeyboard || []) {
+    for (const btn of row || []) {
+      const cb = btn.callback_data || "";
+      buttons.push({
+        id: cb || btn.text,
+        label: btn.text,
+        payload: cb || null,
+      });
+    }
+  }
+  return buttons;
+}
+
+function portableToInlineKeyboard(buttons) {
+  const rows = [];
+  for (const b of buttons || []) {
+    rows.push([{
+      text: b.label,
+      callback_data: typeof b.payload === "string" ? b.payload : b.id,
+    }]);
+  }
+  return rows;
+}
+
+module.exports = { inlineKeyboardToPortable, portableToInlineKeyboard };

package/core/access.js

@@ -0,0 +1,147 @@
+// Authorization rules. Pre-multi-channel this was strictly Telegram
+// chat ids in .env + auth.json; the same store still drives access on
+// any channel because the "chatId" recorded there is opaque (Telegram
+// numeric ids today; Kazee userIds tomorrow). Channel resolution lives
+// in the inbound envelope's canonicalUserId, not here.
+
+const fs = require("fs");
+const { AUTH_FILE, CHAT_ID, CHAT_IDS, saveEnvKey } = require("./config");
+
+function loadAuth() {
+  try {
+    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    return {
+      authorized: Array.isArray(auth.authorized) ? auth.authorized : [],
+      pending: Array.isArray(auth.pending) ? auth.pending : [],
+    };
+  } catch (e) {
+    return { authorized: [], pending: [] };
+  }
+}
+
+function saveAuth(auth) {
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2));
+}
+
+function isChatAuthorized(chatId) {
+  const id = String(chatId || "");
+  if (!id) return false;
+  if (CHAT_IDS.includes(id)) return true;
+  try {
+    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    return Array.isArray(auth.authorized) && auth.authorized.some((a) => String(a.chatId) === id);
+  } catch (e) {}
+  return false;
+}
+
+function isChatOwner(chatId) {
+  const id = String(chatId || "");
+  if (!id) return false;
+  if (id === String(CHAT_ID || "")) return true;
+  try {
+    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    const authorized = Array.isArray(auth.authorized) ? auth.authorized : [];
+    if (authorized.some((a) => String(a.chatId) === id && a.isOwner === true)) return true;
+    // No explicit owner flag → fall back to .env CHAT_IDS membership.
+    if (!authorized.some((a) => a.isOwner === true) && CHAT_IDS.includes(id)) return true;
+  } catch (e) {}
+  return false;
+}
+
+function authRequestLabel(request) {
+  return request.username ? `@${request.username}` : request.name || request.chatId;
+}
+
+function updateAuthorizedChatEnv(auth) {
+  const ids = new Set(CHAT_IDS);
+  for (const user of auth.authorized) {
+    if (user.chatId) ids.add(String(user.chatId));
+  }
+  saveEnvKey("TELEGRAM_CHAT_ID", [...ids].join(","));
+}
+
+function approveAuthRequest(chatId) {
+  const auth = loadAuth();
+  if (auth.authorized.some((a) => String(a.chatId) === chatId)) {
+    auth.pending = auth.pending.filter((p) => String(p.chatId) !== chatId);
+    saveAuth(auth);
+    updateAuthorizedChatEnv(auth);
+    return { status: "already_authorized" };
+  }
+  const idx = auth.pending.findIndex((p) => String(p.chatId) === chatId);
+  if (idx < 0) return { status: "not_found" };
+  const approved = auth.pending.splice(idx, 1)[0];
+  auth.authorized.push({
+    chatId: approved.chatId,
+    name: approved.name,
+    username: approved.username,
+    isOwner: false,
+    authorizedAt: new Date().toISOString(),
+  });
+  saveAuth(auth);
+  updateAuthorizedChatEnv(auth);
+  return { status: "approved", request: approved };
+}
+
+function denyAuthRequest(chatId) {
+  const auth = loadAuth();
+  const idx = auth.pending.findIndex((p) => String(p.chatId) === chatId);
+  if (idx < 0) return { status: "not_found" };
+  const denied = auth.pending.splice(idx, 1)[0];
+  saveAuth(auth);
+  return { status: "denied", request: denied };
+}
+
+function recordPendingAuthRequest({ chatId, name, username }) {
+  const auth = loadAuth();
+  if (auth.pending.some((p) => String(p.chatId) === String(chatId))) return { status: "already_pending" };
+  auth.pending.push({
+    chatId: String(chatId),
+    name,
+    username,
+    requestedAt: new Date().toISOString(),
+  });
+  saveAuth(auth);
+  return { status: "queued" };
+}
+
+function hasOwner() {
+  if (CHAT_ID) return true;
+  try {
+    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    return Array.isArray(auth.authorized) && auth.authorized.some((a) => a.isOwner === true);
+  } catch (e) {
+    return false;
+  }
+}
+
+function bootstrapOwner({ chatId, name, username }) {
+  const id = String(chatId);
+  const auth = loadAuth();
+  auth.pending = auth.pending.filter((p) => String(p.chatId) !== id);
+  auth.authorized = auth.authorized.filter((a) => String(a.chatId) !== id);
+  auth.authorized.push({
+    chatId: id,
+    name: name || "",
+    username: username || "",
+    isOwner: true,
+    authorizedAt: new Date().toISOString(),
+  });
+  saveAuth(auth);
+  if (!CHAT_IDS.includes(id)) CHAT_IDS.push(id);
+  saveEnvKey("TELEGRAM_CHAT_ID", CHAT_IDS.join(","));
+}
+
+module.exports = {
+  loadAuth,
+  saveAuth,
+  isChatAuthorized,
+  isChatOwner,
+  authRequestLabel,
+  approveAuthRequest,
+  denyAuthRequest,
+  recordPendingAuthRequest,
+  updateAuthorizedChatEnv,
+  hasOwner,
+  bootstrapOwner,
+};