@wingman-ai/gateway 0.2.5 → 0.3.1

package/dist/cli/core/imagePersistence.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    persistAssistantImagesToDisk: ()=>persistAssistantImagesToDisk,
+    parseBase64DataUrl: ()=>parseBase64DataUrl,
+    resolveImageExtension: ()=>resolveImageExtension
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const DATA_URL_BASE64_PATTERN = /^data:([^;,]+);base64,(.+)$/i;
+function persistAssistantImagesToDisk(input) {
+    if (!input.messages.length) return;
+    const mediaRoot = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(input.dbPath), "media", sanitizePathSegment(input.sessionId));
+    for (const message of input.messages)if ("assistant" === message.role) {
+        if (Array.isArray(message.attachments) && 0 !== message.attachments.length) for (const attachment of message.attachments){
+            if (!attachment || "image" !== attachment.kind) continue;
+            if (attachment.path) continue;
+            const parsed = parseBase64DataUrl(attachment.dataUrl);
+            if (!parsed) continue;
+            if (!parsed.mimeType.toLowerCase().startsWith("image/")) continue;
+            let bytes;
+            try {
+                bytes = Buffer.from(parsed.data, "base64");
+            } catch  {
+                continue;
+            }
+            if (0 === bytes.length) continue;
+            const extension = resolveImageExtension(parsed.mimeType);
+            const hash = (0, external_node_crypto_namespaceObject.createHash)("sha256").update(bytes).digest("hex").slice(0, 20);
+            const filename = `${hash}.${extension}`;
+            const outputPath = (0, external_node_path_namespaceObject.join)(mediaRoot, filename);
+            if (!(0, external_node_fs_namespaceObject.existsSync)(outputPath)) {
+                (0, external_node_fs_namespaceObject.mkdirSync)(mediaRoot, {
+                    recursive: true
+                });
+                (0, external_node_fs_namespaceObject.writeFileSync)(outputPath, bytes);
+            }
+            attachment.path = outputPath;
+            if (!attachment.mimeType) attachment.mimeType = parsed.mimeType;
+            if ("number" != typeof attachment.size || attachment.size <= 0) attachment.size = bytes.length;
+            if (!attachment.name) attachment.name = `image-${hash.slice(0, 8)}.${extension}`;
+        }
+    }
+}
+function parseBase64DataUrl(dataUrl) {
+    if ("string" != typeof dataUrl) return null;
+    const match = dataUrl.match(DATA_URL_BASE64_PATTERN);
+    if (!match) return null;
+    return {
+        mimeType: match[1].trim().toLowerCase(),
+        data: match[2].trim()
+    };
+}
+function resolveImageExtension(mimeType) {
+    const normalized = (mimeType || "").trim().toLowerCase();
+    switch(normalized){
+        case "image/jpeg":
+            return "jpg";
+        case "image/png":
+            return "png";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        case "image/heic":
+            return "heic";
+        case "image/heif":
+            return "heif";
+        case "image/avif":
+            return "avif";
+        default:
+            {
+                const subtype = normalized.split("/")[1] || "";
+                const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+                return sanitized || "img";
+            }
+    }
+}
+function sanitizePathSegment(value) {
+    const normalized = (value || "").trim();
+    if (!normalized) return "default-session";
+    const sanitized = normalized.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return sanitized.slice(0, 120) || "default-session";
+}
+exports.parseBase64DataUrl = __webpack_exports__.parseBase64DataUrl;
+exports.persistAssistantImagesToDisk = __webpack_exports__.persistAssistantImagesToDisk;
+exports.resolveImageExtension = __webpack_exports__.resolveImageExtension;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseBase64DataUrl",
+    "persistAssistantImagesToDisk",
+    "resolveImageExtension"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/core/imagePersistence.d.ts

@@ -0,0 +1,24 @@
+export interface PersistableAttachment {
+    kind: "image" | "audio" | "file";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+    path?: string;
+}
+export interface PersistableMessage {
+    role: "user" | "assistant";
+    attachments?: PersistableAttachment[];
+}
+type ParsedDataUrl = {
+    mimeType: string;
+    data: string;
+};
+export declare function persistAssistantImagesToDisk(input: {
+    dbPath: string;
+    sessionId: string;
+    messages: PersistableMessage[];
+}): void;
+export declare function parseBase64DataUrl(dataUrl: string): ParsedDataUrl | null;
+export declare function resolveImageExtension(mimeType: string): string;
+export {};

package/dist/cli/core/imagePersistence.js

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const DATA_URL_BASE64_PATTERN = /^data:([^;,]+);base64,(.+)$/i;
+function persistAssistantImagesToDisk(input) {
+    if (!input.messages.length) return;
+    const mediaRoot = join(dirname(input.dbPath), "media", sanitizePathSegment(input.sessionId));
+    for (const message of input.messages)if ("assistant" === message.role) {
+        if (Array.isArray(message.attachments) && 0 !== message.attachments.length) for (const attachment of message.attachments){
+            if (!attachment || "image" !== attachment.kind) continue;
+            if (attachment.path) continue;
+            const parsed = parseBase64DataUrl(attachment.dataUrl);
+            if (!parsed) continue;
+            if (!parsed.mimeType.toLowerCase().startsWith("image/")) continue;
+            let bytes;
+            try {
+                bytes = Buffer.from(parsed.data, "base64");
+            } catch  {
+                continue;
+            }
+            if (0 === bytes.length) continue;
+            const extension = resolveImageExtension(parsed.mimeType);
+            const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 20);
+            const filename = `${hash}.${extension}`;
+            const outputPath = join(mediaRoot, filename);
+            if (!existsSync(outputPath)) {
+                mkdirSync(mediaRoot, {
+                    recursive: true
+                });
+                writeFileSync(outputPath, bytes);
+            }
+            attachment.path = outputPath;
+            if (!attachment.mimeType) attachment.mimeType = parsed.mimeType;
+            if ("number" != typeof attachment.size || attachment.size <= 0) attachment.size = bytes.length;
+            if (!attachment.name) attachment.name = `image-${hash.slice(0, 8)}.${extension}`;
+        }
+    }
+}
+function parseBase64DataUrl(dataUrl) {
+    if ("string" != typeof dataUrl) return null;
+    const match = dataUrl.match(DATA_URL_BASE64_PATTERN);
+    if (!match) return null;
+    return {
+        mimeType: match[1].trim().toLowerCase(),
+        data: match[2].trim()
+    };
+}
+function resolveImageExtension(mimeType) {
+    const normalized = (mimeType || "").trim().toLowerCase();
+    switch(normalized){
+        case "image/jpeg":
+            return "jpg";
+        case "image/png":
+            return "png";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        case "image/heic":
+            return "heic";
+        case "image/heif":
+            return "heif";
+        case "image/avif":
+            return "avif";
+        default:
+            {
+                const subtype = normalized.split("/")[1] || "";
+                const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+                return sanitized || "img";
+            }
+    }
+}
+function sanitizePathSegment(value) {
+    const normalized = (value || "").trim();
+    if (!normalized) return "default-session";
+    const sanitized = normalized.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return sanitized.slice(0, 120) || "default-session";
+}
+export { parseBase64DataUrl, persistAssistantImagesToDisk, resolveImageExtension };