@wrongstack/plugins 0.275.1 → 0.276.3

package/dist/web-search.js

@@ -1,283 +1,13 @@
-import { lookup } from 'dns/promises';
-import { isIPv4, isIPv6 } from 'net';
-import { isPrivateIPv4, isPrivateIPv6 } from '@wrongstack/core';
-
 // src/web-search/index.ts
 var API_VERSION = "^0.1.10";
-async function duckduckgoSearch(query, numResults) {
-  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}&kl=us-en`;
-  const resp = await fetch(url, {
-    headers: {
-      "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)"
-    }
-  });
-  if (!resp.ok) throw new Error(`DuckDuckGo search failed: ${resp.status}`);
-  const html = await resp.text();
-  const results = [];
-  const resultRe = /<a\b[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<a\b[^>]*class="[^"]*result__a[^"]*"|<\/body>|$)/gi;
-  let m;
-  while ((m = resultRe.exec(html)) !== null && results.length < numResults) {
-    const url2 = normalizeDuckDuckGoUrl(m[1]);
-    if (!url2) continue;
-    const title = htmlToText(m[2] ?? "");
-    const snippet = extractDuckDuckGoSnippet(m[3] ?? "");
-    results.push({
-      url: url2,
-      title,
-      snippet,
-      score: 1,
-      source: "duckduckgo",
-      cached: false
-    });
-  }
-  if (results.length === 0 && /result__a|result__snippet|result__body|anomaly-modal|captcha/i.test(html)) {
-    throw new Error("DuckDuckGo response format was not recognized or was blocked");
-  }
-  return results;
-}
-function normalizeDuckDuckGoUrl(rawUrl) {
-  if (!rawUrl) return null;
-  let url = htmlToText(rawUrl);
-  if (url.startsWith("//duckduckgo.com/l/")) url = `https:${url}`;
-  if (url.startsWith("/l/")) url = new URL(url, "https://duckduckgo.com").toString();
-  try {
-    const parsed = new URL(url);
-    const redirected = parsed.searchParams.get("uddg");
-    if (redirected) return redirected;
-    return parsed.toString();
-  } catch {
-    return null;
-  }
-}
-function htmlToText(html) {
-  return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
-}
-function extractDuckDuckGoSnippet(html) {
-  const snippetRe = /<(?:a|div)\b[^>]*class="[^"]*(?:result__snippet|result__body)[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i;
-  const snippetMatch = snippetRe.exec(html);
-  return htmlToText(snippetMatch?.[1] ?? "");
-}
-function assertSafeIp(ip) {
-  if (isIPv4(ip) && isPrivateIPv4(ip)) {
-    throw new Error(`Blocked private/loopback address: ${ip}`);
-  }
-  if (isIPv6(ip) && isPrivateIPv6(ip)) {
-    throw new Error(`Blocked private/loopback address: ${ip}`);
-  }
-}
-async function assertSafeUrl(rawUrl) {
-  const u = new URL(rawUrl);
-  if (u.protocol !== "http:" && u.protocol !== "https:") {
-    throw new Error(`Unsupported protocol: ${u.protocol}`);
-  }
-  const host = u.hostname.startsWith("[") && u.hostname.endsWith("]") ? u.hostname.slice(1, -1) : u.hostname;
-  if (host === "localhost" || host.endsWith(".localhost") || host === "" || host === "0.0.0.0") {
-    throw new Error("Blocked localhost target");
-  }
-  if (isIPv4(host) || isIPv6(host)) {
-    assertSafeIp(host);
-    return;
-  }
-  let addrs;
-  try {
-    addrs = await lookup(host, { all: true });
-  } catch {
-    throw new Error(`Could not resolve host: ${host}`);
-  }
-  for (const { address } of addrs) assertSafeIp(address);
-}
-async function fetchUrl(url, format) {
-  const MAX_REDIRECTS = 5;
-  let currentUrl = url;
-  let resp;
-  for (let i = 0; i <= MAX_REDIRECTS; i++) {
-    await assertSafeUrl(currentUrl);
-    resp = await fetch(currentUrl, {
-      redirect: "manual",
-      headers: {
-        "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)",
-        Accept: format === "text" ? "text/plain" : "text/html"
-      }
-    });
-    if (resp.status >= 300 && resp.status < 400) {
-      const loc = resp.headers.get("location");
-      if (!loc) break;
-      currentUrl = new URL(loc, currentUrl).toString();
-      if (i === MAX_REDIRECTS) throw new Error("Too many redirects");
-      continue;
-    }
-    break;
-  }
-  if (!resp) throw new Error(`Failed to fetch ${url}`);
-  if (!resp.ok) throw new Error(`Failed to fetch ${url}: ${resp.status} ${resp.statusText}`);
-  if (format === "text") {
-    return resp.text();
-  }
-  let html = await resp.text();
-  html = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
-  html = html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
-  html = html.replace(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi, (_, t) => `
-## ${t.trim()}
-`);
-  html = html.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, t) => `${t.trim()}
-
-`);
-  html = html.replace(/<br\s*\/?>/gi, "\n");
-  html = html.replace(/<[^>]+>/g, "");
-  html = html.replace(/&amp;/g, "&");
-  html = html.replace(/&lt;/g, "<");
-  html = html.replace(/&gt;/g, ">");
-  html = html.replace(/&quot;/g, '"');
-  html = html.replace(/&#39;/g, "'");
-  html = html.replace(/\n{3,}/g, "\n\n");
-  return html.trim().slice(0, 5e4);
-}
-function scoreResults(results, query) {
-  const terms = query.toLowerCase().split(/\s+/);
-  return results.map((r) => {
-    const titleLower = r.title.toLowerCase();
-    const snippetLower = r.snippet.toLowerCase();
-    let score = r.score;
-    for (const term of terms) {
-      if (titleLower.includes(term)) score += 2;
-      if (snippetLower.includes(term)) score += 1;
-    }
-    return { ...r, score };
-  }).sort((a, b) => b.score - a.score);
-}
 var plugin = {
   name: "web-search",
-  version: "0.1.0",
-  description: "Cached web search with deduplication and relevance ranking",
+  version: "0.3.0",
+  description: "Retired \u2014 capabilities merged into built-in search and fetch tools",
   apiVersion: API_VERSION,
-  capabilities: { tools: true, pipelines: ["request"] },
-  defaultConfig: {
-    cacheTtlMs: 3e5,
-    maxResults: 10,
-    userAgent: "WrongStack/1.0"
-  },
-  configSchema: {
-    type: "object",
-    properties: {
-      cacheTtlMs: { type: "number", default: 3e5 },
-      maxResults: { type: "number", default: 10 },
-      userAgent: { type: "string", default: "WrongStack/1.0" }
-    }
-  },
+  capabilities: { tools: true },
   setup(api) {
-    const cache = /* @__PURE__ */ new Map();
-    const cacheTtlMs = api.config.extensions?.["web-search"]?.["cacheTtlMs"] ?? 3e5;
-    const maxResults = api.config.extensions?.["web-search"]?.["maxResults"] ?? 10;
-    api.tools.register({
-      name: "web_search",
-      description: "Search the web using DuckDuckGo with automatic caching and deduplication. Results are cached for faster subsequent queries.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          numResults: { type: "number", default: 10, description: "Maximum number of results" },
-          source: { type: "string", enum: ["duckduckgo"], default: "duckduckgo", description: "Search engine" },
-          skipCache: { type: "boolean", default: false, description: "Skip cache and force fresh search" }
-        },
-        required: ["query"]
-      },
-      permission: "auto",
-      mutating: true,
-      async execute(input) {
-        const query = input["query"];
-        if (!query || typeof query !== "string" || query.trim() === "") {
-          return { ok: false, error: "query is required and must be a non-empty string", results: [] };
-        }
-        const numResults = input["numResults"] ?? maxResults;
-        const skipCache = input["skipCache"] ?? false;
-        if (!skipCache) {
-          const cached = cache.get(query);
-          if (cached && Date.now() - cached.timestamp < cacheTtlMs) {
-            const results = cached.results.map((r) => ({ ...r, cached: true }));
-            api.metrics.counter("cache_hit", 1, { query: query.slice(0, 20) });
-            return {
-              ok: true,
-              query,
-              cached: true,
-              results: results.slice(0, numResults),
-              count: results.length
-            };
-          }
-        }
-        api.metrics.counter("cache_miss", 1, { query: query.slice(0, 20) });
-        const seenUrls = /* @__PURE__ */ new Set();
-        let rawResults;
-        try {
-          rawResults = await duckduckgoSearch(query, numResults * 2);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: `Search failed: ${msg}`, results: [] };
-        }
-        const deduplicated = [];
-        for (const r of rawResults) {
-          const noQuery = r.url.split("?")[0] ?? r.url;
-          const normalized = noQuery.split("#")[0] ?? r.url;
-          if (!seenUrls.has(normalized) && r.url.startsWith("http")) {
-            seenUrls.add(normalized);
-            deduplicated.push(r);
-          }
-        }
-        const ranked = scoreResults(deduplicated, query);
-        cache.set(query, { results: ranked, timestamp: Date.now() });
-        const now = Date.now();
-        for (const [key, entry] of cache.entries()) {
-          if (now - entry.timestamp > cacheTtlMs * 2) cache.delete(key);
-        }
-        return {
-          ok: true,
-          query,
-          cached: false,
-          results: ranked.slice(0, numResults),
-          count: ranked.length
-        };
-      }
-    });
-    api.tools.register({
-      name: "web_fetch",
-      description: "Fetch a URL and return its content as markdown or plain text.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          url: { type: "string", format: "uri", description: "URL to fetch" },
-          format: { type: "string", enum: ["markdown", "text"], default: "markdown" }
-        },
-        required: ["url"]
-      },
-      permission: "confirm",
-      mutating: false,
-      async execute(input) {
-        const rawUrl = input["url"];
-        if (!rawUrl || typeof rawUrl !== "string") {
-          return { ok: false, error: "url is required and must be a string" };
-        }
-        const url = rawUrl;
-        const format = input["format"] ?? "markdown";
-        if (!url.startsWith("http://") && !url.startsWith("https://")) {
-          return { ok: false, error: "URL must start with http:// or https://" };
-        }
-        let content;
-        try {
-          content = await fetchUrl(url, format);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: msg };
-        }
-        return {
-          ok: true,
-          url,
-          format,
-          contentLength: content.length,
-          content: content.slice(0, 2e4),
-          truncated: content.length > 2e4
-        };
-      }
-    });
-    api.log.info("web-search plugin loaded", { version: "0.1.0", cacheTtlMs });
+    api.log.info("web-search plugin retired \u2014 use the built-in search and fetch tools");
   }
 };
 var web_search_default = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/plugins",
-  "version": "0.275.1",
+  "version": "0.276.3",
   "description": "Official WrongStack plugin collection — auto-doc, git-autocommit, shell-check, cost-tracker, file-watcher, web-search, json-path, cron, template-engine, semver-bump",
   "license": "MIT",
   "author": "ECOSTACK TECHNOLOGY OÜ",
@@ -63,7 +63,7 @@
     "vitest": "^4.1.8"
   },
   "dependencies": {
-    "@wrongstack/core": "0.275.1"
+    "@wrongstack/core": "0.276.3"
   },
   "scripts": {
     "build": "tsup",