search-web-api 1.0.13

package/src/sources/images/google_images.ts

@@ -0,0 +1,101 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const google_images: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    tbm: "isch",
+    asearch: "isch",
+    hl: "en",
+    gl: "US",
+    async: `_fmt:json,p:1,ijn:${(page || 1) - 1}`,
+  });
+  const response = await fetch(
+    `https://www.google.com/search?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "NSTN/3.60.474802233.release Dalvik/2.1.0 (Linux; U; Android 12; US) gzip",
+        Accept:
+          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.5",
+        Cookie: "CONSENT=YES+; SOCS=CAESBQgYEgAgAA==",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const html = await response.text();
+
+  if (!html || typeof html !== "string") {
+    return [];
+  }
+
+  try {
+    const jsonStart = html.indexOf('{"ischj":');
+    if (jsonStart === -1) {
+      return [];
+    }
+
+    const jsonData = JSON.parse(html.substring(jsonStart));
+    const metadata = jsonData?.ischj?.metadata || [];
+
+    return metadata
+      .map((item: any) => {
+        if (!item?.result || !item?.original_image) {
+          return null;
+        }
+
+        const result = item.result;
+        const originalImage = item.original_image;
+        const thumbnail = item.thumbnail;
+
+        const sourceParts: string[] = [];
+        if (result.site_title) {
+          sourceParts.push(result.site_title);
+        }
+
+        const author = result.iptc?.creator;
+        if (author && Array.isArray(author)) {
+          sourceParts.push(`Author: ${author.join(", ")}`);
+        }
+
+        const copyright = result.iptc?.copyright_notice;
+        if (copyright) {
+          sourceParts.push(copyright);
+        }
+
+        if (result.freshness_date) {
+          sourceParts.push(result.freshness_date);
+        }
+
+        const fileSize = item.gsa?.file_size;
+        if (fileSize) {
+          sourceParts.push(`(${fileSize})`);
+        }
+
+        const resolution = `${originalImage.width} x ${originalImage.height}`;
+
+        const content = [
+          item.text_in_grid?.snippet || "",
+          sourceParts.join(" | "),
+          `Resolution: ${resolution}`,
+        ]
+          .filter(Boolean)
+          .join("\n");
+
+        return {
+          url: result.referrer_url,
+          title: result.page_title || "",
+          content,
+          thumbnail: thumbnail?.url,
+          engine: "google_images",
+        };
+      })
+      .filter((r: any) => r !== null);
+  } catch (e) {
+    console.error("Error parsing Google Images response:", e);
+    return [];
+  }
+};

package/src/sources/images/imgur.ts

@@ -0,0 +1,58 @@
+import { parseHTML } from "linkedom";
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const imgur: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    qs: "thumbs",
+    p: String((page || 1) - 1),
+  });
+  const response = await fetch(
+    `https://imgur.com/search/score/all?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        Accept:
+          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.5",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const html = await response.text();
+
+  if (!html || typeof html !== "string") {
+    return [];
+  }
+
+  const { document } = parseHTML(html);
+
+  return Array.from(
+    document.querySelectorAll('div.cards div.post, div[class*="post"]')
+  )
+    .map((element) => {
+      const link = element.querySelector("a");
+      const url = link?.getAttribute("href");
+      const title = link?.querySelector("img")?.getAttribute("alt") || "";
+      let thumbnail = link?.querySelector("img")?.getAttribute("src") || "";
+
+      if (!url || !thumbnail || thumbnail.length < 25) {
+        return null;
+      }
+
+      const imgSrc = thumbnail.replace("b.", ".");
+
+      return {
+        url: `https://imgur.com${url}`,
+        title,
+        content: "",
+        thumbnail,
+        engine: "imgur",
+      };
+    })
+    .filter((r) => r !== null);
+};

package/src/sources/images/openclipart.ts

@@ -0,0 +1,52 @@
+import { parseHTML } from "linkedom";
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const openclipart: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    query: query,
+    p: String(page || 1),
+  });
+  const response = await fetch(
+    `https://openclipart.org/search/?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const html = await response.text();
+
+  if (!html || typeof html !== "string") {
+    return [];
+  }
+
+  const { document } = parseHTML(html);
+
+  return Array.from(
+    document.querySelectorAll("div.gallery div.artwork")
+  )
+    .map((element) => {
+      const link = element.querySelector("a");
+      const href = link?.getAttribute("href");
+      const title = link?.querySelector("img")?.getAttribute("alt");
+      const imgSrc = link?.querySelector("img")?.getAttribute("src");
+
+      if (!href || !title || !imgSrc) {
+        return null;
+      }
+
+      return {
+        url: `https://openclipart.org${href}`,
+        title,
+        content: "",
+        engine: "openclipart",
+        thumbnail: `https://openclipart.org${imgSrc}`,
+      };
+    })
+    .filter((r) => r !== null);
+};

package/src/sources/images/pixabay.ts

@@ -0,0 +1,56 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const pixabay: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    pagi: String(page || 1),
+  });
+  const response = await fetch(
+    `https://pixabay.com/images/search/${query}/?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Pixabay",
+        "x-bootstrap-cache-miss": "1",
+        "x-fetch-bootstrap": "1",
+      },
+      redirect: "manual",
+    }
+  );
+  if (!response.ok) return [];
+  const json = await response.json();
+
+  if (!json || !json.page || !json.page.results) {
+    return [];
+  }
+
+  return json.page.results
+    .map((result: any) => {
+      if (
+        !result.mediaType ||
+        !["photo", "illustration", "vector"].includes(result.mediaType)
+      ) {
+        return null;
+      }
+
+      const sources = result.sources || {};
+      const thumbnail =
+        (Object.values(sources)[0] as string) || "";
+      const img_src =
+        (Object.values(sources)[
+          Object.values(sources).length - 1
+        ] as string) || "";
+
+      return {
+        url: `https://pixabay.com${result.href}`,
+        title: result.name || "",
+        content: result.description || "",
+        engine: "pixabay",
+        thumbnail,
+        img_src,
+      };
+    })
+    .filter((r: any) => r !== null);
+};

package/src/sources/images/unsplash.ts

@@ -0,0 +1,38 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const unsplash: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    query: query,
+    per_page: "20",
+    page: String(page || 1),
+  });
+  const response = await fetch(
+    `https://unsplash.com/napi/search/photos?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const json = await response.json();
+
+  if (!json || !json.results) {
+    return [];
+  }
+
+  return json.results.map((item: any) => ({
+    url: item.links.html,
+    title:
+      item.description ||
+      item.alt_description ||
+      "Unsplash Image",
+    content: `By ${item.user.name}`,
+    thumbnail: item.urls.small,
+    engine: "unsplash",
+  }));
+};

package/src/sources/images/wallhaven.ts

@@ -0,0 +1,50 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const wallhaven: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page || 1),
+    purity: "100",
+  });
+  const response = await fetch(
+    `https://wallhaven.cc/api/v1/search?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const json = await response.json();
+
+  if (!json || !json.data) {
+    return [];
+  }
+
+  return json.data.map((result: any) => {
+    const fileSize = result.file_size
+      ? `${(result.file_size / 1024 / 1024).toFixed(2)} MB`
+      : "";
+    const content = [
+      `${result.category} / ${result.purity}`,
+      result.resolution ? `Resolution: ${result.resolution}` : "",
+      fileSize ? `Size: ${fileSize}` : "",
+      result.file_type ? `Format: ${result.file_type}` : "",
+    ]
+      .filter(Boolean)
+      .join(" | ");
+
+    return {
+      url: result.url,
+      title: result.resolution || "Wallpaper",
+      content,
+      engine: "wallhaven",
+      img_src: result.path,
+      thumbnail: result.thumbs?.small || result.thumbs?.original,
+    };
+  });
+};

package/src/sources/it/crates.ts

@@ -0,0 +1,41 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const crates: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page || 1),
+    per_page: "10",
+  });
+  const response = await fetch(`https://crates.io/api/v1/crates?${params}`, {
+    headers: {
+      "User-Agent":
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+      Accept: "application/json",
+    },
+  });
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (data && data.crates) {
+    data.crates.forEach((crate: any) => {
+      const name = crate.name;
+      const version = crate.max_version || crate.newest_version;
+      const description = crate.description || "No description";
+      const downloads = crate.downloads || 0;
+      const recent_downloads = crate.recent_downloads || 0;
+
+      results.push({
+        url: `https://crates.io/crates/${name}`,
+        title: `${name} ${version}`,
+        content: `${description} | 📥 ${downloads.toLocaleString()} total, ${recent_downloads.toLocaleString()} recent`,
+        engine: "crates",
+      });
+    });
+  }
+
+  return results;
+};

package/src/sources/it/dockerhub.ts

@@ -0,0 +1,47 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const dockerhub: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page || 1),
+    page_size: "25",
+  });
+  const response = await fetch(
+    `https://hub.docker.com/api/search/v3/catalog/search?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        Accept: "application/json",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (data && data.results) {
+    data.results.forEach((item: any) => {
+      const name = item.name || item.slug;
+      const namespace = item.namespace || "";
+      const fullName = namespace ? `${namespace}/${name}` : name;
+      const description =
+        item.description || item.short_description || "No description";
+      const stars = item.star_count || 0;
+      const pulls = item.pull_count || 0;
+      const isOfficial = item.is_official || false;
+
+      results.push({
+        url: `https://hub.docker.com/r/${fullName}`,
+        title: `${fullName}${isOfficial ? " [OFFICIAL]" : ""}`,
+        content: `${description} | ⭐ ${stars} | 📥 ${pulls.toLocaleString()} pulls`,
+        engine: "dockerhub",
+      });
+    });
+  }
+
+  return results;
+};

package/src/sources/it/github.ts

@@ -0,0 +1,37 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const github: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page || 1),
+    per_page: "10",
+  });
+  const response = await fetch(
+    `https://api.github.com/search/repositories?${params}`,
+    {
+      headers: {
+        "User-Agent": "HonoxSearX/1.0",
+        Accept: "application/vnd.github.v3+json",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (data && data.items) {
+    data.items.forEach((item: any) => {
+      results.push({
+        url: item.html_url,
+        title: item.full_name,
+        content: item.description || "No description",
+        engine: "github",
+      });
+    });
+  }
+
+  return results;
+};

package/src/sources/it/gitlab.ts

@@ -0,0 +1,55 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const gitlab: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    search: query,
+    page: String(page || 1),
+  });
+  const response = await fetch(
+    `https://gitlab.com/api/v4/projects?${params}`,
+    {
+      headers: {
+        Accept: "application/json",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results = [];
+
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      try {
+        const result: any = {
+          url: item.web_url || "",
+          title: item.name || "",
+          content: item.description || "",
+          thumbnail: item.avatar_url,
+          publishedDate: new Date(
+            item.last_activity_at || item.created_at
+          ),
+          engine: "gitlab",
+        };
+
+        // Add extra fields
+        result.template = "packages";
+        result.package_name = item.name;
+        result.maintainer = item.namespace?.name;
+        result.tags = item.tag_list || [];
+        result.popularity = item.star_count;
+        result.homepage = item.readme_url;
+        result.source_code_url = item.http_url_to_repo;
+
+        results.push(result);
+      } catch (error) {
+        // Skip malformed results
+        continue;
+      }
+    }
+  }
+
+  return results;
+};

package/src/sources/it/npm.ts

@@ -0,0 +1,36 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const npm: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    text: query,
+    size: "10",
+    from: String(((page || 1) - 1) * 10),
+  });
+  const response = await fetch(
+    `https://registry.npmjs.org/-/v1/search?${params}`,
+    {
+      headers: {
+        "User-Agent": "HonoxSearX/1.0",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (data && data.objects) {
+    data.objects.forEach((item: any) => {
+      results.push({
+        url: item.package.links.npm,
+        title: item.package.name,
+        content: item.package.description || "",
+        engine: "npm",
+      });
+    });
+  }
+
+  return results;
+};

package/src/sources/it/packagist.ts

@@ -0,0 +1,43 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const packagist: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    q: query,
+    page: String(page || 1),
+    per_page: "15",
+  });
+  const response = await fetch(
+    `https://packagist.org/search.json?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        Accept: "application/json",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (data && data.results) {
+    data.results.forEach((pkg: any) => {
+      const name = pkg.name;
+      const description = pkg.description || "No description";
+      const downloads = pkg.downloads || 0;
+      const favers = pkg.favers || 0;
+
+      results.push({
+        url: pkg.url || `https://packagist.org/packages/${name}`,
+        title: name,
+        content: `${description} | 📥 ${downloads.toLocaleString()} downloads | ⭐ ${favers} favorites`,
+        engine: "packagist",
+      });
+    });
+  }
+
+  return results;
+};

package/src/sources/it/pypi.ts

@@ -0,0 +1,30 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const pypi: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({ q: query });
+  const response = await fetch(`https://pypi.org/search/?${params}`);
+  if (!response.ok) return [];
+  const html = await response.text();
+  const results = [];
+
+  // PyPI search uses a simple structure
+  const packageRegex =
+    /<a class="package-snippet"[^>]*href="([^"]+)"[^>]*>[\s\S]*?<span class="package-snippet__name">([^<]+)<\/span>[\s\S]*?<span class="package-snippet__version">([^<]+)<\/span>[\s\S]*?<p class="package-snippet__description">([^<]*)<\/p>/g;
+
+  let match;
+  while ((match = packageRegex.exec(html)) !== null) {
+    const [, url, name, version, description] = match;
+
+    results.push({
+      url: `https://pypi.org${url}`,
+      title: `${name.trim()} ${version.trim()}`,
+      content: description.trim() || "No description available",
+      engine: "pypi",
+    });
+  }
+
+  return results;
+};

package/src/sources/it/rubygems.ts

@@ -0,0 +1,43 @@
+import { EngineFunction } from "../../types/search-engine-interface.js";
+
+export const rubygems: EngineFunction = async (
+  query: string,
+  page: number | undefined
+) => {
+  const params = new URLSearchParams({
+    query: query,
+    page: String(page || 1),
+  });
+  const response = await fetch(
+    `https://rubygems.org/api/v1/search.json?${params}`,
+    {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        Accept: "application/json",
+      },
+    }
+  );
+  if (!response.ok) return [];
+  const data = await response.json();
+  const results: any[] = [];
+
+  if (Array.isArray(data)) {
+    data.forEach((gem: any) => {
+      const name = gem.name;
+      const version = gem.version;
+      const info = gem.info || "No description";
+      const downloads = gem.downloads || 0;
+      const authors = gem.authors || "";
+
+      results.push({
+        url: `https://rubygems.org/gems/${name}`,
+        title: `${name} ${version}`,
+        content: `${info} | By: ${authors} | 📥 ${downloads.toLocaleString()} downloads`,
+        engine: "rubygems",
+      });
+    });
+  }
+
+  return results;
+};