@superatomai/sdk-node 0.0.28-mds → 0.0.29-mds

package/dist/index.mjs

@@ -1340,7 +1340,30 @@ var Thread = class {
 // src/threads/thread-manager.ts
 var ThreadManager = class _ThreadManager {
   constructor() {
+    this.cleanupInterval = null;
+    // Threads older than 7 days are cleaned up
+    this.threadTtlMs = 7 * 24 * 60 * 60 * 1e3;
     this.threads = /* @__PURE__ */ new Map();
+    this.startCleanup();
+  }
+  /**
+   * Periodically remove threads older than 7 days.
+   * Runs every hour to avoid frequent iteration over the map.
+   */
+  startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      let removedCount = 0;
+      for (const [id, thread] of this.threads.entries()) {
+        if (now - thread.getCreatedAt().getTime() > this.threadTtlMs) {
+          this.threads.delete(id);
+          removedCount++;
+        }
+      }
+      if (removedCount > 0) {
+        console.log(`[ThreadManager] Cleaned up ${removedCount} threads older than 7 days (${this.threads.size} remaining)`);
+      }
+    }, 24 * 60 * 60 * 1e3);
   }
   /**
    * Get singleton instance of ThreadManager
@@ -1429,15 +1452,24 @@ var ThreadManager = class _ThreadManager {
 };
 
 // src/utils/query-cache.ts
+import crypto from "crypto";
 var QueryCache = class {
   constructor() {
     this.cache = /* @__PURE__ */ new Map();
-    this.queryIdCache = /* @__PURE__ */ new Map();
     this.ttlMs = 10 * 60 * 1e3;
-    // Default: 10 minutes (for data cache only)
+    // Default: 10 minutes
+    this.maxCacheSize = 500;
+    // Max data cache entries
     this.cleanupInterval = null;
+    // Encryption for queryId tokens
+    this.algorithm = "aes-256-gcm";
+    const keySource = process.env.QUERY_TOKEN_SECRET || "superatom-query-cache-default-key-v1";
+    this.encryptionKey = crypto.createHash("sha256").update(keySource).digest();
     this.startCleanup();
   }
+  // ============================================
+  // Data Cache (TTL-based, max size)
+  // ============================================
   /**
    * Set the cache TTL (Time To Live)
    * @param minutes - TTL in minutes (default: 10)
@@ -1453,10 +1485,13 @@ var QueryCache = class {
     return this.ttlMs / 60 / 1e3;
   }
   /**
-   * Store query result in cache
-   * Key is the exact query string (or JSON for parameterized queries)
+   * Store query result in data cache
    */
   set(query, data) {
+    if (this.cache.size >= this.maxCacheSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) this.cache.delete(oldestKey);
+    }
     this.cache.set(query, {
       query,
       data,
@@ -1469,12 +1504,9 @@ var QueryCache = class {
    */
   get(query) {
     const entry = this.cache.get(query);
-    if (!entry) {
-      return null;
-    }
+    if (!entry) return null;
     if (Date.now() - entry.timestamp > this.ttlMs) {
       this.cache.delete(query);
-      logger.debug(`[QueryCache] Entry expired for query (${query.substring(0, 50)}...)`);
       return null;
     }
     logger.info(`[QueryCache] Cache HIT for query (${query.substring(0, 50)}...)`);
@@ -1511,14 +1543,13 @@ var QueryCache = class {
     }
     return {
       size: this.cache.size,
-      queryIdCount: this.queryIdCache.size,
+      queryIdCount: 0,
+      // No longer stored in memory
       oldestEntryAge: oldestTimestamp ? Date.now() - oldestTimestamp : null
     };
   }
   /**
-   * Start periodic cleanup of expired entries.
-   * Only cleans the data cache — queryIdCache entries are permanent (server lifetime)
-   * because queryIds are persisted in dashboard widgets.
+   * Start periodic cleanup of expired data cache entries.
    */
   startCleanup() {
     this.cleanupInterval = setInterval(() => {
@@ -1530,61 +1561,81 @@ var QueryCache = class {
           expiredCount++;
         }
       }
-      for (const entry of this.queryIdCache.values()) {
-        if (entry.data && now - entry.timestamp > this.ttlMs) {
-          entry.data = null;
-        }
-      }
       if (expiredCount > 0) {
-        logger.debug(`[QueryCache] Cleaned up ${expiredCount} expired data-cache entries`);
+        logger.debug(`[QueryCache] Cleaned up ${expiredCount} expired data-cache entries (${this.cache.size} remaining)`);
       }
     }, 2 * 60 * 1e3);
   }
   // ============================================
-  // Query ID Store — maps queryId → query (no SQL sent to frontend)
+  // Encrypted Query ID Tokens (zero memory)
   // ============================================
   /**
-   * Generate a unique query ID
+   * Encrypt a payload into a self-contained token.
    */
-  generateQueryId() {
-    return `qry_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+  encrypt(payload) {
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv(this.algorithm, this.encryptionKey, iv);
+    let encrypted = cipher.update(payload, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    const authTag = cipher.getAuthTag();
+    return iv.toString("base64") + "." + authTag.toString("base64") + "." + encrypted;
   }
   /**
-   * Store a query by ID. Returns the generated queryId.
-   * The query is stored server-side; only the queryId is sent to the frontend.
+   * Decrypt a token back to the original payload.
+   */
+  decrypt(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) return null;
+      const iv = Buffer.from(parts[0], "base64");
+      const authTag = Buffer.from(parts[1], "base64");
+      const encrypted = parts[2];
+      const decipher = crypto.createDecipheriv(this.algorithm, this.encryptionKey, iv);
+      decipher.setAuthTag(authTag);
+      let decrypted = decipher.update(encrypted, "base64", "utf8");
+      decrypted += decipher.final("utf8");
+      return decrypted;
+    } catch (err) {
+      logger.warn(`[QueryCache] Failed to decrypt queryId token: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+  /**
+   * Store a query by generating an encrypted token as queryId.
+   * The SQL is encrypted INTO the token — nothing stored in memory.
+   * If data is provided, it's cached temporarily in the data cache.
    */
   storeQuery(query, data) {
-    const queryId = this.generateQueryId();
-    this.queryIdCache.set(queryId, {
-      queryId,
-      query,
-      data: data || null,
-      timestamp: Date.now()
-    });
-    const queryPreview = typeof query === "string" ? query.substring(0, 50) : JSON.stringify(query).substring(0, 50);
-    logger.debug(`[QueryCache] Stored query as ${queryId} (${queryPreview}...)`);
+    const payload = typeof query === "string" ? query : JSON.stringify(query);
+    const queryId = this.encrypt(payload);
+    if (data) {
+      this.set(queryId, data);
+    }
+    const queryPreview = payload.substring(0, 50);
+    logger.debug(`[QueryCache] Stored query as encrypted token (${queryPreview}...)`);
     return queryId;
   }
   /**
-   * Get a stored query by its ID.
-   * The SQL mapping never expires (queryIds are persisted in dashboard widgets).
-   * Cached data may be null if it was evicted by the cleanup interval.
+   * Get a stored query by decrypting its token.
+   * Returns the SQL + any cached result data.
    */
   getQuery(queryId) {
-    const entry = this.queryIdCache.get(queryId);
-    if (!entry) return null;
-    entry.timestamp = Date.now();
-    return { query: entry.query, data: entry.data };
+    const decrypted = this.decrypt(queryId);
+    if (!decrypted) return null;
+    let query;
+    try {
+      query = JSON.parse(decrypted);
+    } catch {
+      query = decrypted;
+    }
+    const cachedData = this.get(queryId);
+    return { query, data: cachedData };
   }
   /**
-   * Update cached data for a queryId
+   * Update cached data for a queryId token
    */
   setQueryData(queryId, data) {
-    const entry = this.queryIdCache.get(queryId);
-    if (entry) {
-      entry.data = data;
-      entry.timestamp = Date.now();
-    }
+    this.set(queryId, data);
   }
   /**
    * Stop cleanup interval (for graceful shutdown)
@@ -1595,7 +1646,6 @@ var QueryCache = class {
       this.cleanupInterval = null;
     }
     this.cache.clear();
-    this.queryIdCache.clear();
   }
 };
 var queryCache = new QueryCache();
@@ -2198,7 +2248,7 @@ async function handleBundleRequest(data, bundleDir, sendMessage) {
 }
 
 // src/auth/utils.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 function decodeBase64ToJson(base64Data) {
   try {
     const decodedString = Buffer.from(base64Data, "base64").toString("utf-8");
@@ -2208,7 +2258,7 @@ function decodeBase64ToJson(base64Data) {
   }
 }
 function hashPassword(password) {
-  return crypto.createHash("sha1").update(password).digest("hex");
+  return crypto2.createHash("sha1").update(password).digest("hex");
 }
 
 // src/auth/user-storage.ts