@diegoaltoworks/chatter 0.32.0 → 0.33.0

package/dist/images/index.js

@@ -0,0 +1,412 @@
+"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);
+
+// src/images/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CACHE_TTL_MS: () => CACHE_TTL_MS,
+  DEFAULT_CLOUDINARY_FOLDER: () => DEFAULT_CLOUDINARY_FOLDER,
+  DEFAULT_IMAGE_MODEL: () => DEFAULT_IMAGE_MODEL,
+  DEFAULT_IMAGE_QUALITY: () => DEFAULT_IMAGE_QUALITY,
+  DEFAULT_IMAGE_SIZE: () => DEFAULT_IMAGE_SIZE,
+  ImageGenerationError: () => ImageGenerationError,
+  createCaptionComposer: () => createCaptionComposer,
+  createCloudinaryUploadClient: () => createCloudinaryUploadClient,
+  createImageGenerator: () => createImageGenerator,
+  createImageUploader: () => createImageUploader,
+  createOpenAIImageClient: () => createOpenAIImageClient,
+  createTursoImageCacheStore: () => createTursoImageCacheStore,
+  isCacheEntryFresh: () => isCacheEntryFresh,
+  isCloudinaryConfigured: () => isCloudinaryConfigured,
+  isImageConfigured: () => isImageConfigured,
+  publicIdForRequest: () => publicIdForRequest,
+  resolveCloudinaryConfig: () => resolveCloudinaryConfig,
+  resolveImageConfig: () => resolveImageConfig,
+  signCloudinaryParams: () => signCloudinaryParams
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/images/cache.ts
+var import_node_crypto = require("node:crypto");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function publicIdForRequest(prompt, images) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update(prompt);
+  if (images?.baseImage) hash.update(images.baseImage.bytes);
+  for (const image of images?.inputImages ?? []) {
+    hash.update(image.bytes);
+  }
+  return hash.digest("hex");
+}
+function isCacheEntryFresh(entry, now) {
+  return now - entry.createdAt < CACHE_TTL_MS;
+}
+
+// src/images/cacheStore.ts
+var schemaReady = /* @__PURE__ */ new WeakMap();
+function ensureCacheSchema(client, tableName) {
+  let perTable = schemaReady.get(client);
+  if (!perTable) {
+    perTable = /* @__PURE__ */ new Map();
+    schemaReady.set(client, perTable);
+  }
+  const tables = perTable;
+  let ready = tables.get(tableName);
+  if (!ready) {
+    ready = client.execute(
+      `CREATE TABLE IF NOT EXISTS ${tableName} (
+          public_id TEXT PRIMARY KEY,
+          url TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        )`
+    ).catch((error) => {
+      tables.delete(tableName);
+      throw error;
+    });
+    tables.set(tableName, ready);
+  }
+  return ready;
+}
+var VALID_TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function createTursoImageCacheStore(client, tableName) {
+  if (!VALID_TABLE_NAME.test(tableName)) {
+    throw new Error(`Invalid image cache table name: ${tableName}`);
+  }
+  return {
+    async get(key) {
+      await ensureCacheSchema(client, tableName);
+      const result = await client.execute({
+        sql: `SELECT url, created_at FROM ${tableName} WHERE public_id = ?`,
+        args: [key]
+      });
+      const row = result.rows[0];
+      if (!row) return null;
+      return { url: String(row.url), createdAt: Number(row.created_at) };
+    },
+    async set(key, entry) {
+      await ensureCacheSchema(client, tableName);
+      await client.execute({
+        sql: `INSERT INTO ${tableName} (public_id, url, created_at) VALUES (?, ?, ?)
+              ON CONFLICT(public_id) DO UPDATE SET url = excluded.url, created_at = excluded.created_at`,
+        args: [key, entry.url, entry.createdAt]
+      });
+    }
+  };
+}
+
+// src/images/captionComposer.ts
+var DEFAULT_TIMEOUT_MS = 8e3;
+var MAX_COMPOSED_LENGTH = 300;
+function createCaptionComposer(options) {
+  const { pool } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const random = options.random ?? Math.random;
+  function randomCaption(subject) {
+    if (pool.length === 0) return "";
+    const eligible = pool.filter((template2) => subject || !template2.includes("{subject}"));
+    const candidates = eligible.length > 0 ? eligible : pool;
+    const template = candidates[Math.floor(random() * candidates.length)] ?? candidates[0] ?? "";
+    return template.replaceAll("{subject}", subject ?? "");
+  }
+  return {
+    randomCaption,
+    async composeCaption(request) {
+      if (!options.compose) return randomCaption(request.subject);
+      let timer;
+      try {
+        const text = await Promise.race([
+          options.compose(request),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("caption compose timed out")), timeoutMs);
+          })
+        ]);
+        const trimmed = text.trim();
+        return trimmed.length > 0 && trimmed.length <= MAX_COMPOSED_LENGTH ? trimmed : randomCaption(request.subject);
+      } catch {
+        return randomCaption(request.subject);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+// src/images/cloudinaryConfig.ts
+var DEFAULT_CLOUDINARY_FOLDER = "generated";
+function pick(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0);
+}
+function resolveCloudinaryConfig(env = {}, overrides = {}) {
+  return {
+    cloudName: pick(overrides.cloudName, env.CLOUDINARY_CLOUD_NAME),
+    apiKey: pick(overrides.apiKey, env.CLOUDINARY_API_KEY),
+    apiSecret: pick(overrides.apiSecret, env.CLOUDINARY_API_SECRET),
+    folder: pick(overrides.folder, env.CLOUDINARY_FOLDER, DEFAULT_CLOUDINARY_FOLDER) ?? DEFAULT_CLOUDINARY_FOLDER
+  };
+}
+function isCloudinaryConfigured(config) {
+  return Boolean(config.cloudName && config.apiKey && config.apiSecret);
+}
+
+// src/images/cloudinarySignature.ts
+var import_node_crypto2 = require("node:crypto");
+function signCloudinaryParams(params, apiSecret) {
+  const toSign = Object.keys(params).sort().map((key) => `${key}=${params[key]}`).join("&");
+  return (0, import_node_crypto2.createHash)("sha1").update(`${toSign}${apiSecret}`).digest("hex");
+}
+
+// src/images/types.ts
+var ImageGenerationError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "ImageGenerationError";
+    this.code = code;
+  }
+};
+
+// src/images/cloudinaryClient.ts
+function createCloudinaryUploadClient(config, fetchImpl = fetch) {
+  return {
+    async upload({ imageBytes, publicId, folder }) {
+      if (!isCloudinaryConfigured(config)) {
+        throw new ImageGenerationError("not_configured", "Image upload is not configured");
+      }
+      const timestamp = Math.floor(Date.now() / 1e3).toString();
+      const signature = signCloudinaryParams(
+        { folder, public_id: publicId, timestamp },
+        config.apiSecret
+      );
+      const form = new FormData();
+      form.set(
+        "file",
+        new Blob([Buffer.from(imageBytes)], { type: "image/png" }),
+        `${publicId}.png`
+      );
+      form.set("public_id", publicId);
+      form.set("folder", folder);
+      form.set("timestamp", timestamp);
+      form.set("api_key", config.apiKey);
+      form.set("signature", signature);
+      const response = await fetchImpl(
+        `https://api.cloudinary.com/v1_1/${config.cloudName}/image/upload`,
+        { method: "POST", body: form }
+      );
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new ImageGenerationError(
+          "api_error",
+          `Cloudinary upload failed: ${response.status} ${body}`
+        );
+      }
+      const data = await response.json();
+      if (!data.secure_url) {
+        throw new ImageGenerationError("api_error", "Cloudinary upload returned no secure_url");
+      }
+      return { secureUrl: data.secure_url };
+    }
+  };
+}
+
+// src/images/config.ts
+var DEFAULT_IMAGE_MODEL = "gpt-image-1";
+var DEFAULT_IMAGE_SIZE = "1024x1024";
+var DEFAULT_IMAGE_QUALITY = "medium";
+function pick2(...values) {
+  return values.find((value) => typeof value === "string" && value.length > 0) ?? "";
+}
+function resolveImageConfig(env = {}, overrides = {}) {
+  return {
+    apiKey: overrides.apiKey ?? env.OPENAI_API_KEY,
+    model: pick2(overrides.model, env.IMAGE_MODEL, DEFAULT_IMAGE_MODEL),
+    size: pick2(overrides.size, env.IMAGE_SIZE, DEFAULT_IMAGE_SIZE),
+    quality: pick2(overrides.quality, env.IMAGE_QUALITY, DEFAULT_IMAGE_QUALITY)
+  };
+}
+function isImageConfigured(config) {
+  return typeof config.apiKey === "string" && config.apiKey.length > 0;
+}
+
+// src/images/generator.ts
+var MODERATION_PATTERN = /moderation|safety system|content policy|rejected as a result/i;
+var DEFAULT_MIME_TYPE = "image/png";
+function extensionForMimeType(mimeType) {
+  const subtype = mimeType.split("/")[1];
+  return subtype === "jpeg" ? "jpg" : subtype || "png";
+}
+function toImageError(error) {
+  if (error instanceof ImageGenerationError) return error;
+  const code = error?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === "moderation_blocked" || MODERATION_PATTERN.test(message)) {
+    return new ImageGenerationError("moderation", message, { cause: error });
+  }
+  return new ImageGenerationError("api_error", message, { cause: error });
+}
+function createImageGenerator(config, deps) {
+  return {
+    isConfigured: () => isImageConfigured(config),
+    async generateImage(request) {
+      if (!isImageConfigured(config)) {
+        throw new ImageGenerationError("not_configured", "Image generation is not configured");
+      }
+      if (request.prompt.trim().length === 0) {
+        throw new ImageGenerationError("invalid_request", "Image request has an empty prompt");
+      }
+      let response;
+      try {
+        response = await deps.client.createImage({
+          model: config.model,
+          prompt: request.prompt,
+          size: config.size,
+          quality: config.quality,
+          n: 1,
+          baseImage: request.baseImage ? {
+            bytes: request.baseImage.bytes,
+            mimeType: request.baseImage.mimeType ?? DEFAULT_MIME_TYPE,
+            fileName: `base.${extensionForMimeType(request.baseImage.mimeType ?? DEFAULT_MIME_TYPE)}`
+          } : void 0,
+          inputImages: request.inputImages?.map((image, index) => ({
+            bytes: image.bytes,
+            mimeType: image.mimeType ?? DEFAULT_MIME_TYPE,
+            fileName: `photo-${index + 1}.${extensionForMimeType(image.mimeType ?? DEFAULT_MIME_TYPE)}`
+          }))
+        });
+      } catch (error) {
+        throw toImageError(error);
+      }
+      const b64 = response?.data?.[0]?.b64_json;
+      if (!b64) {
+        throw new ImageGenerationError("api_error", "Image API returned no image data");
+      }
+      return { b64, imageBytes: Uint8Array.from(Buffer.from(b64, "base64")) };
+    }
+  };
+}
+
+// src/images/openaiClient.ts
+var import_openai = __toESM(require("openai"));
+function isGptImageModel(model) {
+  return model.startsWith("gpt-image");
+}
+function createOpenAIImageClient(config, client = new import_openai.default({ apiKey: config.apiKey })) {
+  return {
+    async createImage(params) {
+      const responseFormat = isGptImageModel(params.model) ? {} : { response_format: "b64_json" };
+      if (!params.baseImage && (!params.inputImages || params.inputImages.length === 0)) {
+        const response2 = await client.images.generate({
+          model: params.model,
+          prompt: params.prompt,
+          size: params.size,
+          quality: params.quality,
+          n: params.n,
+          ...responseFormat
+        });
+        return { data: response2.data };
+      }
+      const baseFile = params.baseImage ? await (0, import_openai.toFile)(Buffer.from(params.baseImage.bytes), params.baseImage.fileName, {
+        type: params.baseImage.mimeType
+      }) : void 0;
+      const photoFiles = await Promise.all(
+        (params.inputImages ?? []).map(
+          (photo) => (0, import_openai.toFile)(Buffer.from(photo.bytes), photo.fileName, { type: photo.mimeType })
+        )
+      );
+      const image = baseFile ? [...photoFiles, baseFile] : photoFiles;
+      const response = await client.images.edit({
+        model: params.model,
+        image,
+        prompt: params.prompt,
+        size: params.size,
+        quality: params.quality,
+        n: params.n,
+        ...responseFormat
+      });
+      return { data: response.data };
+    }
+  };
+}
+
+// src/images/uploader.ts
+function createImageUploader(config, deps) {
+  const now = deps.now ?? Date.now;
+  function cacheKey(request) {
+    if (!isCloudinaryConfigured(config)) {
+      throw new ImageGenerationError("not_configured", "Image upload is not configured");
+    }
+    return publicIdForRequest(request.prompt, request);
+  }
+  return {
+    // A cache hit never needs the generator, but a fresh upload does — both
+    // must be configured for this uploader to actually work end to end.
+    isConfigured: () => isCloudinaryConfigured(config) && deps.generator.isConfigured(),
+    async peekCached(request) {
+      const publicId = cacheKey(request);
+      const cached = await deps.cacheStore.get(publicId);
+      return !!cached && isCacheEntryFresh(cached, now());
+    },
+    async getOrCreateImage(request) {
+      const publicId = cacheKey(request);
+      const nowMs = now();
+      const cached = await deps.cacheStore.get(publicId);
+      if (cached && isCacheEntryFresh(cached, nowMs)) {
+        return { url: cached.url, cached: true };
+      }
+      const generated = await deps.generator.generateImage(request);
+      const uploaded = await deps.uploadClient.upload({
+        imageBytes: generated.imageBytes,
+        publicId,
+        folder: config.folder
+      });
+      await deps.cacheStore.set(publicId, { url: uploaded.secureUrl, createdAt: nowMs });
+      return { url: uploaded.secureUrl, cached: false };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_TTL_MS,
+  DEFAULT_CLOUDINARY_FOLDER,
+  DEFAULT_IMAGE_MODEL,
+  DEFAULT_IMAGE_QUALITY,
+  DEFAULT_IMAGE_SIZE,
+  ImageGenerationError,
+  createCaptionComposer,
+  createCloudinaryUploadClient,
+  createImageGenerator,
+  createImageUploader,
+  createOpenAIImageClient,
+  createTursoImageCacheStore,
+  isCacheEntryFresh,
+  isCloudinaryConfigured,
+  isImageConfigured,
+  publicIdForRequest,
+  resolveCloudinaryConfig,
+  resolveImageConfig,
+  signCloudinaryParams
+});