@dexto/core 1.2.4 → 1.2.6

package/dist/storage/blob/local-blob-store.js

@@ -3,8 +3,7 @@ import { promises as fs, createReadStream } from "fs";
 import path from "path";
 import { createHash } from "crypto";
 import { pathToFileURL } from "url";
-import { logger } from "../../logger/index.js";
-import { getDextoPath } from "../../utils/path.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { StorageError } from "../errors.js";
 class LocalBlobStore {
   config;
@@ -13,27 +12,13 @@ class LocalBlobStore {
   statsCache = null;
   statsCachePromise = null;
   lastStatsRefresh = 0;
-  agentId;
+  logger;
   static STATS_REFRESH_INTERVAL_MS = 6e4;
   // 1 minute
-  constructor(config, agentId) {
+  constructor(config, logger) {
     this.config = config;
-    if (agentId) {
-      const trimmed = agentId.trim();
-      if (!trimmed) {
-        throw StorageError.blobInvalidConfig("agentId cannot be empty or whitespace-only");
-      }
-      if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
-        throw StorageError.blobInvalidConfig(
-          "agentId must contain only alphanumeric characters, hyphens, and underscores"
-        );
-      }
-      this.agentId = trimmed;
-    } else {
-      this.agentId = agentId;
-    }
-    const blobSubdir = this.agentId ? `blobs-${this.agentId}` : "blobs";
-    this.storePath = config.storePath || getDextoPath("data", blobSubdir);
+    this.storePath = config.storePath;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
   }
   async connect() {
     if (this.connected) return;
@@ -42,14 +27,14 @@ class LocalBlobStore {
       await this.refreshStatsCache();
       this.lastStatsRefresh = Date.now();
       this.connected = true;
-      logger.debug(`LocalBlobStore connected at: ${this.storePath}`);
+      this.logger.debug(`LocalBlobStore connected at: ${this.storePath}`);
     } catch (error) {
       throw StorageError.blobOperationFailed("connect", "local", error);
     }
   }
   async disconnect() {
     this.connected = false;
-    logger.debug("LocalBlobStore disconnected");
+    this.logger.debug("LocalBlobStore disconnected");
   }
   /**
    * Normalize metadata after JSON parsing to ensure createdAt is a Date object
@@ -82,7 +67,9 @@ class LocalBlobStore {
       const existingMeta = await fs.readFile(metaPath, "utf-8");
       const parsed = JSON.parse(existingMeta);
       const existingMetadata = this.normalizeMetadata(parsed);
-      logger.debug(`Blob ${id} already exists, returning existing reference (deduplication)`);
+      this.logger.debug(
+        `Blob ${id} already exists, returning existing reference (deduplication)`
+      );
       return {
         id,
         uri: `blob:${id}`,
@@ -114,7 +101,9 @@ class LocalBlobStore {
         fs.writeFile(blobPath, buffer),
         fs.writeFile(metaPath, JSON.stringify(storedMetadata, null, 2))
       ]);
-      logger.debug(`Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`);
+      this.logger.debug(
+        `Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`
+      );
       this.updateStatsCacheAfterStore(buffer.length);
       return {
         id,
@@ -203,7 +192,7 @@ class LocalBlobStore {
       const parsed = JSON.parse(metaContent);
       const metadata = this.normalizeMetadata(parsed);
       await Promise.all([fs.unlink(blobPath), fs.unlink(metaPath)]);
-      logger.debug(`Deleted blob: ${id}`);
+      this.logger.debug(`Deleted blob: ${id}`);
       this.updateStatsCacheAfterDelete(metadata.size);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -239,14 +228,16 @@ class LocalBlobStore {
             ]);
             deletedCount++;
             this.updateStatsCacheAfterDelete(metadata.size);
-            logger.debug(`Cleaned up old blob: ${id}`);
+            this.logger.debug(`Cleaned up old blob: ${id}`);
           }
         } catch (error) {
-          logger.warn(`Failed to process blob metadata ${metaFile}: ${String(error)}`);
+          this.logger.warn(
+            `Failed to process blob metadata ${metaFile}: ${String(error)}`
+          );
         }
       }
       if (deletedCount > 0) {
-        logger.info(`Blob cleanup: removed ${deletedCount} old blobs`);
+        this.logger.info(`Blob cleanup: removed ${deletedCount} old blobs`);
       }
       return deletedCount;
     } catch (error) {
@@ -289,12 +280,14 @@ class LocalBlobStore {
             metadata
           });
         } catch (error) {
-          logger.warn(`Failed to process blob metadata ${metaFile}: ${String(error)}`);
+          this.logger.warn(
+            `Failed to process blob metadata ${metaFile}: ${String(error)}`
+          );
         }
       }
       return blobs;
     } catch (error) {
-      logger.warn(`Failed to list blobs: ${String(error)}`);
+      this.logger.warn(`Failed to list blobs: ${String(error)}`);
       return [];
     }
   }
@@ -326,13 +319,13 @@ class LocalBlobStore {
           const stat = await fs.stat(path.join(this.storePath, datFile));
           stats.totalSize += stat.size;
         } catch (error) {
-          logger.debug(
+          this.logger.debug(
             `Skipping size calculation for ${datFile}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
     } catch (error) {
-      logger.warn(`Failed to refresh blob stats cache: ${String(error)}`);
+      this.logger.warn(`Failed to refresh blob stats cache: ${String(error)}`);
     }
     this.statsCache = stats;
   }

package/dist/storage/blob/memory-blob-store.cjs

@@ -0,0 +1,326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memory_blob_store_exports = {};
+__export(memory_blob_store_exports, {
+  InMemoryBlobStore: () => InMemoryBlobStore
+});
+module.exports = __toCommonJS(memory_blob_store_exports);
+var import_crypto = require("crypto");
+var import_stream = require("stream");
+var import_types = require("../../logger/v2/types.js");
+var import_errors = require("../errors.js");
+class InMemoryBlobStore {
+  config;
+  blobs = /* @__PURE__ */ new Map();
+  connected = false;
+  logger;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
+  }
+  async connect() {
+    if (this.connected) return;
+    this.connected = true;
+    this.logger.debug("InMemoryBlobStore connected");
+  }
+  async disconnect() {
+    this.blobs.clear();
+    this.connected = false;
+    this.logger.debug("InMemoryBlobStore disconnected");
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async store(input, metadata = {}) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    const buffer = await this.inputToBuffer(input);
+    if (buffer.length > this.config.maxBlobSize) {
+      throw import_errors.StorageError.blobSizeExceeded(buffer.length, this.config.maxBlobSize);
+    }
+    const hash = (0, import_crypto.createHash)("sha256").update(buffer).digest("hex").substring(0, 16);
+    const id = hash;
+    const existing = this.blobs.get(id);
+    if (existing) {
+      this.logger.debug(
+        `Blob ${id} already exists, returning existing reference (deduplication)`
+      );
+      return {
+        id,
+        uri: `blob:${id}`,
+        metadata: existing.metadata
+      };
+    }
+    const currentSize = this.getTotalSize();
+    if (currentSize + buffer.length > this.config.maxTotalSize) {
+      throw import_errors.StorageError.blobTotalSizeExceeded(
+        currentSize + buffer.length,
+        this.config.maxTotalSize
+      );
+    }
+    const storedMetadata = {
+      id,
+      mimeType: metadata.mimeType || this.detectMimeType(buffer, metadata.originalName),
+      originalName: metadata.originalName,
+      createdAt: metadata.createdAt || /* @__PURE__ */ new Date(),
+      source: metadata.source || "system",
+      size: buffer.length,
+      hash
+    };
+    this.blobs.set(id, { data: buffer, metadata: storedMetadata });
+    this.logger.debug(`Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`);
+    return {
+      id,
+      uri: `blob:${id}`,
+      metadata: storedMetadata
+    };
+  }
+  async retrieve(reference, format = "base64") {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    const blob = this.blobs.get(id);
+    if (!blob) {
+      throw import_errors.StorageError.blobNotFound(reference);
+    }
+    switch (format) {
+      case "base64":
+        return {
+          format: "base64",
+          data: blob.data.toString("base64"),
+          metadata: blob.metadata
+        };
+      case "buffer":
+        return {
+          format: "buffer",
+          data: Buffer.from(blob.data),
+          metadata: { ...blob.metadata }
+        };
+      case "path":
+        throw new Error(
+          "Path format not supported for in-memory blobs. Use local blob storage for filesystem paths."
+        );
+      case "stream": {
+        const stream = import_stream.Readable.from(blob.data);
+        return {
+          format: "stream",
+          data: stream,
+          metadata: blob.metadata
+        };
+      }
+      case "url": {
+        const base64 = blob.data.toString("base64");
+        const mimeType = blob.metadata.mimeType || "application/octet-stream";
+        const dataUrl = `data:${mimeType};base64,${base64}`;
+        return {
+          format: "url",
+          data: dataUrl,
+          metadata: blob.metadata
+        };
+      }
+      default:
+        throw import_errors.StorageError.blobInvalidInput(format, `Unsupported format: ${format}`);
+    }
+  }
+  async exists(reference) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    return this.blobs.has(id);
+  }
+  async delete(reference) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    if (!this.blobs.has(id)) {
+      throw import_errors.StorageError.blobNotFound(reference);
+    }
+    this.blobs.delete(id);
+    this.logger.debug(`Deleted blob: ${id}`);
+  }
+  async cleanup(olderThan) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    const cutoffDate = olderThan || new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
+    let deletedCount = 0;
+    for (const [id, { metadata }] of this.blobs.entries()) {
+      if (metadata.createdAt < cutoffDate) {
+        this.blobs.delete(id);
+        deletedCount++;
+        this.logger.debug(`Cleaned up old blob: ${id}`);
+      }
+    }
+    if (deletedCount > 0) {
+      this.logger.info(`Blob cleanup: removed ${deletedCount} old blobs from memory`);
+    }
+    return deletedCount;
+  }
+  async getStats() {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    return {
+      count: this.blobs.size,
+      totalSize: this.getTotalSize(),
+      backendType: "in-memory",
+      storePath: "memory://"
+    };
+  }
+  async listBlobs() {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("in-memory");
+    }
+    return Array.from(this.blobs.entries()).map(([id, { metadata }]) => ({
+      id,
+      uri: `blob:${id}`,
+      metadata
+    }));
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  /**
+   * Calculate total size of all blobs in memory
+   */
+  getTotalSize() {
+    return Array.from(this.blobs.values()).reduce((sum, { data }) => sum + data.length, 0);
+  }
+  /**
+   * Convert various input types to Buffer.
+   * Copied from LocalBlobStore with minor adaptations.
+   */
+  async inputToBuffer(input) {
+    if (Buffer.isBuffer(input)) {
+      return input;
+    }
+    if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    }
+    if (input instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(input));
+    }
+    if (typeof input === "string") {
+      if (input.startsWith("data:")) {
+        const commaIndex = input.indexOf(",");
+        if (commaIndex !== -1 && input.includes(";base64,")) {
+          const base64Data = input.substring(commaIndex + 1);
+          return Buffer.from(base64Data, "base64");
+        }
+        throw import_errors.StorageError.blobEncodingError(
+          "inputToBuffer",
+          "Unsupported data URI format"
+        );
+      }
+      try {
+        return Buffer.from(input, "base64");
+      } catch {
+        throw import_errors.StorageError.blobEncodingError("inputToBuffer", "Invalid base64 string");
+      }
+    }
+    throw import_errors.StorageError.blobInvalidInput(input, `Unsupported input type: ${typeof input}`);
+  }
+  /**
+   * Parse blob reference to extract ID.
+   * Copied from LocalBlobStore.
+   */
+  parseReference(reference) {
+    if (!reference) {
+      throw import_errors.StorageError.blobInvalidReference(reference, "Empty reference");
+    }
+    if (reference.startsWith("blob:")) {
+      const id = reference.substring(5);
+      if (!id) {
+        throw import_errors.StorageError.blobInvalidReference(reference, "Empty blob ID after prefix");
+      }
+      return id;
+    }
+    return reference;
+  }
+  /**
+   * Detect MIME type from buffer content and/or filename.
+   * Copied from LocalBlobStore.
+   */
+  detectMimeType(buffer, filename) {
+    const header = buffer.subarray(0, 16);
+    if (header.length >= 3) {
+      const jpegSignature = header.subarray(0, 3);
+      if (jpegSignature.equals(Buffer.from([255, 216, 255]))) {
+        return "image/jpeg";
+      }
+    }
+    if (header.length >= 4) {
+      const signature = header.subarray(0, 4);
+      if (signature.equals(Buffer.from([137, 80, 78, 71]))) return "image/png";
+      if (signature.equals(Buffer.from([71, 73, 70, 56]))) return "image/gif";
+      if (signature.equals(Buffer.from([37, 80, 68, 70]))) return "application/pdf";
+    }
+    if (filename) {
+      const ext = filename.split(".").pop()?.toLowerCase();
+      const mimeTypes = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        pdf: "application/pdf",
+        txt: "text/plain",
+        json: "application/json",
+        xml: "text/xml",
+        html: "text/html",
+        css: "text/css",
+        js: "text/javascript",
+        md: "text/markdown",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        wav: "audio/wav"
+      };
+      if (ext && mimeTypes[ext]) return mimeTypes[ext];
+    }
+    if (this.isTextBuffer(buffer)) {
+      return "text/plain";
+    }
+    return "application/octet-stream";
+  }
+  /**
+   * Check if buffer contains text content.
+   * Copied from LocalBlobStore.
+   */
+  isTextBuffer(buffer) {
+    let printableCount = 0;
+    const sampleSize = Math.min(512, buffer.length);
+    for (let i = 0; i < sampleSize; i++) {
+      const byte = buffer[i];
+      if (byte !== void 0 && (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13)) {
+        printableCount++;
+      }
+    }
+    return printableCount / sampleSize > 0.7;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryBlobStore
+});

package/dist/storage/blob/memory-blob-store.d.ts

@@ -0,0 +1,66 @@
+import type { IDextoLogger } from '../../logger/v2/types.js';
+import type { BlobStore, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats } from './types.js';
+import type { InMemoryBlobStoreConfig } from './schemas.js';
+/**
+ * In-memory blob store implementation.
+ *
+ * Stores blobs in memory with content-based deduplication and size limits.
+ * Suitable for development, testing, and scenarios where blob persistence
+ * across restarts is not required.
+ *
+ * Features:
+ * - Content-based deduplication (same as LocalBlobStore)
+ * - Configurable size limits (per-blob and total)
+ * - Automatic cleanup of old blobs
+ * - MIME type detection
+ * - Multi-format retrieval (base64, buffer, stream, data URI)
+ *
+ * Limitations:
+ * - Data lost on restart (no persistence)
+ * - Path format not supported (no filesystem)
+ * - Memory usage proportional to blob size
+ */
+export declare class InMemoryBlobStore implements BlobStore {
+    private config;
+    private blobs;
+    private connected;
+    private logger;
+    constructor(config: InMemoryBlobStoreConfig, logger: IDextoLogger);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    store(input: BlobInput, metadata?: BlobMetadata): Promise<BlobReference>;
+    retrieve(reference: string, format?: 'base64' | 'buffer' | 'path' | 'stream' | 'url'): Promise<BlobData>;
+    exists(reference: string): Promise<boolean>;
+    delete(reference: string): Promise<void>;
+    cleanup(olderThan?: Date): Promise<number>;
+    getStats(): Promise<BlobStats>;
+    listBlobs(): Promise<BlobReference[]>;
+    getStoragePath(): string | undefined;
+    /**
+     * Calculate total size of all blobs in memory
+     */
+    private getTotalSize;
+    /**
+     * Convert various input types to Buffer.
+     * Copied from LocalBlobStore with minor adaptations.
+     */
+    private inputToBuffer;
+    /**
+     * Parse blob reference to extract ID.
+     * Copied from LocalBlobStore.
+     */
+    private parseReference;
+    /**
+     * Detect MIME type from buffer content and/or filename.
+     * Copied from LocalBlobStore.
+     */
+    private detectMimeType;
+    /**
+     * Check if buffer contains text content.
+     * Copied from LocalBlobStore.
+     */
+    private isTextBuffer;
+}
+//# sourceMappingURL=memory-blob-store.d.ts.map

package/dist/storage/blob/memory-blob-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-blob-store.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/memory-blob-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,SAAS,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAkB,YAAW,SAAS;IAC/C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,KAAK,CAA0E;IACvF,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,YAAY;IAK3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAMxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAIhB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,GAAE,YAAiB,GAAG,OAAO,CAAC,aAAa,CAAC;IA8D5E,QAAQ,CACV,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAgB,GACnE,OAAO,CAAC,QAAQ,CAAC;IA6Dd,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS3C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAexC,OAAO,CAAC,SAAS,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAwB1C,QAAQ,IAAI,OAAO,CAAC,SAAS,CAAC;IAc9B,SAAS,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAY3C,cAAc,IAAI,MAAM,GAAG,SAAS;IAKpC;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;;OAGG;YACW,aAAa;IAuC3B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAkDtB;;;OAGG;IACH,OAAO,CAAC,YAAY;CAiBvB"}