apexify.js 3.3.6 → 3.3.7

package/SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| >v1.x.x | :white_check_mark: |
+| >v2.x.x | :white_check_mark: |
+| >v3.3.x | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

package/change logs.md

@@ -5,7 +5,7 @@
 ### General Chnages
 
 - Documetation moved to [Apexify.js](http://apexify.jedi-studio.com)
-
+- Fixed minor bugs
 ### ApexAI Changes
 
 - Added custom nsfw key words filter.

package/examples/barchart.txt

@@ -14,7 +14,6 @@ const data = {
     },
     bg: {
        image: 'https://png.pngtree.com/thumb_back/fh260/background/20211118/pngtree-financial-technology-data-graph-image_908921.jpg',
-       baseDir: __dirname,
        bgColor: 'darkgray'
       }, 
     grid: {
@@ -58,7 +57,6 @@ const data = {
             'blue': 'Label 3',
             'yellow': 'Lable 4'
         },
-        keyColor: '',
         xTitle: 'X Axis Title',
         yTitle: 'Y Axis Title',
         labelStyle: {

package/examples/linechart.txt

@@ -79,13 +79,11 @@ const data = {
            lineWidth: 3, 
         },
         canvas: {
-            bgColor: 'black',
             fontColor: 'white',
             fontSize: 16,
             width: 800,
             height: 600,
             image: 'image url or path if u dont want a bg color',
-            baseDir: __dirname // need to be added if u using a local path image
         }
     }
 };

package/lib/ai/ApexAI.ts

@@ -10,12 +10,11 @@ import {
   typeWriter,
   readImage,
 } from "./utils";
-import axios from "axios";
 import { 
   ModalBuilder,
   TextInputBuilder,
   TextInputStyle,
-  ActionRowBuilder 
+  ActionRowBuilder
 } from "discord.js";
 import { filters } from "./buttons/tools";
 import { imageTools } from "./buttons/drawMenu";
@@ -406,7 +405,6 @@ export async function ApexAI (message: any, aiOptions: Options) {
                 await typeWriter(message.channel, part, speed, delay);
               }
           }
-
       } else {
           if (response.length <= 2000) {
               await message.reply({
@@ -479,106 +477,139 @@ export async function ApexAI (message: any, aiOptions: Options) {
 }
 
 export async function gemmaAi_4(prompt: string) {
-    try {
-        const response = await axios.post('https://api-inference.huggingface.co/models/google/gemma-7b-it', { inputs: prompt }, {
-            headers: { 'Authorization': `Bearer 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` }
-        });
-        return response.data[0].generated_text;
-    } catch (error: any) {
-        console.error('Error fetching response:', error.message);
-        return null;
+  try {
+    const response = await fetch('https://api-inference.huggingface.co/models/google/gemma-7b-it', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer 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'
+        },
+        body: JSON.stringify({ inputs: prompt })
+    });
+
+    if (!response.ok) {
+        throw new Error('Network response was not ok');
     }
+
+    const responseData = await response.json();
+    return responseData[0].generated_text;
+  } catch (error: any) {
+    console.error('Error fetching response:', error.message);
+    return null;
+  }
 }
 
 export async function gemmaAi_3(prompt: string) {
-    try {
-        const response = await axios.post('https://api-inference.huggingface.co/models/google/gemma-2b-it', { inputs: prompt }, {
-            headers: { 'Authorization': `Bearer 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` }
-        });
-        return response.data[0].generated_text;
-    } catch (error: any) {
-        console.error('Error fetching response:', error.message);
-        return null;
-    }
-}
+  try {
+      const response = await fetch('https://api-inference.huggingface.co/models/google/gemma-2b-it', {
+          method: 'POST',
+          headers: {
+              'Content-Type': 'application/json',
+              'Authorization': 'Bearer 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'
+          },
+          body: JSON.stringify({ inputs: prompt })
+      });
+
+      if (!response.ok) {
+          throw new Error('Network response was not ok');
+      }
 
+      const responseData = await response.json();
+      return responseData[0].generated_text;
+  } catch (error: any) {
+      console.error('Error fetching response:', error.message);
+      return null;
+  }
+}
 export async function apexai(prompt: string) {
-    try {
+  try {
       const messages = [
-        {"role": "user", "content": `${prompt}`}
+          {"role": "user", "content": `${prompt}`}
       ];
-        const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
-
-        const response = await axios.post(`https://api-inference.huggingface.co/models/mistralai/Mixtral-8x7B-Instruct-v0.1`, {
-            inputs: formattedMessages
-        }, {
-            headers: {
-                'Authorization': `Bearer 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`,
-                'Content-Type': 'application/json'
-            }
-        });
-
-        const generatedText = response.data[0].generated_text;
+      const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
+
+      const response = await fetch('https://api-inference.huggingface.co/models/mistralai/Mixtral-8x7B-Instruct-v0.1', {
+          method: 'POST',
+          headers: {
+              'Authorization': 'Bearer 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',
+              'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({ inputs: formattedMessages })
+      });
 
-        const lines = generatedText.split('\n').slice(1);
+      if (!response.ok) {
+          throw new Error('Network response was not ok');
+      }
 
-        const output = lines.join('\n');
+      const responseData = await response.json();
+      const generatedText = responseData[0].generated_text;
+      const lines = generatedText.split('\n').slice(1);
+      const output = lines.join('\n');
 
-     return output
-    } catch (error: any) {
-      console.error('Error:', error.response.data);
-      return 'Please wait i am on cooldown.'
-    }
+      return output;
+  } catch (error: any) {
+      console.error('Error:', error.message);
+      return 'Please wait i am on cooldown.';
+  }
 }
 
 export async function starChat(prompt: string) {
-  const messages = [{"role":"user","content": `${prompt}`}]
-  
-    try {
-        const response = await axios.post('https://api-inference.huggingface.co/models/HuggingFaceH4/starchat2-15b-v0.1', {
-            inputs: JSON.stringify(messages), 
-        }, {
-            headers: {
-                'Authorization': `Bearer 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`,
-            },
-        });
+  const messages = [{"role":"user","content": `${prompt}`}];
+
+  try {
+      const response = await fetch('https://api-inference.huggingface.co/models/HuggingFaceH4/starchat2-15b-v0.1', {
+          method: 'POST',
+          headers: {
+              'Authorization': 'Bearer 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',
+              'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({ inputs: messages })
+      });
 
-        const chatbotReply = response.data[0];
-        const chatbotResponseText = chatbotReply.generated_text.replace(/^.*?\n.*?\n/, '');
-        const chatbotResponseArray = JSON.parse(chatbotResponseText);
-        const chatbotResponseString = chatbotResponseArray.join(' ');
+      if (!response.ok) {
+          throw new Error('Network response was not ok');
+      }
 
-        return chatbotResponseString;
-    } catch (error: any) {
-        console.error('Error fetching response:', error.message);
-        return null;
-    }
+      const responseData = await response.json();
+      const chatbotReply = responseData[0];
+      const chatbotResponseText = chatbotReply.generated_text.replace(/^.*?\n.*?\n/, '');
+      const chatbotResponseArray = JSON.parse(chatbotResponseText);
+      const chatbotResponseString = chatbotResponseArray.join(' ');
+
+      return chatbotResponseString;
+  } catch (error: any) {
+      console.error('Error:', error.message);
+      return null;
+  }
 }
 
 export async function zephyr_beta(prompt: string) {
+  const messages = [{"role":"user","content": `${prompt}` }];
+
+  try {
+      const response = await fetch('https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta', {
+          method: 'POST',
+          headers: {
+              'Authorization': 'Bearer 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',
+              'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({ inputs: messages })
+      });
 
-  const messages = [{"role":"user","content": `${prompt}` }]
-    try {
-        const response = await axios.post('https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta', {
-            inputs: JSON.stringify(messages), 
-        }, {
-            headers: {
-                'Authorization': `Bearer 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`,
-            },
-        });
-
-        const chatbotReply = response.data[0];
-
-        const textParts = chatbotReply.generated_text.split('\n');
-
-        const secondArrayString = textParts[2];
-        const chatbotResponseArray = JSON.parse(secondArrayString);
-
-        const chatbotResponseString = chatbotResponseArray.map((obj: any) => obj.content).join(' ');
+      if (!response.ok) {
+          throw new Error('Network response was not ok');
+      }
 
-        return chatbotResponseString;
-    } catch (error: any) {
-        console.error('Error fetching response:', error.message);
-        return null;
-    }
-}
+      const responseData = await response.json();
+      const chatbotReply = responseData[0];
+      const textParts = chatbotReply.generated_text.split('\n');
+      const secondArrayString = textParts[2];
+      const chatbotResponseArray = JSON.parse(secondArrayString);
+      const chatbotResponseString = chatbotResponseArray.map((obj: any) => obj.content).join(' ');
+
+      return chatbotResponseString;
+  } catch (error: any) {
+      console.error('Error:', error.message);
+      return null;
+  }
+}

package/lib/ai/functions/draw.ts

@@ -88,8 +88,8 @@ async function aiImagine(
   nsfw: boolean,
   nsfwKeyWords: string[],
 ) {
-  const maxRetryAttempts = 4;
-  const retryInterval = 5000;
+  const maxRetryAttempts = 3;
+  const retryInterval = 10000;
   let response: any;
   async function retry(fn: any, retriesLeft = maxRetryAttempts) {
     try {
@@ -98,7 +98,6 @@ async function aiImagine(
       if (retriesLeft === 0) {
         throw error;
       }
-
       await new Promise((resolve) => setTimeout(resolve, retryInterval));
       return retry(fn, retriesLeft - 1);
     }
@@ -421,9 +420,7 @@ async function attemptImageCaptioning(imageUrl: string) {
       try {
         return await fetchData();
       } catch (error: any) {
-        console.error(
-          `Error fetching data (Retry ${retryCount + 1}): ${error.message}`,
-        );
+
         retryCount++;
       }
     }

package/lib/canvas/ApexPainter.ts

@@ -1,5 +1,4 @@
 import { createCanvas, loadImage, GlobalFonts } from "@napi-rs/canvas";
-import axios, { responseEncoding } from "axios";
 import path from 'path';
 import GIFEncoder from 'gifencoder';
 import { PassThrough, Writable} from 'stream'
@@ -11,55 +10,57 @@ import { CanvasConfig, TextObject, ImageProperties, ImageObject, GIFOptions, GIF
 import {  } from "./utils/general functions";
 
 export class ApexPainter {
-    async createCanvas(canvas: CanvasConfig): Promise<Buffer> {
-        let canvasWidth: number = canvas.width || 500;
-        let canvasHeight: number = canvas.height || 500;
-        let borderRadius: number | string = canvas.borderRadius || 0;
 
-        if (canvas.customBg) {
-            try {
-                const response = await axios.get(canvas.customBg, { responseType: 'arraybuffer' });
-                const imageBuffer = Buffer.from(response.data, 'binary');
-                const image = await loadImage(imageBuffer);
-
-                canvasWidth = image.width;
-                canvasHeight = image.height;
-            } catch (error) {
-                console.error('Error loading custom background image:', error);
+  async createCanvas(canvas: CanvasConfig): Promise<Buffer> {
+    let canvasWidth: number = canvas.width || 500;
+    let canvasHeight: number = canvas.height || 500;
+    let borderRadius: number | string = canvas.borderRadius || 0;
+
+    if (canvas.customBg) {
+        try {
+            const response = await fetch(canvas.customBg);
+            if (!response.ok) {
+                throw new Error("Failed to fetch background image.");
             }
+            const buffer = await response.arrayBuffer();
+            const image = await loadImage(Buffer.from(buffer));
+            canvasWidth = image.width;
+            canvasHeight = image.height;
+        } catch (error) {
+            console.error('Error loading custom background image:', error);
         }
+    }
 
-  
-   
-        const canvasInstance = createCanvas(canvasWidth, canvasHeight);
-        const ctx: any = canvasInstance.getContext('2d');
+    const canvasInstance = createCanvas(canvasWidth, canvasHeight);
+    const ctx: any = canvasInstance.getContext('2d');
 
-        if (!ctx) {
-            throw new Error('Unable to get 2D rendering context from canvas');
-        }
-
-        applyRotation(ctx, canvas.rotation || 0, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+    if (!ctx) {
+        throw new Error('Unable to get 2D rendering context from canvas');
+    }
 
-        applyShadow(ctx, canvas.shadow, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+    applyRotation(ctx, canvas.rotation || 0, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
 
-        if (typeof borderRadius === 'string') {
-            circularBorder(ctx, canvasWidth, canvasHeight);
-        } else if (typeof borderRadius === 'number') {
-            radiusBorder(ctx, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight, borderRadius);
-        }
+    applyShadow(ctx, canvas.shadow, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
 
-        if (canvas.customBg) {
-            await customBackground(ctx, canvas);
-        } else if (canvas.gradientBg) {
-            await drawBackgroundGradient(ctx, canvas);
-        } else {
-            await drawBackgroundColor(ctx, canvas);
-        }
-        applyStroke(ctx, canvas.stroke, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+    if (typeof borderRadius === 'string') {
+        circularBorder(ctx, canvasWidth, canvasHeight);
+    } else if (typeof borderRadius === 'number') {
+        radiusBorder(ctx, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight, borderRadius);
+    }
 
-        return canvasInstance.toBuffer('image/png');
+    if (canvas.customBg) {
+        await customBackground(ctx, canvas);
+    } else if (canvas.gradientBg) {
+        await drawBackgroundGradient(ctx, canvas);
+    } else {
+        await drawBackgroundColor(ctx, canvas);
     }
 
+    applyStroke(ctx, canvas.stroke, canvas.x || 0, canvas.y || 0, canvasWidth, canvasHeight);
+
+    return canvasInstance.toBuffer('image/png');
+  }
+
     async createImage(images: ImageProperties[], canvasBuffer: Buffer): Promise<Buffer> {
 
         if (!canvasBuffer) {
@@ -517,51 +518,45 @@ export class ApexPainter {
     }
 
     try {
-
-    let img: any;
-    const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
-
-    const isShape = shapeNames.includes(source.toLowerCase());
-
-    if (source.startsWith('http')) {
-        const response = await axios.get(source, { responseType: 'arraybuffer' });
-        const imageBuffer = Buffer.from(response.data, 'binary');
-        img = await loadImage(imageBuffer);
-    } else if (isShape) {
-        drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient });
-    } else {
-        const imagePath = path.join(process.cwd(), source);
-        try {
-            img = await loadImage(imagePath);
-        } catch (e: any) {
-            throw new Error(`Error loading image: ${e.message}`);
+        let img: any;
+        const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
+        const isShape = shapeNames.includes(source.toLowerCase());
+
+        if (source.startsWith('http')) {
+            const response = await fetch(source);
+            if (!response.ok) {
+                throw new Error("Failed to fetch image.");
+            }
+            const buffer = await response.arrayBuffer();
+            img = await loadImage(Buffer.from(buffer));
+        } else if (isShape) {
+            drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient });
+        } else {
+            const imagePath = path.join(process.cwd(), source);
+            try {
+                img = await loadImage(imagePath);
+            } catch (e: any) {
+                throw new Error(`Error loading image: ${e.message}`);
+            }
         }
-    }
-
-    if (img !== undefined) {
-
-      ctx.save();
-
-      applyRotation(ctx, rotation || 0, x, y, width, height);
-
-      applyShadow(ctx, shadow, x, y, width, height);
 
-      imageRadius(ctx, img, x, y, width, height, borderRadius || 0);
- 
-      applyStroke(ctx, stroke, x, y, width, height);
-
-      ctx.restore();
-    } else {
-         if (!isShape) {
-           throw new Error('Invalid image source or shape name');
+        if (img !== undefined) {
+            ctx.save();
+            applyRotation(ctx, rotation || 0, x, y, width, height);
+            applyShadow(ctx, shadow, x, y, width, height);
+            imageRadius(ctx, img, x, y, width, height, borderRadius || 0);
+            applyStroke(ctx, stroke, x, y, width, height);
+            ctx.restore();
+        } else {
+            if (!isShape) {
+                throw new Error('Invalid image source or shape name');
+            }
         }
-      }
-
-    } catch (e: any) {
-      throw new Error(e.message)
-    } 
+    } catch (error: any) {
+        throw new Error(error.message);
+    }
+  
   }
-
   public validHex(hexColor: string): any {
     const hexPattern = /^#[0-9a-fA-F]{6}$/;
     if (!hexPattern.test(hexColor)) {

package/lib/canvas/utils/bg.ts

@@ -1,6 +1,5 @@
 import { loadImage } from "@napi-rs/canvas";
 import { CanvasConfig } from './types';
-import axios from 'axios';
 import fs from 'fs';
 import path from 'path';
 
@@ -58,8 +57,12 @@ export async function customBackground(ctx: any, canvas: CanvasConfig): Promise<
             let imagePath: string;
 
             if (canvas.customBg.startsWith('http')) {
-                const response = await axios.get(canvas.customBg, { responseType: 'arraybuffer' });
-                imageBuffer = Buffer.from(response.data, 'binary');
+                const response = await fetch(canvas.customBg);
+                if (!response.ok) {
+                    throw new Error("Failed to fetch custom background image.");
+                }
+                const buffer = await response.arrayBuffer();
+                imageBuffer = Buffer.from(buffer);
             } else {
                 imagePath = path.join(process.cwd(), canvas.customBg);
                 imageBuffer = fs.readFileSync(imagePath);
@@ -72,7 +75,7 @@ export async function customBackground(ctx: any, canvas: CanvasConfig): Promise<
 
             ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
 
-        } catch (error) {
+        } catch (error: any) {
             console.error('Error loading custom background image:', error);
         }
     }