@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-ECSNSHZ7.js

@@ -0,0 +1,431 @@
+// src/gateway/adapters/whatsapp.ts
+import { randomUUID } from "crypto";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync } from "fs";
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e5;
+var BACKOFF_MULTIPLIER = 2;
+var JITTER_FACTOR = 0.25;
+var AUTH_DIR = join(homedir(), ".exe-os", "whatsapp-auth");
+function createBaileysLogger(accountName) {
+  const prefix = accountName ? `[whatsapp:${accountName}]` : "[whatsapp]";
+  const logger = {
+    level: "warn",
+    trace: () => {
+    },
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: (...args) => console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args),
+    fatal: (...args) => console.error(prefix, ...args),
+    child: () => logger
+  };
+  return logger;
+}
+function calculateBackoff(retryCount) {
+  const base = Math.min(
+    INITIAL_BACKOFF_MS * BACKOFF_MULTIPLIER ** retryCount,
+    MAX_BACKOFF_MS
+  );
+  const jitter = base * JITTER_FACTOR * (2 * Math.random() - 1);
+  return Math.max(INITIAL_BACKOFF_MS, Math.round(base + jitter));
+}
+var WhatsAppAdapter = class {
+  platform = "whatsapp";
+  sock = null;
+  messageHandler = null;
+  connected = false;
+  abortController = null;
+  authDir = AUTH_DIR;
+  baileysLogger = createBaileysLogger();
+  // Resilience state
+  retryCount = 0;
+  disconnectedAt = 0;
+  async connect(config) {
+    this.authDir = config.credentials.authDir ?? AUTH_DIR;
+    mkdirSync(this.authDir, { recursive: true });
+    const baileys = await import("@whiskeysockets/baileys");
+    const { makeWASocket, useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason, makeCacheableSignalKeyStore } = baileys;
+    const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+    const { version } = await fetchLatestBaileysVersion();
+    this.baileysLogger = createBaileysLogger();
+    this.abortController = new AbortController();
+    let agent;
+    const socksProxy = config.credentials.socksProxy;
+    if (socksProxy) {
+      try {
+        const modName = "socks-proxy-agent";
+        const mod = await import(modName);
+        const SocksProxyAgent = mod.SocksProxyAgent ?? mod.default;
+        agent = new SocksProxyAgent(socksProxy);
+        console.log(`[whatsapp] Using SOCKS proxy: ${socksProxy.replace(/\/\/.*@/, "//***@")}`);
+      } catch {
+        console.error("[whatsapp] socks-proxy-agent not installed \u2014 run: npm i socks-proxy-agent");
+        throw new Error("SOCKS proxy configured but socks-proxy-agent package not installed");
+      }
+    }
+    const sock = makeWASocket({
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, this.baileysLogger)
+      },
+      logger: this.baileysLogger,
+      version,
+      printQRInTerminal: true,
+      browser: ["exe-os", "cli", "1.0"],
+      syncFullHistory: false,
+      markOnlineOnConnect: false,
+      ...agent ? { agent } : {}
+    });
+    this.sock = sock;
+    sock.ev.on("creds.update", saveCreds);
+    sock.ev.on("connection.update", (update) => {
+      const { connection, lastDisconnect } = update;
+      if (connection === "close") {
+        this.connected = false;
+        if (this.disconnectedAt === 0) this.disconnectedAt = Date.now();
+        const statusCode = lastDisconnect?.error?.output?.statusCode;
+        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+        if (shouldReconnect && !this.abortController?.signal.aborted) {
+          const delay = calculateBackoff(this.retryCount);
+          this.retryCount++;
+          console.log(
+            `[whatsapp] Connection closed (code=${statusCode}), retry #${this.retryCount} in ${(delay / 1e3).toFixed(1)}s` + (socksProxy ? ` (proxy: ${socksProxy.replace(/\/\/.*@/, "//***@")})` : "")
+          );
+          setTimeout(() => void this.connect(config), delay);
+        } else {
+          console.log("[whatsapp] Logged out \u2014 clear auth and re-scan QR");
+        }
+      }
+      if (connection === "open") {
+        if (this.retryCount > 0) {
+          const downtimeSec = this.disconnectedAt > 0 ? ((Date.now() - this.disconnectedAt) / 1e3).toFixed(1) : "?";
+          console.log(
+            `[whatsapp] Reconnected after ${this.retryCount} retries (${downtimeSec}s downtime)`
+          );
+        } else {
+          console.log("[whatsapp] Connected via Baileys (linked device)");
+        }
+        this.connected = true;
+        this.retryCount = 0;
+        this.disconnectedAt = 0;
+      }
+    });
+    sock.ev.on("messages.upsert", (upsert) => {
+      if (!this.messageHandler) return;
+      const { messages, type } = upsert;
+      if (type !== "notify") return;
+      for (const msg of messages) {
+        if (msg.key.fromMe) continue;
+        const normalized = this.normalizeMessage(msg);
+        if (normalized) {
+          void this.messageHandler(normalized).catch((err) => {
+            console.error("[whatsapp] Message handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("message-receipt.update", (updates) => {
+      if (!this.messageHandler) return;
+      for (const update of updates) {
+        const receipt = this.normalizeReadReceipt(update);
+        if (receipt) {
+          void this.messageHandler(receipt).catch((err) => {
+            console.error("[whatsapp] Read receipt handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("contacts.upsert", (contacts) => {
+      if (!this.messageHandler) return;
+      for (const contact of contacts) {
+        const synced = this.normalizeContactSync(contact);
+        if (synced) {
+          void this.messageHandler(synced).catch((err) => {
+            console.error("[whatsapp] Contact sync handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("groups.upsert", (groups) => {
+      if (!this.messageHandler) return;
+      for (const group of groups) {
+        const normalized = this.normalizeGroupInfo(group);
+        if (normalized) {
+          void this.messageHandler(normalized).catch((err) => {
+            console.error("[whatsapp] Group handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("messages.reaction", (reactions) => {
+      if (!this.messageHandler) return;
+      for (const reaction of reactions) {
+        const normalized = this.normalizeReaction(reaction);
+        if (normalized) {
+          void this.messageHandler(normalized).catch((err) => {
+            console.error("[whatsapp] Reaction handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("call", (calls) => {
+      if (!this.messageHandler) return;
+      for (const call of calls) {
+        const normalized = this.normalizeCall(call);
+        if (normalized) {
+          void this.messageHandler(normalized).catch((err) => {
+            console.error("[whatsapp] Call handler error:", err);
+          });
+        }
+      }
+    });
+    sock.ev.on("messaging-history.set", (history) => {
+      if (!this.messageHandler) return;
+      const { messages: historyMessages } = history;
+      if (!Array.isArray(historyMessages)) return;
+      for (const msg of historyMessages) {
+        if (msg.key?.fromMe) continue;
+        const normalized = this.normalizeMessage(msg);
+        if (normalized) {
+          normalized.dataCategory = "history_sync";
+          normalized.isHistorical = true;
+          void this.messageHandler(normalized).catch((err) => {
+            console.error("[whatsapp] History sync handler error:", err);
+          });
+        }
+      }
+    });
+  }
+  async disconnect() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.sock?.ws?.close();
+    this.sock = null;
+    this.connected = false;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async sendText(channelId, text, options) {
+    if (!this.sock || !this.connected) throw new Error("WhatsApp not connected");
+    const jid = channelId.includes("@") ? channelId : `${channelId}@s.whatsapp.net`;
+    await this.sock.sendMessage(jid, {
+      text,
+      ...options?.replyToMessageId ? { quoted: { key: { remoteJid: jid, id: options.replyToMessageId } } } : {}
+    });
+  }
+  async sendTyping(channelId) {
+    if (!this.sock || !this.connected) return;
+    const jid = channelId.includes("@") ? channelId : `${channelId}@s.whatsapp.net`;
+    await this.sock.sendPresenceUpdate("composing", jid);
+  }
+  async healthCheck() {
+    return { connected: this.connected };
+  }
+  /** Verify webhook for backward compat — no-op for Baileys */
+  verifyWebhook(_mode, _token, _challenge) {
+    return null;
+  }
+  /** Inject message — no-op for Baileys (messages arrive via socket) */
+  async injectMessage(_rawPayload) {
+  }
+  normalizeMessage(msg) {
+    const text = msg.message?.conversation ?? msg.message?.extendedTextMessage?.text ?? msg.message?.imageMessage?.caption ?? msg.message?.videoMessage?.caption ?? msg.message?.documentMessage?.caption ?? "";
+    if (!text && !msg.message) return null;
+    const remoteJid = msg.key.remoteJid ?? "";
+    const isGroup = remoteJid.endsWith("@g.us");
+    const senderId = isGroup ? msg.key.participant ?? "" : remoteJid.replace("@s.whatsapp.net", "");
+    const media = this.extractMedia(msg.message);
+    const replyContext = msg.message?.extendedTextMessage?.contextInfo;
+    const location = this.extractLocation(msg.message);
+    const dataCategory = location ? "location" : "message";
+    return {
+      messageId: msg.key.id ?? randomUUID(),
+      platform: "whatsapp",
+      senderId,
+      senderName: msg.pushName ?? void 0,
+      senderPhone: senderId.replace("@s.whatsapp.net", ""),
+      channelId: remoteJid,
+      chatType: isGroup ? "group" : "direct",
+      text,
+      timestamp: msg.messageTimestamp ? new Date(Number(msg.messageTimestamp) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      media,
+      replyTo: replyContext?.quotedMessage ? {
+        messageId: replyContext.stanzaId ?? "",
+        text: replyContext.quotedMessage.conversation ?? "",
+        senderId: replyContext.participant ?? ""
+      } : void 0,
+      raw: msg,
+      dataCategory,
+      location
+    };
+  }
+  extractLocation(message) {
+    const loc = message?.locationMessage;
+    const live = message?.liveLocationMessage;
+    const src = loc ?? live;
+    if (!src) return void 0;
+    return {
+      latitude: src.degreesLatitude,
+      longitude: src.degreesLongitude,
+      address: src.address ?? void 0,
+      venueName: src.name ?? void 0,
+      isLive: !!live
+    };
+  }
+  normalizeReadReceipt(update) {
+    const key = update.key;
+    if (!key) return null;
+    const remoteJid = key.remoteJid ?? "";
+    const receipt = update.receipt;
+    if (!receipt) return null;
+    let status = "delivered";
+    if (receipt.readTimestamp || receipt.receiptTimestamp) {
+      status = "read";
+    }
+    const timestamp = receipt.readTimestamp ?? receipt.receiptTimestamp ?? Date.now() / 1e3;
+    return {
+      messageId: randomUUID(),
+      platform: "whatsapp",
+      senderId: remoteJid.replace("@s.whatsapp.net", "").replace("@g.us", ""),
+      channelId: remoteJid,
+      chatType: remoteJid.endsWith("@g.us") ? "group" : "direct",
+      text: "",
+      timestamp: new Date(Number(timestamp) * 1e3).toISOString(),
+      raw: update,
+      dataCategory: "read_receipt",
+      readReceipt: {
+        messageId: key.id ?? "",
+        status,
+        timestamp: new Date(Number(timestamp) * 1e3).toISOString(),
+        readBy: key.participant ?? void 0
+      }
+    };
+  }
+  normalizeContactSync(contact) {
+    const id = contact.id;
+    if (!id) return null;
+    const phone = id.replace("@s.whatsapp.net", "").replace("@g.us", "");
+    const name = contact.name ?? contact.notify ?? phone;
+    return {
+      messageId: randomUUID(),
+      platform: "whatsapp",
+      senderId: phone,
+      senderName: name,
+      senderPhone: phone,
+      channelId: id,
+      chatType: "direct",
+      text: "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      raw: contact,
+      dataCategory: "contact_sync",
+      contactSync: {
+        name,
+        phone,
+        pushName: contact.notify ?? void 0
+      }
+    };
+  }
+  normalizeGroupInfo(group) {
+    const groupId = group.id;
+    if (!groupId) return null;
+    const participants = (group.participants ?? []).map((p) => p.id ?? p);
+    const admins = (group.participants ?? []).filter((p) => p.admin === "admin" || p.admin === "superadmin").map((p) => p.id ?? p);
+    return {
+      messageId: randomUUID(),
+      platform: "whatsapp",
+      senderId: groupId,
+      channelId: groupId,
+      chatType: "group",
+      text: "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      raw: group,
+      dataCategory: "group",
+      groupInfo: {
+        groupId,
+        groupName: group.subject ?? "",
+        participants,
+        admins,
+        description: group.desc ?? void 0
+      }
+    };
+  }
+  normalizeReaction(reaction) {
+    const key = reaction.key;
+    if (!key) return null;
+    const reactionData = reaction.reaction;
+    if (!reactionData) return null;
+    const remoteJid = key.remoteJid ?? "";
+    return {
+      messageId: randomUUID(),
+      platform: "whatsapp",
+      senderId: reactionData.key?.participant ?? reactionData.key?.remoteJid?.replace("@s.whatsapp.net", "") ?? "",
+      channelId: remoteJid,
+      chatType: remoteJid.endsWith("@g.us") ? "group" : "direct",
+      text: "",
+      timestamp: reactionData.senderTimestampMs ? new Date(Number(reactionData.senderTimestampMs)).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      raw: reaction,
+      dataCategory: "reaction",
+      reaction: {
+        emoji: reactionData.text ?? "",
+        targetMessageId: key.id ?? "",
+        reactedBy: reactionData.key?.participant ?? reactionData.key?.remoteJid?.replace("@s.whatsapp.net", "") ?? "",
+        timestamp: reactionData.senderTimestampMs ? new Date(Number(reactionData.senderTimestampMs)).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  normalizeCall(call) {
+    const chatId = call.chatId ?? call.from;
+    if (!chatId) return null;
+    const caller = call.from?.replace("@s.whatsapp.net", "") ?? "";
+    return {
+      messageId: randomUUID(),
+      platform: "whatsapp",
+      senderId: caller,
+      channelId: chatId,
+      chatType: call.isGroup ? "group" : "direct",
+      text: "",
+      timestamp: call.date ? new Date(call.date * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      raw: call,
+      dataCategory: "call_log",
+      callLog: {
+        callType: call.isVideo ? "video" : "voice",
+        status: call.status ?? "offered",
+        duration: call.duration ?? void 0,
+        caller,
+        callee: call.from === chatId ? "" : chatId.replace("@s.whatsapp.net", ""),
+        timestamp: call.date ? new Date(call.date * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        isGroup: call.isGroup ?? false
+      }
+    };
+  }
+  extractMedia(message) {
+    if (!message) return void 0;
+    const media = [];
+    if (message.imageMessage) {
+      media.push({ type: "image", fileName: "image.jpg" });
+    }
+    if (message.videoMessage) {
+      media.push({ type: "video", fileName: "video.mp4" });
+    }
+    if (message.audioMessage) {
+      media.push({ type: "audio", fileName: "audio.ogg" });
+    }
+    if (message.documentMessage) {
+      media.push({
+        type: "document",
+        fileName: message.documentMessage.fileName ?? "document"
+      });
+    }
+    return media.length > 0 ? media : void 0;
+  }
+};
+
+export {
+  calculateBackoff,
+  WhatsAppAdapter
+};

package/dist/chunk-EEAKFEEA.js

@@ -0,0 +1,221 @@
+// src/lib/crdt-sync.ts
+import * as Y from "yjs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
+import path from "path";
+import { homedir } from "os";
+var DEFAULT_STATE_PATH = path.join(homedir(), ".exe-os", "crdt-state.bin");
+var _statePathOverride = null;
+function getStatePath() {
+  return _statePathOverride ?? DEFAULT_STATE_PATH;
+}
+function _setStatePath(p) {
+  _statePathOverride = p;
+}
+var doc = null;
+function initCrdtDoc() {
+  if (doc) return doc;
+  doc = new Y.Doc();
+  const sp = getStatePath();
+  if (existsSync(sp)) {
+    try {
+      const state = readFileSync(sp);
+      Y.applyUpdate(doc, new Uint8Array(state));
+    } catch {
+      console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
+      try {
+        unlinkSync(sp);
+      } catch {
+      }
+      rebuildFromDb().catch((err) => {
+        console.warn("[crdt-sync] rebuild from DB failed:", err);
+      });
+    }
+  }
+  doc.on("update", () => {
+    persistState();
+  });
+  return doc;
+}
+function getMemoriesMap() {
+  const d = initCrdtDoc();
+  return d.getMap("memories");
+}
+function getBehaviorsMap() {
+  const d = initCrdtDoc();
+  return d.getMap("behaviors");
+}
+function applyRemoteUpdate(update) {
+  const d = initCrdtDoc();
+  Y.applyUpdate(d, update);
+}
+function getFullState() {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d);
+}
+function getDiffUpdate(remoteStateVector) {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d, remoteStateVector);
+}
+function getStateVector() {
+  const d = initCrdtDoc();
+  return Y.encodeStateVector(d);
+}
+function importExistingMemories(memories) {
+  const map = getMemoriesMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const mem of memories) {
+      if (!mem.id) continue;
+      if (map.has(mem.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", mem.id);
+      entry.set("agent_id", mem.agent_id ?? null);
+      entry.set("agent_role", mem.agent_role ?? null);
+      entry.set("session_id", mem.session_id ?? null);
+      entry.set("timestamp", mem.timestamp ?? null);
+      entry.set("tool_name", mem.tool_name ?? null);
+      entry.set("project_name", mem.project_name ?? null);
+      entry.set("has_error", mem.has_error ?? 0);
+      entry.set("raw_text", mem.raw_text ?? "");
+      entry.set("version", mem.version ?? 0);
+      entry.set("author_device_id", mem.author_device_id ?? null);
+      entry.set("scope", mem.scope ?? "business");
+      map.set(mem.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function importExistingBehaviors(behaviors) {
+  const map = getBehaviorsMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const beh of behaviors) {
+      if (!beh.id) continue;
+      if (map.has(beh.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", beh.id);
+      entry.set("agent_id", beh.agent_id ?? null);
+      entry.set("project_name", beh.project_name ?? null);
+      entry.set("domain", beh.domain ?? null);
+      entry.set("content", beh.content ?? null);
+      entry.set("active", beh.active ?? 1);
+      entry.set("priority", beh.priority ?? "p1");
+      entry.set("created_at", beh.created_at ?? null);
+      entry.set("updated_at", beh.updated_at ?? null);
+      map.set(beh.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function readAllMemories() {
+  const map = getMemoriesMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      agent_role: entry.get("agent_role"),
+      session_id: entry.get("session_id"),
+      timestamp: entry.get("timestamp"),
+      tool_name: entry.get("tool_name"),
+      project_name: entry.get("project_name"),
+      has_error: entry.get("has_error"),
+      raw_text: entry.get("raw_text"),
+      version: entry.get("version"),
+      author_device_id: entry.get("author_device_id"),
+      scope: entry.get("scope"),
+      session_scope: entry.get("session_scope")
+    });
+  });
+  return records;
+}
+function readAllBehaviors() {
+  const map = getBehaviorsMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      project_name: entry.get("project_name"),
+      domain: entry.get("domain"),
+      content: entry.get("content"),
+      active: entry.get("active"),
+      priority: entry.get("priority"),
+      created_at: entry.get("created_at"),
+      updated_at: entry.get("updated_at")
+    });
+  });
+  return records;
+}
+function onUpdate(callback) {
+  const d = initCrdtDoc();
+  const handler = (update) => callback(update);
+  d.on("update", handler);
+  return () => d.off("update", handler);
+}
+function persistState() {
+  if (!doc) return;
+  try {
+    const sp = getStatePath();
+    const dir = path.dirname(sp);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const state = Y.encodeStateAsUpdate(doc);
+    writeFileSync(sp, Buffer.from(state));
+  } catch {
+  }
+}
+function isCrdtSyncEnabled() {
+  return process.env.EXE_CRDT_SYNC !== "0";
+}
+async function rebuildFromDb() {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const result = await client.execute(
+    "SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, version, author_device_id, scope, session_scope FROM memories"
+  );
+  const memories = result.rows.map((row) => ({
+    id: String(row.id),
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error,
+    raw_text: row.raw_text,
+    version: row.version,
+    author_device_id: row.author_device_id,
+    scope: row.scope,
+    session_scope: row.session_scope
+  }));
+  const count = importExistingMemories(memories);
+  persistState();
+  return count;
+}
+function destroyCrdtDoc() {
+  if (doc) {
+    doc.destroy();
+    doc = null;
+  }
+}
+
+export {
+  _setStatePath,
+  initCrdtDoc,
+  applyRemoteUpdate,
+  getFullState,
+  getDiffUpdate,
+  getStateVector,
+  importExistingMemories,
+  importExistingBehaviors,
+  readAllMemories,
+  readAllBehaviors,
+  onUpdate,
+  isCrdtSyncEnabled,
+  rebuildFromDb,
+  destroyCrdtDoc
+};