@xuda.io/ai_module 1.1.4524 → 1.1.4526

package/index.mjs

@@ -6998,3 +6998,97 @@ const get_chat_picture_cache = async function (uid, docType, name) {
 
   return null;
 };
+
+const save_drive_file_to_disk = async function (drive_file) {
+  async function hasTransparentBackground(filePath) {
+    const image = sharp(filePath);
+    const metadata = await image.metadata();
+
+    // If the image doesn't have an alpha channel at all → no transparency possible
+    if (!metadata.hasAlpha) {
+      return false;
+    }
+
+    // For images with alpha channel, check if any pixel actually has alpha < 255
+    const { data, info } = await image.raw().toBuffer({ resolveWithObject: true });
+
+    // Determine position of alpha channel based on number of channels
+    const channels = info.channels; // 2 (grayscale+alpha), 4 (RGBA), etc.
+    const alphaOffset = channels === 2 ? 1 : channels === 4 ? 3 : -1;
+
+    if (alphaOffset === -1) {
+      // Unusual channel count – be conservative and assume it might have transparency
+      return true;
+    }
+
+    for (let i = alphaOffset; i < data.length; i += channels) {
+      if (data[i] < 255) {
+        return true; // Found at least one transparent/semi-transparent pixel
+      }
+    }
+
+    return false; // Has alpha channel but all pixels are fully opaque
+  }
+
+  async function imageToPngBlob(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    let buffer;
+
+    let is_transparent = false;
+    if (ext === '.png') {
+      buffer = await fs.promises.readFile(filePath);
+      is_transparent = await hasTransparentBackground(filePath);
+    } else {
+      console.log(`Converting ${path.basename(filePath)} to PNG...`);
+      buffer = await sharp(filePath).png({ quality: 100, compressionLevel: 9, force: true }).toBuffer();
+    }
+
+    // Create a Blob with correct MIME type
+
+    return { is_transparent, image_blob: new Blob([buffer], { type: 'image/png' }) };
+  }
+  // try {
+  if (!drive_file.file_url) {
+    throw new Error('No URL provided in request');
+  }
+
+  // 3. Download the image to a Buffer
+  const res = await fetch(drive_file.file_url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch image URL: ${res.status} ${res.statusText}`);
+  }
+
+  const arrayBuffer = await res.arrayBuffer();
+  const imageBuffer = Buffer.from(arrayBuffer);
+
+  const tempDir = os.tmpdir();
+  const uniqueId = Date.now() + '_' + Math.random().toString(36).substring(7);
+
+  const inputExt = path.extname(url) || '.jpg';
+  const tempInputPath = path.join(tempDir, `input_${uniqueId}${inputExt}`);
+  // const tempOutputPath = path.join(tempDir, `output_${uniqueId}.png`); // Output is always PNG (transparent)
+
+  // 5. Write the downloaded image to disk
+  fs.writeFileSync(tempInputPath, imageBuffer);
+  /////////////////////////////////
+
+  const imageFiles = [tempInputPath];
+
+  const images = await Promise.all(
+    imageFiles.map(async (filePath) => {
+      const img_ret = await imageToPngBlob(filePath);
+      const blob = img_ret.image_blob;
+
+      // OpenAI expects a filename for logging/debugging
+      const filename = path.basename(filePath, path.extname(filePath)) + '.png';
+      blob.name = filename; // Optional but helpful
+      // @ts-ignore – name is allowed in Node 20+
+      blob.lastModified = Date.now();
+
+      return { is_transparent: img_ret.is_transparent, image_blob: blob };
+    }),
+  );
+
+  return images[0];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.4524",
+  "version": "1.1.4526",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",