@inetafrica/open-claudia 1.20.0 → 2.0.0

package/channels/kazee/adapter.js

@@ -0,0 +1,375 @@
+// KazeeAdapter — talks to chat-central via REST (commands, message
+// edit/delete, file upload) and socket.io v2 events (inbound messages,
+// button presses). Mirrors TelegramAdapter's contract so core code
+// stays transport-agnostic.
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+const { URL } = require("url");
+const { TEMP_DIR, FILES_DIR } = require("../../core/config");
+const { canonicalForChannel } = require("../../core/identity");
+const { inlineKeyboardToPortable } = require("../types");
+const { createKazeeSocket } = require("./socket");
+
+class KazeeAdapter {
+  constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
+    this.id = id;
+    this.type = "kazee";
+    // KAZEE_URL is the root host (socket.io lives at /). REST routes are
+    // mounted under /api on chat-central; we prepend that internally.
+    this.url = url.replace(/\/$/, "");
+    this.apiBase = this.url + "/api";
+    this.token = token;
+    this.ownerUserId = ownerUserId || "";
+    this.botUserId = botUserId || null;
+    this._listeners = { message: new Set(), action: new Set() };
+    this._socket = null;
+  }
+
+  on(event, fn) {
+    if (!this._listeners[event]) return () => {};
+    this._listeners[event].add(fn);
+    return () => this._listeners[event].delete(fn);
+  }
+
+  _emit(event, envelope) {
+    for (const fn of this._listeners[event] || []) {
+      try { Promise.resolve(fn(envelope)).catch((e) => console.error(`kazee ${event} handler:`, e.message)); }
+      catch (e) { console.error(`kazee ${event} handler:`, e.message); }
+    }
+  }
+
+  async start() {
+    if (this.botUserId) {
+      console.log(`Kazee bot user id: ${this.botUserId}`);
+    } else {
+      console.error("Kazee adapter started without botUserId — set KAZEE_BOT_USER_ID. Slash commands and self-echo filtering will not work.");
+    }
+    this._socket = createKazeeSocket({
+      url: this.url,
+      token: this.token,
+      userId: this.botUserId,
+      onConnect: (s) => {
+        console.log(`Kazee socket connected (${this.url})`);
+        if (this.botUserId) {
+          // Join the bot's personal room so the server can fan out
+          // message:action presses directly to us.
+          s.emit("user:join", { userId: this.botUserId });
+        }
+      },
+      onDisconnect: (reason) => console.log(`Kazee socket disconnected: ${reason}`),
+      onError: (err) => console.error("Kazee socket error:", err.message),
+    });
+    this._wireSocket(this._socket);
+  }
+
+  async stop() {
+    try { this._socket?.disconnect?.(); } catch (e) {}
+    this._socket = null;
+  }
+
+  _wireSocket(socket) {
+    if (process.env.KAZEE_DEBUG_EVENTS) {
+      socket.onAny((event, ...args) => {
+        try { console.log(`[kazee event] ${event}`, JSON.stringify(args).slice(0, 400)); }
+        catch (e) { console.log(`[kazee event] ${event} (unserializable)`); }
+      });
+    }
+    socket.on("message:new", (msg) => this._handleInboundMessage(msg));
+    socket.on("message:action", (payload) => {
+      const channelId = String(payload.chatId);
+      const userId = String(payload.userId);
+      this._emit("action", {
+        adapter: this,
+        channelId,
+        canonicalUserId: canonicalForChannel("kazee", userId),
+        userId,
+        type: "action",
+        messageId: payload.messageId,
+        action: {
+          buttonId: payload.buttonId,
+          payload: payload.buttonPayload ?? payload.clientPayload ?? null,
+          sourceMessageId: payload.messageId,
+        },
+        raw: payload,
+      });
+    });
+  }
+
+  _handleInboundMessage(msg) {
+    if (!msg) return;
+    const senderId = String(msg.sender?._id || msg.sender?.id || msg.senderId || "");
+    if (this.botUserId && senderId === String(this.botUserId)) return; // ignore our own echoes
+    const chatField = msg.chat;
+    const channelId = String(
+      msg.chatId
+        || (typeof chatField === "string" ? chatField : (chatField?._id || chatField?.id))
+        || ""
+    );
+    if (!channelId) {
+      console.error("Kazee message:new missing chat id, ignoring:", JSON.stringify(msg).slice(0, 200));
+      return;
+    }
+    const userId = senderId || channelId;
+    const baseFrom = {
+      id: userId,
+      name: msg.sender?.name || msg.sender?.displayName || "",
+      username: msg.sender?.username || "",
+    };
+
+    const text = (msg.content || "").toString();
+    const isCommand = text.trim().startsWith("/");
+    const type = isCommand ? "command" : (msg.type === "voice" || msg.type === "audio" || msg.type === "image" || msg.type === "file" ? msg.type : "text");
+    const envelope = {
+      adapter: this,
+      channelId,
+      canonicalUserId: canonicalForChannel("kazee", userId),
+      userId,
+      type: type === "image" ? "photo" : type === "file" ? "document" : type,
+      text,
+      messageId: msg._id || msg.id,
+      replyToId: msg.replyTo,
+      from: baseFrom,
+      raw: msg,
+    };
+
+    if (msg.attachments && msg.attachments.length) {
+      envelope.media = msg.attachments.map((a) => ({
+        type: a.type || (a.mimeType?.startsWith("image/") ? "photo" : "document"),
+        fileId: a.url || a._id,
+        fileName: a.name || a.filename,
+        mimeType: a.mimeType,
+        size: a.size,
+      }));
+      if (envelope.type === "text") envelope.type = envelope.media[0].type === "image" ? "photo" : envelope.media[0].type;
+    }
+
+    this._emit("message", envelope);
+  }
+
+  _normalizeKeyboard(keyboard) {
+    if (!keyboard) return null;
+    if (keyboard.buttons) return keyboard.buttons;
+    if (keyboard.inline_keyboard) return inlineKeyboardToPortable(keyboard.inline_keyboard);
+    return null;
+  }
+
+  async send(channelId, text, opts = {}) {
+    const buttons = this._normalizeKeyboard(opts.keyboard);
+    const body = {
+      chat_id: channelId,
+      sender: this.botUserId,
+      content: text,
+      type: buttons ? "interactive" : "text",
+      findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    };
+    if (opts.replyTo) body.replyTo = opts.replyTo;
+    if (buttons) body.interactive = { buttons };
+    try {
+      const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
+      return res?.message?._id || res?.messageId || res?._id || null;
+    } catch (e) {
+      console.error("Kazee send error:", e.message);
+      return null;
+    }
+  }
+
+  async edit(channelId, messageId, text, opts = {}) {
+    const buttons = this._normalizeKeyboard(opts.keyboard);
+    const body = { content: text };
+    if (buttons) {
+      body.type = "interactive";
+      body.interactive = { buttons };
+    }
+    try {
+      await this._request("PUT", `/message/${encodeURIComponent(messageId)}`, body);
+    } catch (e) {
+      const msg = e.message || "";
+      if (msg.includes("not found")) return;
+      console.error("Kazee edit error:", msg);
+    }
+  }
+
+  async delete(channelId, messageId) {
+    try { await this._request("DELETE", `/message/${encodeURIComponent(messageId)}`); }
+    catch (e) { /* ignore */ }
+  }
+
+  async sendVoice(channelId, oggPath) {
+    const ok = await this.sendFile(channelId, oggPath);
+    try { fs.unlinkSync(oggPath); } catch (e) {}
+    return ok;
+  }
+
+  async sendFile(channelId, filePath, caption) {
+    try {
+      const buffer = fs.readFileSync(filePath);
+      const fileName = path.basename(filePath);
+      const upload = await this._uploadMultipart("/upload", { file: { buffer, fileName } });
+      const url = upload?.url || upload?.fileUrl || upload?.location;
+      if (!url) {
+        console.error("Kazee upload returned no url");
+        return false;
+      }
+      const body = {
+        chat_id: channelId,
+        sender: this.botUserId,
+        content: caption || fileName,
+        type: this._kazeeFileType(fileName),
+        findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        media_url: url,
+        attachments: [{ url, name: fileName }],
+      };
+      await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
+      return true;
+    } catch (e) {
+      console.error("Kazee sendFile error:", e.message);
+      return false;
+    }
+  }
+
+  _kazeeFileType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    if ([".jpg", ".jpeg", ".png", ".gif", ".webp"].includes(ext)) return "image";
+    if ([".mp4", ".mov", ".webm"].includes(ext)) return "video";
+    if ([".mp3", ".m4a", ".ogg", ".wav"].includes(ext)) return "audio";
+    return "file";
+  }
+
+  async typing(channelId) {
+    try { this._socket?.emit?.("typing:start", { chatId: channelId }); } catch (e) {}
+  }
+
+  async downloadMedia(media) {
+    if (!media || !media.fileId) return null;
+    const url = media.fileId; // Kazee passes the cloud URL through fileId.
+    const ext = path.extname(media.fileName || "") || (media.type === "voice" ? ".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, `kz-${Date.now()}${ext}`);
+    await this._downloadUrl(url, localPath);
+    return localPath;
+  }
+
+  async registerCommands(commands) {
+    if (!this.botUserId) {
+      console.error("Kazee registerCommands: no botUserId yet, skipping");
+      return;
+    }
+    const list = (commands || [])
+      .filter((c) => c && c.name)
+      .map((c) => ({
+        name: String(c.name).replace(/^\//, ""),
+        description: String(c.description || ""),
+        args: typeof c.args === "string" ? c.args : "",
+      }));
+    try {
+      await this._request("PUT", `/bot/${this.botUserId}/commands`, { commands: list });
+    } catch (e) {
+      console.error("Kazee registerCommands failed:", e.message);
+    }
+  }
+
+  // ── HTTP helpers ────────────────────────────────────────────────
+
+  _request(method, urlPath, body) {
+    return new Promise((resolve, reject) => {
+      const u = new URL(this.apiBase + urlPath);
+      const lib = u.protocol === "https:" ? https : http;
+      const data = body ? Buffer.from(JSON.stringify(body)) : null;
+      const headers = {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/json",
+      };
+      if (data) {
+        headers["Content-Type"] = "application/json";
+        headers["Content-Length"] = data.length;
+      }
+      const req = lib.request({
+        method,
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname + (u.search || ""),
+        headers,
+      }, (res) => {
+        let chunks = "";
+        res.on("data", (c) => { chunks += c; });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try { resolve(chunks ? JSON.parse(chunks) : {}); }
+            catch (e) { resolve({}); }
+          } else {
+            reject(new Error(`Kazee ${method} ${urlPath} → ${res.statusCode}: ${chunks.slice(0, 500)}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.setTimeout(30000, () => req.destroy(new Error("Kazee request timeout")));
+      if (data) req.write(data);
+      req.end();
+    });
+  }
+
+  _uploadMultipart(urlPath, files) {
+    return new Promise((resolve, reject) => {
+      const u = new URL(this.apiBase + urlPath);
+      const lib = u.protocol === "https:" ? https : http;
+      const boundary = `----oc-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const parts = [];
+      for (const [field, info] of Object.entries(files)) {
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${field}"; filename="${info.fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`));
+        parts.push(info.buffer);
+        parts.push(Buffer.from("\r\n"));
+      }
+      parts.push(Buffer.from(`--${boundary}--\r\n`));
+      const body = Buffer.concat(parts);
+      const req = lib.request({
+        method: "POST",
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname,
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": `multipart/form-data; boundary=${boundary}`,
+          "Content-Length": body.length,
+        },
+      }, (res) => {
+        let chunks = "";
+        res.on("data", (c) => { chunks += c; });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try { resolve(chunks ? JSON.parse(chunks) : {}); }
+            catch (e) { resolve({}); }
+          } else {
+            reject(new Error(`Kazee upload → ${res.statusCode}: ${chunks.slice(0, 500)}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.setTimeout(120000, () => req.destroy(new Error("Kazee upload timeout")));
+      req.write(body);
+      req.end();
+    });
+  }
+
+  _downloadUrl(url, localPath) {
+    return new Promise((resolve, reject) => {
+      const lib = url.startsWith("https:") ? https : http;
+      const out = fs.createWriteStream(localPath);
+      lib.get(url, (res) => {
+        if (res.statusCode && res.statusCode >= 400) {
+          out.destroy();
+          reject(new Error(`Download ${url} → ${res.statusCode}`));
+          return;
+        }
+        res.pipe(out);
+        out.on("finish", () => { out.close(); resolve(); });
+      }).on("error", reject);
+    });
+  }
+}
+
+module.exports = { KazeeAdapter };

package/channels/kazee/format.js

@@ -0,0 +1,9 @@
+// Kazee uses standard markdown end-to-end. Telegram-flavoured asterisks
+// and underscores still render fine, so this is mostly a hook for future
+// divergence (image embeds, code-block fences, etc.).
+
+function normalize(text) {
+  return String(text || "");
+}
+
+module.exports = { normalize };

package/channels/kazee/socket.js

@@ -0,0 +1,28 @@
+// Thin wrapper around socket.io-client. Keeps the v2 event names + auth
+// header in one place so the adapter stays focused on envelope shape.
+
+let io;
+try { io = require("socket.io-client").io; }
+catch (e) { io = null; }
+
+function createKazeeSocket({ url, token, userId, onConnect, onDisconnect, onError }) {
+  if (!io) {
+    throw new Error("socket.io-client is not installed. Run `npm install` to install dependencies.");
+  }
+  const query = { version: "v2" };
+  if (userId) query.userId = userId;
+  const socket = io(url, {
+    transports: ["websocket"],
+    auth: { token },
+    query,
+    reconnection: true,
+    reconnectionDelay: 2000,
+    reconnectionDelayMax: 30000,
+  });
+  socket.on("connect", () => { if (onConnect) onConnect(socket); });
+  socket.on("disconnect", (reason) => { if (onDisconnect) onDisconnect(reason); });
+  socket.on("connect_error", (err) => { if (onError) onError(err); });
+  return socket;
+}
+
+module.exports = { createKazeeSocket };