@cifumo/scraper-node/esm/ai.js

Sebuah Module Scraper yang dibuat oleh Sxyz dan SuzakuTeam untuk memudahkan penggunaan scraper di project ESM maupun CJS.

import axios from "axios";
import WebSocket from "ws";
import * as cheerio from "cheerio";
import FormData from "form-data";
import fakeUserAgent from "fake-useragent";
const { fromBuffer } = await import("file-type");
import MathRandoms from "./lib/math.random.js";
import { randomUUID } from "crypto";
import https from "https";

const ai = {
  img2prompt: async (imageBuffer, filename = 'image.png') => {
    try {
        const form = new FormData();
        form.append('image', imageBuffer, filename);

        const response = await axios.post('https://api.findit.moe/tagger/file', form, {
            headers: {
                ...form.getHeaders(),
                'accept': '*/*',
                'Referer': 'https://findit.moe/',
                'Referrer-Policy': 'strict-origin-when-cross-origin',
                'x-token-history': 'KJsCHOr3Cc4wq6WRGLT-wwAReDU0RM4n'
            }
        });

        const data = response.data.results.data;

        const bestCharacter = data.character?.length
            ? data.character.sort((a, b) => b.score - a.score)[0].tag
            : '';

        let topGenerals = [];
        if (data.general?.length) {
            topGenerals = data.general
                .sort((a, b) => b.score - a.score)
                .filter(tag => tag.score >= 0.5)
                .slice(0, 100)
                .map(tag => tag.tag);
        }

        if (topGenerals.length === 0 && data.general?.length) {
            topGenerals.push(data.general[0].tag);
        }

        const result = [bestCharacter, ...topGenerals].filter(Boolean).join(', ');

        return result;

    } catch (error) {
        console.error('Error uploading image:', error.message);
        throw error;
    }
  },
  ss2code: async (urlImage, timeoutMs = 30000) => {
    function generateUUIDv4() {
      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
        const r = (Math.random() * 16) | 0;
        const v = c === "x" ? r : (r & 0x3) | 0x8;
        return v.toString(16);
      });
    }
    const buffer = await axios.get(urlImage, { responseType: "arraybuffer" });
    const base64 = `data:image/png;base64,${Buffer.from(buffer.data).toString("base64")}`;
    const uuid = generateUUIDv4();

    return new Promise((resolve, reject) => {
      const sock = new WebSocket(
        "wss://screenshot-code.onrender.com/generate-code",
      );

      const timer = setTimeout(() => {
        sock.terminate();
        reject(new Error("Timeout: Server tidak merespons dalam 30 detik"));
      }, timeoutMs);

      sock.on("open", () => {
        const payload = {
          generationType: "create",
          image: base64,
          codeGenerationModel: "gpt-4o-2024-05-13",
          editorTheme: "cobalt",
          generatedCodeConfig: "html_tailwind",
          inputMode: "image",
          isImageGenerationEnabled: true,
          isTermOfServiceAccepted: false,
          openAiApiKey: null,
          openAiBaseURL: null,
          screenshotOneApiKey: null,
          sessionId: uuid,
        };
        sock.send(JSON.stringify(payload));
      });

      sock.on("message", (raw) => {
        try {
          const data = JSON.parse(raw.toString());
          if (data.type === "setCode") {
            clearTimeout(timer);
            sock.close();
            resolve({ code: data.value });
          }
        } catch (err) {
          clearTimeout(timer);
          sock.close();
          reject(new Error("Parsing error: " + err.message));
        }
      });

      sock.on("error", (err) => {
        clearTimeout(timer);
        reject(err);
      });

      sock.on("close", () => {
        console.log("WebSocket Closed!");
      });
    });
  },
  chatAIOrg: async (query) => {
    if (!query) {
      return {
        code: 403,
        timestamp: new Date().getTime(),
        message: "Query Tidak Di Isi!",
      };
    }
    let payload = {
      messages: [
        {
          role: "user",
          content: query,
        },
      ],
    };
    let headers = {
      headers: {
        Origin: "https://chatai.org",
        Referer: "https://chatai.org/",
      },
    };
    let { data } = await axios.post(
      "https://chatai.org/api/chat",
      payload,
      headers,
    );
    if (data.status === 500) {
      return {
        code: 500,
        timestamp: new Date().getTime(),
        message: data.data || null,
      };
    }
    return {
      code: 200,
      timestamp: new Date().getTime(),
      message: data.content,
    };
  },
  chatAIOrgPrompt: async (query, prompt) => {
    if (!query && !prompt) {
      return {
        code: 403,
        timestamp: new Date().getTime(),
        message: "Parameter Query Atau Prompt Tidak Terisi.",
      };
    }
    let payload = {
      messages: [
        {
          role: "user",
          content: "Siapa Nama Kamu?",
        },
        {
          role: "assistant",
          content: prompt,
        },
        {
          role: "user",
          content: query,
        },
      ],
    };
    let headers = {
      headers: {
        Origin: "https://chatai.org",
        Referer: "https://chatai.org/",
      },
    };
    let { data } = await axios.post(
      "https://chatai.org/api/chat",
      payload,
      headers,
    );
    if (data.status === 500) {
      return {
        code: 500,
        timestamp: new Date().getTime(),
        message: data.data || null,
      };
    }
    return {
      code: 200,
      timestamp: new Date().getTime(),
      content: data.content,
    };
  },
  gptOnline: async (prompt) => {
    const { data: html } = await axios.get(
      "https://gptonline.ai/id/chatgpt-online/",
    );
    const $ = cheerio.load(html);

    const div = $(".wpaicg-chat-shortcode");
    const nonce = div.attr("data-nonce");
    const botId = div.attr("data-bot-id");
    const postId = div.attr("data-post-id");

    const form = new FormData();
    form.append("_wpnonce", nonce);
    form.append("post_id", postId);
    form.append("url", "https://gptonline.ai/id/chatgpt-online/");
    form.append("action", "wpaicg_chat_shortcode_message");
    form.append("message", prompt);
    form.append("bot_id", botId);
    form.append("chat_bot_identity", "custom_bot_1040");
    form.append("wpaicg_chat_history", "[]");
    form.append("wpaicg_chat_client_id", "LCgGOMeIOC");

    const headersList = {
      headers: {
        ...form.getHeaders(),
      },
    };

    const { data } = await axios.post(
      "https://gptonline.ai/id/wp-admin/admin-ajax.php",
      form,
      headersList,
    );
    return data;
  },
  aiCodeAssistant: async (q) => {
    async function generateUserId() {
      const chars =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
      let userId = "";
      for (let i = 0; i < 10; i++) {
        userId += chars[Math.floor(Math.random() * chars.length)];
      }
      return userId;
    }
    let userId = await generateUserId();
    let { data } = await axios.get(
      `https://yw85opafq6.execute-api.us-east-1.amazonaws.com/default/boss_mode_15aug?text=Generate a Codes in Indonesian for the following text: ${encodeURIComponent(q)}&country=Asia&user_id=${userId}`,
    );
    return data;
  },
  toBald: async (imgUrl) => {
    const ress = await axios.get(imgUrl, {
      responseType: "arraybuffer",
    });
    const base64 = Buffer.from(ress.data).toString("base64");
    const payload = {
      filter: "botak",
      imageData: base64,
    };
    const { data } = await axios.post(
      "https://wpw.my.id/api/process-image",
      payload,
    );
    return {
      success: true,
      outputBase64: data.processedImageUrl,
    };
  },
  toBlack: async (imgUrl) => {
    const ress = await axios.get(imgUrl, {
      responseType: "arraybuffer",
    });
    const base64 = Buffer.from(ress.data).toString("base64");
    const payload = {
      filter: "hitam",
      imageData: base64,
    };
    const { data } = await axios.post(
      "https://wpw.my.id/api/process-image",
      payload,
    );
    return {
      success: true,
      outputBase64: data.processedImageUrl,
    };
  },
  toPiggy: async (imgUrl) => {
    const ress = await axios.get(imgUrl, {
      responseType: "arraybuffer",
    });
    const base64 = Buffer.from(ress.data).toString("base64");
    const payload = {
      filter: "piggy",
      imageData: base64,
    };
    const { data } = await axios.post(
      "https://wpw.my.id/api/process-image",
      payload,
    );
    return {
      success: true,
      outputBase64: data.processedImageUrl,
    };
  },
  toNerd: async (imgUrl) => {
    const ress = await axios.get(imgUrl, {
      responseType: "arraybuffer",
    });
    const base64 = Buffer.from(ress.data).toString("base64");
    const payload = {
      filter: "nerd",
      imageData: base64,
    };
    const { data } = await axios.post(
      "https://wpw.my.id/api/process-image",
      payload,
    );
    return {
      success: true,
      outputBase64: data.processedImageUrl,
    };
  },
  gemini: async (chat) => {
    const apikeyArray = [
      "AIzaSyA0ECSvKEUpTySjwCXLPQATWTjJzmaDeoc",
      "AIzaSyB8qHA81c8rsNGQ9PyeOSCXMgxJ99h63Rg",
      "AIzaSyDptw3Q8R_s_cLUfYcb3hQCWXuboM08CSQ",
    ];
    const randomMath = MathRandoms(apikeyArray);
    const payload = {
      contents: [
        {
          parts: [
            {
              text: chat,
            },
          ],
        },
      ],
    };
    const { data } = await axios.post(
      `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${randomMath}`,
      payload,
    );
    return {
      success: true,
      response: data.candidates[0].content.parts[0].text,
    };
  },
  phindChat: async (chat, options = {}) => {
    const endpoint = "https://https.extension.phind.com/agent/";

    const getHeaders = () => ({
      "Content-Type": "application/json",
      "User-Agent": "",
      Accept: "*/*",
      "Accept-Encoding": "Identity",
    });

    const createRequestBody = (input, options = {}) => ({
      additional_extension_context: "",
      allow_magic_buttons: true,
      is_vscode_extension: true,
      message_history: [
        ...(options.previousMessages || []),
        { content: input, role: "user" },
      ],
      requested_model: options.model || "Phind-70B",
      user_input: input,
    });
    try {
      const response = await fetch(endpoint, {
        method: "POST",
        headers: getHeaders(),
        body: JSON.stringify(createRequestBody(chat, options)),
      });

      if (!response.ok) {
        throw new Error(`Request failed with status ${response.status}`);
      }

      const reader = response.body.getReader();
      const decoder = new TextDecoder();
      let fullText = "";

      while (true) {
        const { done, value } = await reader.read();

        if (done) {
          break;
        }

        const text = decoder.decode(value);
        const lines = text.split("\n");

        for (const line of lines) {
          if (line.startsWith("data: ")) {
            try {
              const jsonStr = line.slice(6);
              if (jsonStr === "[DONE]") continue;

              const data = JSON.parse(jsonStr);
              if (data.choices?.[0]?.delta?.content) {
                fullText += data.choices[0].delta.content;
              }
            } catch (e) {
              // Skip invalid JSON
            }
          }
        }
      }

      return fullText;
    } catch (error) {
      console.error("Error:", error);
      throw error;
    }
  },
  ratePhoto: async (url) => {
    const ress = await axios.get(url, {
      responseType: "arraybuffer",
    });
    const binarys = Buffer.from(ress.data, "binary");
    const d = new FormData();
    d.append("imageFile", binarys, { filename: "y.png" });
    d.append("canvasimg", "");
    d.append(
      "image_data",
      `data:image/png;base64,${Buffer.from(ress.data).toString("base64")}`,
    );
    const headers = {
      headers: {
        ...d.getHeaders(),
      },
    };
    const { data: s } = await axios.post(
      "https://rate-my-photo.com/result",
      d,
      headers,
    );
    const $ = cheerio.load(s);
    const score = $(".skill-progress")
      .first()
      .text()
      .trim()
      .replace("SCORE: ", "");
    const compare = $(".card-text").text().trim();
    const aesthetic = $(".text-success").text().replace(/\s+/g, " ").trim();
    return {
      success: true,
      result: {
        score,
        aesthetic,
      },
    };
  },
};

export default ai;