@askexenow/exe-os 0.9.279 → 0.9.280

package/dist/chunk-OADURIIN.js

@@ -0,0 +1,258 @@
+// src/lib/message-queue.ts
+var DEFAULT_MAX_SIZE = 1e3;
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var MessageQueue = class {
+  queue = [];
+  maxSize;
+  ttlMs;
+  constructor(maxSize = DEFAULT_MAX_SIZE, ttlMs = DEFAULT_TTL_MS) {
+    this.maxSize = maxSize;
+    this.ttlMs = ttlMs;
+  }
+  /** Add a message to the queue. Drops oldest if at capacity. */
+  enqueue(data) {
+    this.pruneExpired();
+    if (this.queue.length >= this.maxSize) {
+      process.stderr.write(`[msg-queue] Dropping oldest message (queue at ${this.maxSize} cap)
+`);
+      this.queue.shift();
+    }
+    this.queue.push({ data, enqueuedAt: Date.now() });
+  }
+  /** Remove and return all queued messages (oldest first). Prunes expired entries. */
+  flush() {
+    this.pruneExpired();
+    const messages = this.queue.map((m) => m.data);
+    this.queue = [];
+    return messages;
+  }
+  /** Current number of queued (non-expired) messages. */
+  get size() {
+    this.pruneExpired();
+    return this.queue.length;
+  }
+  /** Remove all messages from the queue. */
+  clear() {
+    this.queue = [];
+  }
+  /** Remove messages whose TTL has expired. */
+  pruneExpired() {
+    const now = Date.now();
+    this.queue = this.queue.filter((m) => now - m.enqueuedAt < this.ttlMs);
+  }
+};
+
+// src/lib/gateway-client.ts
+var MIN_RECONNECT_MS = 1e3;
+var MAX_RECONNECT_MS = 3e4;
+var AUTH_RESPONSE_TIMEOUT_MS = 5e3;
+var DEFAULT_CHANNELS = ["all"];
+var GATEWAY_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message_received",
+  "response_sent",
+  "agent_status",
+  "health",
+  "escalation"
+]);
+function createGatewayClient(config) {
+  assertSecureWsUrl(config.url);
+  let ws = null;
+  let currentStatus = "disconnected";
+  let closed = false;
+  let reconnectDelay = MIN_RECONNECT_MS;
+  let reconnectTimer = null;
+  let authTimer = null;
+  const eventHandlers = /* @__PURE__ */ new Set();
+  const statusHandlers = /* @__PURE__ */ new Set();
+  const channels = config.channels ?? DEFAULT_CHANNELS;
+  const outboundQueue = new MessageQueue();
+  function setStatus(next) {
+    if (next === currentStatus) return;
+    currentStatus = next;
+    for (const handler of statusHandlers) {
+      handler(next);
+    }
+  }
+  function connect() {
+    if (closed) return;
+    setStatus("connecting");
+    try {
+      ws = new WebSocket(config.url);
+      ws.onopen = () => {
+        setStatus("authenticating");
+        sendRaw({ type: "auth", token: config.authTokenHex });
+        authTimer = setTimeout(() => {
+          if (currentStatus === "authenticating") {
+            ws?.close();
+          }
+        }, AUTH_RESPONSE_TIMEOUT_MS);
+      };
+      ws.onmessage = (event) => {
+        const data = typeof event.data === "string" ? event.data : String(event.data);
+        handleMessage(data);
+      };
+      ws.onclose = () => {
+        clearAuthTimer();
+        if (!closed) {
+          setStatus("reconnecting");
+          scheduleReconnect();
+        } else {
+          setStatus("disconnected");
+        }
+      };
+      ws.onerror = () => {
+      };
+    } catch {
+      setStatus("reconnecting");
+      scheduleReconnect();
+    }
+  }
+  function handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "auth" && msg.status === "ok") {
+      clearAuthTimer();
+      reconnectDelay = MIN_RECONNECT_MS;
+      setStatus("connected");
+      if (channels.length > 0) {
+        sendRaw({ type: "subscribe", channels });
+      }
+      const queued = outboundQueue.flush();
+      for (const data of queued) {
+        try {
+          ws?.send(data);
+        } catch {
+        }
+      }
+      return;
+    }
+    if (msg.type === "error" && currentStatus === "authenticating") {
+      clearAuthTimer();
+      ws?.close();
+      return;
+    }
+    if (msg.type === "ping") {
+      sendRaw({ type: "pong" });
+      return;
+    }
+    if (currentStatus === "connected" && isGatewayEvent(msg)) {
+      for (const handler of eventHandlers) {
+        handler(msg);
+      }
+    }
+  }
+  function sendRaw(data) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      try {
+        ws.send(JSON.stringify(data));
+      } catch {
+      }
+    }
+  }
+  function scheduleReconnect() {
+    if (closed || reconnectTimer) return;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_MS);
+      connect();
+    }, reconnectDelay);
+  }
+  function clearAuthTimer() {
+    if (authTimer) {
+      clearTimeout(authTimer);
+      authTimer = null;
+    }
+  }
+  connect();
+  return {
+    get status() {
+      return currentStatus;
+    },
+    get queueSize() {
+      return outboundQueue.size;
+    },
+    send(data) {
+      const serialized = JSON.stringify(data);
+      if (currentStatus === "connected" && ws?.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(serialized);
+        } catch {
+          outboundQueue.enqueue(serialized);
+        }
+      } else {
+        outboundQueue.enqueue(serialized);
+      }
+    },
+    onEvent(handler) {
+      eventHandlers.add(handler);
+      return () => {
+        eventHandlers.delete(handler);
+      };
+    },
+    onStatusChange(handler) {
+      statusHandlers.add(handler);
+      return () => {
+        statusHandlers.delete(handler);
+      };
+    },
+    close() {
+      closed = true;
+      clearAuthTimer();
+      outboundQueue.clear();
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+        ws = null;
+      }
+      setStatus("disconnected");
+    }
+  };
+}
+async function connectGateway(url) {
+  const { getMasterKey } = await import("./lib/keychain.js");
+  const { deriveWsAuthToken } = await import("./lib/ws-auth.js");
+  const masterKey = await getMasterKey();
+  if (!masterKey) return null;
+  const token = deriveWsAuthToken(masterKey);
+  return createGatewayClient({
+    url,
+    authTokenHex: token.toString("hex")
+  });
+}
+var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
+function assertSecureWsUrl(url) {
+  if (url.startsWith("wss://")) return;
+  if (url.startsWith("ws://")) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new Error(
+        `Malformed WebSocket URL rejected: "${url}".`
+      );
+    }
+    if (LOCALHOST_PATTERNS.test(parsed.hostname)) return;
+    throw new Error(
+      `Insecure WebSocket URL rejected: "${url}". Use wss:// for remote hosts. Plain ws:// is only allowed for localhost.`
+    );
+  }
+}
+function isGatewayEvent(msg) {
+  return typeof msg.type === "string" && GATEWAY_EVENT_TYPES.has(msg.type);
+}
+
+export {
+  createGatewayClient,
+  connectGateway,
+  assertSecureWsUrl
+};

package/dist/chunk-OCYNSIQR.js

@@ -0,0 +1,204 @@
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+
+// src/lib/pipeline-router.ts
+import crypto from "crypto";
+async function sinkConversationStore(msg, agentResponse, agentName) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
+    await client.execute({
+      sql: `INSERT INTO conversations
+            (id, platform, external_id, sender_id, sender_name, sender_phone, sender_email,
+             recipient_id, channel_id, thread_id, reply_to_id,
+             content_text, content_media, agent_response, agent_name,
+             timestamp, ingested_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        msg.platform,
+        msg.messageId,
+        msg.senderId,
+        msg.senderName ?? null,
+        msg.senderPhone ?? null,
+        msg.senderEmail ?? null,
+        msg.accountId ?? null,
+        msg.channelId,
+        msg.threadId ?? `${msg.platform}:${msg.channelId}`,
+        msg.replyTo?.messageId ?? null,
+        msg.text ?? null,
+        mediaJson,
+        agentResponse ?? null,
+        agentName ?? null,
+        msg.timestamp,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] conversation-store error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkMemory(msg, agentResponse, agentName) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const { writeMemory, flushBatch } = await import("./lib/store.js");
+    const direction = agentResponse ? "conversation" : "inbound";
+    const rawText = [
+      `[${msg.platform}] ${direction} from ${msg.senderName ?? msg.senderId}`,
+      msg.text ? `Message: ${msg.text}` : null,
+      agentResponse ? `Agent (${agentName ?? "unknown"}): ${agentResponse}` : null
+    ].filter(Boolean).join("\n");
+    const vector = await embed(rawText);
+    await writeMemory({
+      id: crypto.randomUUID(),
+      agent_id: agentName ?? "gateway",
+      agent_role: "gateway",
+      session_id: `gateway-${msg.platform}`,
+      timestamp: msg.timestamp,
+      tool_name: `gateway-${msg.platform}`,
+      project_name: "exe-os",
+      has_error: false,
+      raw_text: rawText,
+      vector,
+      importance: 4,
+      confidence: 0.8
+    });
+    await flushBatch();
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] memory-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkCRM(msg, agentResponse, agentName) {
+  try {
+    const { isCRMBridgeEnabled, pushConversationToCRM, pushInboundMessageToCRM } = await import("./crm-bridge-BVTB6LZK.js");
+    if (!isCRMBridgeEnabled()) return false;
+    if (agentResponse) {
+      await pushConversationToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        agentResponse,
+        agentName: agentName ?? "unknown",
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    } else {
+      await pushInboundMessageToCRM({
+        platform: msg.platform,
+        senderId: msg.senderId,
+        senderName: msg.senderName,
+        messageText: msg.text,
+        timestamp: msg.timestamp,
+        accountId: msg.accountId
+      });
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] crm-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkWiki(msg, agentResponse) {
+  try {
+    const { createWikiClient } = await import("./wiki-client-HETQ6XHM.js");
+    const client = await createWikiClient();
+    if (!client) return false;
+    const content = msg.text ?? "";
+    if (content.length < 50) return false;
+    const { chatInWorkspace } = await import("./wiki-client-HETQ6XHM.js");
+    const ingestText = [
+      `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
+      content,
+      agentResponse ? `
+Agent response: ${agentResponse}` : ""
+    ].join("\n");
+    await chatInWorkspace(client, "conversations", ingestText, "chat");
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] wiki-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation } = await import("./conversation-entity-extractor-W25VJFOH.js");
+    const { storeExtraction } = await import("./graph-rag-4BVYONA4.js");
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction(client, extraction, memoryId, msg.timestamp);
+    import("./conversation-wiki-populator-CIWEI4FV.js").then(
+      ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
+async function ingest(msg, agentResponse, agentName) {
+  const errors = [];
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
+    sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`conversation: ${e}`);
+      return false;
+    }),
+    sinkMemory(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`memory: ${e}`);
+      return false;
+    }),
+    sinkCRM(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`crm: ${e}`);
+      return false;
+    }),
+    sinkWiki(msg, agentResponse).catch((e) => {
+      errors.push(`wiki: ${e}`);
+      return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
+    })
+  ]);
+  if (errors.length > 0) {
+    process.stderr.write(
+      `[pipeline] ${errors.length} sink error(s): ${errors.join("; ")}
+`
+    );
+  }
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
+}
+
+export {
+  ingest
+};