@dexto/core 1.1.9 → 1.1.11

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

@@ -0,0 +1,487 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var local_blob_store_exports = {};
+__export(local_blob_store_exports, {
+  LocalBlobStore: () => LocalBlobStore
+});
+module.exports = __toCommonJS(local_blob_store_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_crypto = require("crypto");
+var import_url = require("url");
+var import_logger = require("../../logger/index.js");
+var import_path2 = require("../../utils/path.js");
+var import_errors = require("../errors.js");
+class LocalBlobStore {
+  config;
+  storePath;
+  connected = false;
+  statsCache = null;
+  statsCachePromise = null;
+  lastStatsRefresh = 0;
+  static STATS_REFRESH_INTERVAL_MS = 6e4;
+  // 1 minute
+  constructor(config) {
+    this.config = config;
+    this.storePath = config.storePath || (0, import_path2.getDextoPath)("data", "blobs");
+  }
+  async connect() {
+    if (this.connected) return;
+    try {
+      await import_fs.promises.mkdir(this.storePath, { recursive: true });
+      await this.refreshStatsCache();
+      this.lastStatsRefresh = Date.now();
+      this.connected = true;
+      import_logger.logger.debug(`LocalBlobStore connected at: ${this.storePath}`);
+    } catch (error) {
+      throw import_errors.StorageError.blobOperationFailed("connect", "local", error);
+    }
+  }
+  async disconnect() {
+    this.connected = false;
+    import_logger.logger.debug("LocalBlobStore disconnected");
+  }
+  /**
+   * Normalize metadata after JSON parsing to ensure createdAt is a Date object
+   */
+  normalizeMetadata(parsed) {
+    return {
+      ...parsed,
+      createdAt: parsed.createdAt instanceof Date ? parsed.createdAt : new Date(parsed.createdAt)
+    };
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "local";
+  }
+  async store(input, metadata = {}) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    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 blobPath = import_path.default.join(this.storePath, `${id}.dat`);
+    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
+    try {
+      const existingMeta = await import_fs.promises.readFile(metaPath, "utf-8");
+      const parsed = JSON.parse(existingMeta);
+      const existingMetadata = this.normalizeMetadata(parsed);
+      import_logger.logger.debug(`Blob ${id} already exists, returning existing reference (deduplication)`);
+      return {
+        id,
+        uri: `blob:${id}`,
+        metadata: existingMetadata
+      };
+    } catch {
+    }
+    const maxTotalSize = this.config.maxTotalSize;
+    if (maxTotalSize) {
+      const stats = await this.ensureStatsCache();
+      if (stats.totalSize + buffer.length > maxTotalSize) {
+        throw import_errors.StorageError.blobTotalSizeExceeded(
+          stats.totalSize + buffer.length,
+          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
+    };
+    try {
+      await Promise.all([
+        import_fs.promises.writeFile(blobPath, buffer),
+        import_fs.promises.writeFile(metaPath, JSON.stringify(storedMetadata, null, 2))
+      ]);
+      import_logger.logger.debug(`Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`);
+      this.updateStatsCacheAfterStore(buffer.length);
+      return {
+        id,
+        uri: `blob:${id}`,
+        metadata: storedMetadata
+      };
+    } catch (error) {
+      await Promise.allSettled([
+        import_fs.promises.unlink(blobPath).catch(() => {
+        }),
+        import_fs.promises.unlink(metaPath).catch(() => {
+        })
+      ]);
+      throw import_errors.StorageError.blobOperationFailed("store", "local", error);
+    }
+  }
+  async retrieve(reference, format = "buffer") {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    const id = this.parseReference(reference);
+    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
+    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
+    try {
+      const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
+      const parsed = JSON.parse(metaContent);
+      const metadata = this.normalizeMetadata(parsed);
+      switch (format) {
+        case "base64": {
+          const buffer = await import_fs.promises.readFile(blobPath);
+          return { format: "base64", data: buffer.toString("base64"), metadata };
+        }
+        case "buffer": {
+          const buffer = await import_fs.promises.readFile(blobPath);
+          return { format: "buffer", data: buffer, metadata };
+        }
+        case "path": {
+          await import_fs.promises.access(blobPath);
+          return { format: "path", data: blobPath, metadata };
+        }
+        case "stream": {
+          const stream = (0, import_fs.createReadStream)(blobPath);
+          return { format: "stream", data: stream, metadata };
+        }
+        case "url": {
+          const absolutePath = import_path.default.resolve(blobPath);
+          return {
+            format: "url",
+            data: (0, import_url.pathToFileURL)(absolutePath).toString(),
+            metadata
+          };
+        }
+        default:
+          throw import_errors.StorageError.blobInvalidInput(format, `Unsupported format: ${format}`);
+      }
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw import_errors.StorageError.blobNotFound(reference);
+      }
+      throw import_errors.StorageError.blobOperationFailed("retrieve", "local", error);
+    }
+  }
+  async exists(reference) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    const id = this.parseReference(reference);
+    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
+    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
+    try {
+      await Promise.all([import_fs.promises.access(blobPath), import_fs.promises.access(metaPath)]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(reference) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    const id = this.parseReference(reference);
+    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
+    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
+    try {
+      const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
+      const parsed = JSON.parse(metaContent);
+      const metadata = this.normalizeMetadata(parsed);
+      await Promise.all([import_fs.promises.unlink(blobPath), import_fs.promises.unlink(metaPath)]);
+      import_logger.logger.debug(`Deleted blob: ${id}`);
+      this.updateStatsCacheAfterDelete(metadata.size);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw import_errors.StorageError.blobNotFound(reference);
+      }
+      throw import_errors.StorageError.blobOperationFailed("delete", "local", error);
+    }
+  }
+  async cleanup(olderThan) {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    const cleanupDays = this.config.cleanupAfterDays;
+    const cutoffDate = olderThan || new Date(Date.now() - cleanupDays * 24 * 60 * 60 * 1e3);
+    let deletedCount = 0;
+    try {
+      const files = await import_fs.promises.readdir(this.storePath);
+      const metaFiles = files.filter((f) => f.endsWith(".meta.json"));
+      for (const metaFile of metaFiles) {
+        const metaPath = import_path.default.join(this.storePath, metaFile);
+        const id = metaFile.replace(".meta.json", "");
+        const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
+        try {
+          const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
+          const parsed = JSON.parse(metaContent);
+          const metadata = this.normalizeMetadata(parsed);
+          if (metadata.createdAt < cutoffDate) {
+            await Promise.all([
+              import_fs.promises.unlink(blobPath).catch(() => {
+              }),
+              import_fs.promises.unlink(metaPath).catch(() => {
+              })
+            ]);
+            deletedCount++;
+            this.updateStatsCacheAfterDelete(metadata.size);
+            import_logger.logger.debug(`Cleaned up old blob: ${id}`);
+          }
+        } catch (error) {
+          import_logger.logger.warn(`Failed to process blob metadata ${metaFile}: ${String(error)}`);
+        }
+      }
+      if (deletedCount > 0) {
+        import_logger.logger.info(`Blob cleanup: removed ${deletedCount} old blobs`);
+      }
+      return deletedCount;
+    } catch (error) {
+      throw import_errors.StorageError.blobCleanupFailed("local", error);
+    }
+  }
+  async getStats() {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    const stats = await this.ensureStatsCache();
+    return {
+      count: stats.count,
+      totalSize: stats.totalSize,
+      backendType: "local",
+      storePath: this.storePath
+    };
+  }
+  getStoragePath() {
+    return this.storePath;
+  }
+  async listBlobs() {
+    if (!this.connected) {
+      throw import_errors.StorageError.blobBackendNotConnected("local");
+    }
+    try {
+      const files = await import_fs.promises.readdir(this.storePath);
+      const metaFiles = files.filter((f) => f.endsWith(".meta.json"));
+      const blobs = [];
+      for (const metaFile of metaFiles) {
+        try {
+          const metaPath = import_path.default.join(this.storePath, metaFile);
+          const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
+          const parsed = JSON.parse(metaContent);
+          const metadata = this.normalizeMetadata(parsed);
+          const blobId = metaFile.replace(".meta.json", "");
+          blobs.push({
+            id: blobId,
+            uri: `blob:${blobId}`,
+            metadata
+          });
+        } catch (error) {
+          import_logger.logger.warn(`Failed to process blob metadata ${metaFile}: ${String(error)}`);
+        }
+      }
+      return blobs;
+    } catch (error) {
+      import_logger.logger.warn(`Failed to list blobs: ${String(error)}`);
+      return [];
+    }
+  }
+  async ensureStatsCache() {
+    const now = Date.now();
+    const cacheAge = now - this.lastStatsRefresh;
+    const isStale = cacheAge > LocalBlobStore.STATS_REFRESH_INTERVAL_MS;
+    if (!this.statsCache || isStale) {
+      if (!this.statsCachePromise) {
+        this.statsCachePromise = this.refreshStatsCache();
+      }
+      try {
+        await this.statsCachePromise;
+        this.lastStatsRefresh = now;
+      } finally {
+        this.statsCachePromise = null;
+      }
+    }
+    return this.statsCache ?? { count: 0, totalSize: 0 };
+  }
+  async refreshStatsCache() {
+    const stats = { count: 0, totalSize: 0 };
+    try {
+      const files = await import_fs.promises.readdir(this.storePath);
+      const datFiles = files.filter((f) => f.endsWith(".dat"));
+      stats.count = datFiles.length;
+      for (const datFile of datFiles) {
+        try {
+          const stat = await import_fs.promises.stat(import_path.default.join(this.storePath, datFile));
+          stats.totalSize += stat.size;
+        } catch (error) {
+          import_logger.logger.debug(
+            `Skipping size calculation for ${datFile}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    } catch (error) {
+      import_logger.logger.warn(`Failed to refresh blob stats cache: ${String(error)}`);
+    }
+    this.statsCache = stats;
+  }
+  updateStatsCacheAfterStore(size) {
+    if (!this.statsCache) {
+      this.statsCache = { count: 1, totalSize: size };
+      return;
+    }
+    this.statsCache.count += 1;
+    this.statsCache.totalSize += size;
+  }
+  updateStatsCacheAfterDelete(size) {
+    if (!this.statsCache) {
+      this.statsCache = { count: 0, totalSize: 0 };
+      return;
+    }
+    this.statsCache.count = Math.max(0, this.statsCache.count - 1);
+    this.statsCache.totalSize = Math.max(0, this.statsCache.totalSize - size);
+  }
+  /**
+   * Convert various input types to Buffer
+   */
+  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"
+        );
+      }
+      if ((input.includes("/") || input.includes("\\")) && input.length > 1) {
+        try {
+          await import_fs.promises.access(input);
+          return await import_fs.promises.readFile(input);
+        } catch {
+        }
+      }
+      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
+   */
+  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
+   */
+  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 = import_path.default.extname(filename).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",
+        ".mp3": "audio/mpeg",
+        ".mp4": "video/mp4",
+        ".wav": "audio/wav"
+      };
+      if (mimeTypes[ext]) return mimeTypes[ext];
+    }
+    if (this.isTextBuffer(buffer)) {
+      return "text/plain";
+    }
+    return "application/octet-stream";
+  }
+  /**
+   * Check if buffer contains text content
+   */
+  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 = {
+  LocalBlobStore
+});

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

@@ -0,0 +1,56 @@
+import type { BlobStore, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats } from './types.js';
+import type { LocalBlobStoreConfig } from './schemas.js';
+/**
+ * Local filesystem blob store implementation.
+ *
+ * Stores blobs on the local filesystem with content-based deduplication
+ * and metadata tracking. This is the default store for development
+ * and single-machine deployments.
+ */
+export declare class LocalBlobStore implements BlobStore {
+    private config;
+    private storePath;
+    private connected;
+    private statsCache;
+    private statsCachePromise;
+    private lastStatsRefresh;
+    private static readonly STATS_REFRESH_INTERVAL_MS;
+    constructor(config: LocalBlobStoreConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Normalize metadata after JSON parsing to ensure createdAt is a Date object
+     */
+    private normalizeMetadata;
+    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>;
+    getStoragePath(): string | undefined;
+    listBlobs(): Promise<BlobReference[]>;
+    private ensureStatsCache;
+    private refreshStatsCache;
+    private updateStatsCacheAfterStore;
+    private updateStatsCacheAfterDelete;
+    /**
+     * Convert various input types to Buffer
+     */
+    private inputToBuffer;
+    /**
+     * Parse blob reference to extract ID
+     */
+    private parseReference;
+    /**
+     * Detect MIME type from buffer content and/or filename
+     */
+    private detectMimeType;
+    /**
+     * Check if buffer contains text content
+     */
+    private isTextBuffer;
+}
+//# sourceMappingURL=local-blob-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-blob-store.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/local-blob-store.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,SAAS,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC5C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAqD;IACvE,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,gBAAgB,CAAa;IAErC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAS;gBAE9C,MAAM,EAAE,oBAAoB;IAKlC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAcxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAIhB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,GAAE,YAAiB,GAAG,OAAO,CAAC,aAAa,CAAC;IAqF5E,QAAQ,CACV,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAgB,GACnE,OAAO,CAAC,QAAQ,CAAC;IAsDd,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB3C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBxC,OAAO,CAAC,SAAS,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IA+C1C,QAAQ,IAAI,OAAO,CAAC,SAAS,CAAC;IAepC,cAAc,IAAI,MAAM,GAAG,SAAS;IAI9B,SAAS,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YAmC7B,gBAAgB;YAsBhB,iBAAiB;IAwB/B,OAAO,CAAC,0BAA0B;IASlC,OAAO,CAAC,2BAA2B;IASnC;;OAEG;YACW,aAAa;IAgD3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAiDtB;;OAEG;IACH,OAAO,CAAC,YAAY;CAiBvB"}