privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-6FUXKHOK.mjs

@@ -0,0 +1,1969 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  value_exports
+} from "./c-6LOBR4I6.mjs";
+import {
+  typebox_exports
+} from "./c-RQJJ26T4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/brave.ts?ext=privateer-web
+var BRAVE_SEARCH_API_URL = "https://api.search.brave.com/res/v1/web/search";
+var BRAVE_API_KEY_ENV_VAR = "BRAVE_SEARCH_API_KEY";
+var BRAVE_PROVIDER_META = {
+  name: "brave",
+  label: "Brave",
+  envVar: BRAVE_API_KEY_ENV_VAR,
+  roles: ["search"]
+};
+function normalizeBraveResults(raw) {
+  return (raw.web?.results ?? []).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.description ?? ""
+  }));
+}
+__name(normalizeBraveResults, "normalizeBraveResults");
+var BraveProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "BraveProvider");
+  }
+  name = BRAVE_PROVIDER_META.name;
+  label = BRAVE_PROVIDER_META.label;
+  envVar = BRAVE_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const url = new URL(BRAVE_SEARCH_API_URL);
+    url.searchParams.set("q", query);
+    url.searchParams.set("count", String(maxResults));
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": this.apiKey
+      },
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeBraveResults(raw) };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/exa.ts?ext=privateer-web
+var EXA_API_URL = "https://api.exa.ai/search";
+var EXA_CONTENTS_API_URL = "https://api.exa.ai/contents";
+var EXA_API_KEY_ENV_VAR = "EXA_API_KEY";
+var EXA_PROVIDER_META = {
+  name: "exa",
+  label: "Exa",
+  envVar: EXA_API_KEY_ENV_VAR,
+  roles: ["search", "fetch"]
+};
+var EXA_MAX_SNIPPET_CHARACTERS = 300;
+var EXA_MAX_FETCH_CHARACTERS = 1e6;
+function normalizeExaResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.text ?? ""
+  }));
+}
+__name(normalizeExaResults, "normalizeExaResults");
+var ExaProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "ExaProvider");
+  }
+  name = EXA_PROVIDER_META.name;
+  label = EXA_PROVIDER_META.label;
+  envVar = EXA_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(EXA_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey
+      },
+      body: JSON.stringify({
+        query,
+        numResults: maxResults,
+        contents: {
+          text: { maxCharacters: EXA_MAX_SNIPPET_CHARACTERS }
+        }
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeExaResults(raw.results ?? []) };
+  }
+  async fetch(url, _raw, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(EXA_CONTENTS_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey
+      },
+      body: JSON.stringify({
+        ids: [url],
+        text: { maxCharacters: EXA_MAX_FETCH_CHARACTERS }
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Fetch API error (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    const result = data.results?.[0];
+    if (!result?.text) {
+      throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+    }
+    return {
+      text: result.text,
+      title: result.title || void 0,
+      contentType: "text/plain"
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/firecrawl.ts?ext=privateer-web
+var FIRECRAWL_API_URL = "https://api.firecrawl.dev/v1";
+var FIRECRAWL_API_KEY_ENV_VAR = "FIRECRAWL_API_KEY";
+var FIRECRAWL_PROVIDER_META = {
+  name: "firecrawl",
+  label: "Firecrawl",
+  envVar: FIRECRAWL_API_KEY_ENV_VAR,
+  roles: ["search", "fetch"]
+};
+function normalizeFirecrawlResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.description ?? ""
+  }));
+}
+__name(normalizeFirecrawlResults, "normalizeFirecrawlResults");
+var FirecrawlProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "FirecrawlProvider");
+  }
+  name = FIRECRAWL_PROVIDER_META.name;
+  label = FIRECRAWL_PROVIDER_META.label;
+  envVar = FIRECRAWL_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(`${FIRECRAWL_API_URL}/search`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        query,
+        limit: maxResults
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeFirecrawlResults(raw.data ?? []) };
+  }
+  async fetch(url, _raw, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(`${FIRECRAWL_API_URL}/scrape`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        url,
+        formats: ["markdown"]
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Fetch API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    if (!raw.success) {
+      throw new Error(`${this.label} Fetch API error: ${raw.error ?? "scrape failed"}`);
+    }
+    if (!raw.data?.markdown) {
+      throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+    }
+    return {
+      text: raw.data.markdown,
+      title: raw.data.metadata?.title || void 0,
+      contentType: "text/markdown"
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/jina.ts?ext=privateer-web
+var JINA_SEARCH_API_URL = "https://s.jina.ai/";
+var JINA_READER_API_URL = "https://r.jina.ai/";
+var JINA_API_KEY_ENV_VAR = "JINA_API_KEY";
+var JINA_PROVIDER_META = {
+  name: "jina",
+  label: "Jina",
+  envVar: JINA_API_KEY_ENV_VAR,
+  roles: ["search", "fetch"]
+};
+function normalizeJinaResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.description ?? ""
+  }));
+}
+__name(normalizeJinaResults, "normalizeJinaResults");
+var JinaProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "JinaProvider");
+  }
+  name = JINA_PROVIDER_META.name;
+  label = JINA_PROVIDER_META.label;
+  envVar = JINA_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const url = new URL(`${JINA_SEARCH_API_URL}${encodeURIComponent(query)}`);
+    url.searchParams.set("num", String(maxResults));
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    const results = normalizeJinaResults(Array.isArray(raw.data) ? raw.data : raw.data?.results ?? []).slice(
+      0,
+      maxResults
+    );
+    return { query, results };
+  }
+  async fetch(url, _raw, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(`${JINA_READER_API_URL}${url}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      signal
+    });
+    if (!res.ok) {
+      const text2 = await res.text();
+      throw new Error(`${this.label} Fetch API error (${res.status}): ${text2}`);
+    }
+    const text = await res.text();
+    if (!text.trim()) {
+      throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+    }
+    return {
+      text,
+      contentType: "text/markdown"
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/types.ts?ext=privateer-web
+function isCancellation(input) {
+  return input == null;
+}
+__name(isCancellation, "isCancellation");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/ollama.ts?ext=privateer-web
+var OLLAMA_API_KEY_ENV_VAR = "OLLAMA_API_KEY";
+var OLLAMA_HOST_ENV_VAR = "OLLAMA_HOST";
+var OLLAMA_DEFAULT_URL = "http://localhost:11434";
+var CLOUD_SEARCH_PATH = "/api/web_search";
+var CLOUD_FETCH_PATH = "/api/web_fetch";
+var LOCAL_SEARCH_PATH = "/api/experimental/web_search";
+var LOCAL_FETCH_PATH = "/api/experimental/web_fetch";
+function isLocalHost(baseUrl) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "[::1]";
+  } catch {
+    return true;
+  }
+}
+__name(isLocalHost, "isLocalHost");
+var MASK_VISIBLE_CHARS = 4;
+var OLLAMA_PROVIDER_META = {
+  name: "ollama",
+  label: "Ollama",
+  envVar: OLLAMA_API_KEY_ENV_VAR,
+  baseUrlEnvVar: OLLAMA_HOST_ENV_VAR,
+  defaultBaseUrl: OLLAMA_DEFAULT_URL,
+  roles: ["search", "fetch"],
+  configure: /* @__PURE__ */ __name((ui, current) => configureOllama(ui, current), "configure")
+};
+function normalizeOllamaResults(raw) {
+  return (raw.results ?? []).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? ""
+  }));
+}
+__name(normalizeOllamaResults, "normalizeOllamaResults");
+function stripTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
+__name(stripTrailingSlashes, "stripTrailingSlashes");
+function assertHttpUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`${OLLAMA_HOST_ENV_VAR} is not a valid URL (got: ${url})`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `${OLLAMA_HOST_ENV_VAR} must use http:// or https:// (got: ${parsed.protocol.replace(":", "")}://)`
+    );
+  }
+}
+__name(assertHttpUrl, "assertHttpUrl");
+function isConnectionRefused(error) {
+  if (error instanceof TypeError) {
+    const cause = error.cause;
+    return cause?.code === "ECONNREFUSED";
+  }
+  return false;
+}
+__name(isConnectionRefused, "isConnectionRefused");
+function connectionRefusedError(host) {
+  return new Error(`Could not connect to Ollama at ${host}. Make sure Ollama is running (ollama serve).`);
+}
+__name(connectionRefusedError, "connectionRefusedError");
+var OllamaProvider = class {
+  static {
+    __name(this, "OllamaProvider");
+  }
+  name = "ollama";
+  label = "Ollama";
+  envVar = OLLAMA_API_KEY_ENV_VAR;
+  apiKey;
+  baseUrl;
+  local;
+  constructor(options) {
+    this.apiKey = options.apiKey?.trim() || void 0;
+    const trimmed = stripTrailingSlashes(options.baseUrl?.trim() ?? "");
+    if (trimmed) assertHttpUrl(trimmed);
+    this.baseUrl = trimmed;
+    this.local = isLocalHost(trimmed);
+  }
+  async search(query, maxResults, signal) {
+    this.requireBaseUrl();
+    const path = this.local ? LOCAL_SEARCH_PATH : CLOUD_SEARCH_PATH;
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ query, max_results: maxResults }),
+        signal
+      });
+      if (!res.ok) throw await this.formatError("Search", res);
+      const raw = await res.json();
+      return { query, results: normalizeOllamaResults(raw) };
+    } catch (error) {
+      if (isConnectionRefused(error)) throw connectionRefusedError(this.baseUrl);
+      throw error;
+    }
+  }
+  async fetch(url, _raw, signal) {
+    this.requireBaseUrl();
+    const path = this.local ? LOCAL_FETCH_PATH : CLOUD_FETCH_PATH;
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ url }),
+        signal
+      });
+      if (!res.ok) throw await this.formatError("Fetch", res);
+      const data = await res.json();
+      if (!data.content) {
+        throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+      }
+      return {
+        text: data.content,
+        title: data.title || void 0,
+        contentType: "text/plain"
+      };
+    } catch (error) {
+      if (isConnectionRefused(error)) throw connectionRefusedError(this.baseUrl);
+      throw error;
+    }
+  }
+  requireBaseUrl() {
+    if (!this.baseUrl) {
+      throw new Error(`${OLLAMA_HOST_ENV_VAR} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+  }
+  buildHeaders() {
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    return headers;
+  }
+  async formatError(label, res) {
+    const body = await res.text();
+    const hint = hintForStatus(res.status);
+    return new Error(`${this.label} ${label} API error (${res.status})${hint}: ${body}`);
+  }
+};
+function hintForStatus(status) {
+  if (status === 401) {
+    return " (run `ollama signin` to authenticate)";
+  }
+  if (status === 404) {
+    return " (the Ollama instance may not support web search; ensure you are running a recent version)";
+  }
+  return "";
+}
+__name(hintForStatus, "hintForStatus");
+function maskKey(key) {
+  const head = key.slice(0, MASK_VISIBLE_CHARS);
+  const tail = key.slice(-MASK_VISIBLE_CHARS);
+  return `${head}...${tail}`;
+}
+__name(maskKey, "maskKey");
+async function promptForBaseUrl(ui, current) {
+  const existing = current?.trim();
+  const input = await ui.input(
+    "Ollama base URL",
+    existing ? `Press Enter to keep current (${existing}), or type new URL` : `Press Enter for default (${OLLAMA_DEFAULT_URL}), or type instance URL`
+  );
+  if (isCancellation(input)) return void 0;
+  return input.trim() || existing || OLLAMA_DEFAULT_URL;
+}
+__name(promptForBaseUrl, "promptForBaseUrl");
+async function promptForOptionalKey(ui, current) {
+  const existing = current?.trim() || void 0;
+  const input = await ui.input(
+    "Ollama API key (optional \u2014 for direct cloud access; local Ollama authenticates via `ollama signin`)",
+    existing ? `Press Enter to keep current (${maskKey(existing)}), or type new key` : "Press Enter to leave unset, or type a key"
+  );
+  if (isCancellation(input)) return void 0;
+  return input.trim() || existing || null;
+}
+__name(promptForOptionalKey, "promptForOptionalKey");
+async function configureOllama(ui, current) {
+  const baseUrl = await promptForBaseUrl(ui, current.baseUrl);
+  if (baseUrl === void 0) return null;
+  const apiKey = await promptForOptionalKey(ui, current.apiKey);
+  if (apiKey === void 0) return null;
+  return { baseUrl, apiKey };
+}
+__name(configureOllama, "configureOllama");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/perplexity.ts?ext=privateer-web
+var PERPLEXITY_API_URL = "https://api.perplexity.ai/search";
+var PERPLEXITY_API_KEY_ENV_VAR = "PERPLEXITY_API_KEY";
+var PERPLEXITY_PROVIDER_META = {
+  name: "perplexity",
+  label: "Perplexity",
+  envVar: PERPLEXITY_API_KEY_ENV_VAR,
+  roles: ["search"]
+};
+function normalizePerplexityResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.snippet ?? ""
+  }));
+}
+__name(normalizePerplexityResults, "normalizePerplexityResults");
+var PerplexityProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "PerplexityProvider");
+  }
+  name = PERPLEXITY_PROVIDER_META.name;
+  label = PERPLEXITY_PROVIDER_META.label;
+  envVar = PERPLEXITY_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(PERPLEXITY_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        query,
+        max_results: maxResults
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizePerplexityResults(raw.results ?? []) };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/searxng.ts?ext=privateer-web
+var SEARXNG_API_KEY_ENV_VAR = "SEARXNG_API_KEY";
+var SEARXNG_URL_ENV_VAR = "SEARXNG_URL";
+var SEARXNG_DEFAULT_URL = "http://localhost:8080";
+var SEARXNG_SEARCH_PATH = "/search";
+var SEARXNG_FORMAT_JSON = "json";
+var SEARXNG_SAFESEARCH_OFF = "0";
+var MASK_VISIBLE_CHARS2 = 4;
+var SEARXNG_PROVIDER_META = {
+  name: "searxng",
+  label: "SearXNG",
+  envVar: SEARXNG_API_KEY_ENV_VAR,
+  baseUrlEnvVar: SEARXNG_URL_ENV_VAR,
+  defaultBaseUrl: SEARXNG_DEFAULT_URL,
+  roles: ["search"],
+  configure: /* @__PURE__ */ __name((ui, current) => configureSearxng(ui, current), "configure")
+};
+function normalizeSearxngResults(raw, maxResults) {
+  return (raw.results ?? []).slice(0, maxResults).map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? ""
+  }));
+}
+__name(normalizeSearxngResults, "normalizeSearxngResults");
+function stripTrailingSlashes2(url) {
+  return url.replace(/\/+$/, "");
+}
+__name(stripTrailingSlashes2, "stripTrailingSlashes");
+function assertHttpUrl2(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`${SEARXNG_URL_ENV_VAR} is not a valid URL (got: ${url})`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `${SEARXNG_URL_ENV_VAR} must use http:// or https:// (got: ${parsed.protocol.replace(":", "")}://)`
+    );
+  }
+}
+__name(assertHttpUrl2, "assertHttpUrl");
+function hintForSearchStatus(status) {
+  if (status === 401) {
+    return ` (the SearXNG instance's reverse-proxy rejected the Bearer token; check ${SEARXNG_API_KEY_ENV_VAR} or apiKeys.searxng)`;
+  }
+  if (status === 403) {
+    return " (the SearXNG instance may have JSON output disabled; enable 'json' under 'search.formats' in its settings.yml)";
+  }
+  return "";
+}
+__name(hintForSearchStatus, "hintForSearchStatus");
+var SearxngProvider = class {
+  static {
+    __name(this, "SearxngProvider");
+  }
+  name = "searxng";
+  label = "SearXNG";
+  envVar = SEARXNG_API_KEY_ENV_VAR;
+  apiKey;
+  baseUrl;
+  constructor(options) {
+    this.apiKey = options.apiKey?.trim() || void 0;
+    const trimmed = stripTrailingSlashes2(options.baseUrl?.trim() ?? "");
+    if (trimmed) assertHttpUrl2(trimmed);
+    this.baseUrl = trimmed;
+  }
+  async search(query, maxResults, signal) {
+    this.requireBaseUrl();
+    const res = await fetch(this.buildSearchUrl(query), {
+      method: "GET",
+      headers: this.buildAuthHeaders(),
+      signal
+    });
+    if (!res.ok) throw await this.searchApiError(res);
+    const raw = await res.json();
+    return { query, results: normalizeSearxngResults(raw, maxResults) };
+  }
+  requireBaseUrl() {
+    if (!this.baseUrl) {
+      throw new Error(`${SEARXNG_URL_ENV_VAR} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+  }
+  // The SearXNG API exposes only `pageno` for pagination, not `count`/`limit`
+  // (https://docs.searxng.org/dev/search_api.html), so we ask for a single
+  // page and slice to maxResults client-side.
+  buildSearchUrl(query) {
+    const url = new URL(`${this.baseUrl}${SEARXNG_SEARCH_PATH}`);
+    url.searchParams.set("q", query);
+    url.searchParams.set("format", SEARXNG_FORMAT_JSON);
+    url.searchParams.set("safesearch", SEARXNG_SAFESEARCH_OFF);
+    return url.toString();
+  }
+  // SearXNG itself has no native auth; the optional Bearer key is for
+  // instances fronted by a reverse-proxy that gates on Authorization.
+  buildAuthHeaders() {
+    const headers = { Accept: "application/json" };
+    if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+    return headers;
+  }
+  async searchApiError(res) {
+    const body = await res.text();
+    return new Error(`${this.label} Search API error (${res.status})${hintForSearchStatus(res.status)}: ${body}`);
+  }
+};
+function maskKey2(key) {
+  const head = key.slice(0, MASK_VISIBLE_CHARS2);
+  const tail = key.slice(-MASK_VISIBLE_CHARS2);
+  return `${head}...${tail}`;
+}
+__name(maskKey2, "maskKey");
+async function promptForBaseUrl2(ui, current) {
+  const existing = current?.trim();
+  const input = await ui.input(
+    "SearXNG base URL",
+    existing ? `Press Enter to keep current (${existing}), or type new URL` : `Press Enter for default (${SEARXNG_DEFAULT_URL}), or type instance URL`
+  );
+  if (isCancellation(input)) return void 0;
+  return input.trim() || existing || SEARXNG_DEFAULT_URL;
+}
+__name(promptForBaseUrl2, "promptForBaseUrl");
+async function promptForOptionalKey2(ui, current) {
+  const existing = current?.trim() || void 0;
+  const input = await ui.input(
+    "SearXNG API key (optional \u2014 for instances behind a Bearer-auth proxy)",
+    existing ? `Press Enter to keep current (${maskKey2(existing)}), or type new key` : "Press Enter to leave unset, or type a key"
+  );
+  if (isCancellation(input)) return void 0;
+  return input.trim() || existing || null;
+}
+__name(promptForOptionalKey2, "promptForOptionalKey");
+async function configureSearxng(ui, current) {
+  const baseUrl = await promptForBaseUrl2(ui, current.baseUrl);
+  if (baseUrl === void 0) return null;
+  const apiKey = await promptForOptionalKey2(ui, current.apiKey);
+  if (apiKey === void 0) return null;
+  return { baseUrl, apiKey };
+}
+__name(configureSearxng, "configureSearxng");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/serper.ts?ext=privateer-web
+var SERPER_API_URL = "https://google.serper.dev/search";
+var SERPER_API_KEY_ENV_VAR = "SERPER_API_KEY";
+var SERPER_PROVIDER_META = {
+  name: "serper",
+  label: "Serper",
+  envVar: SERPER_API_KEY_ENV_VAR,
+  roles: ["search"]
+};
+function normalizeSerperResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.link ?? "",
+    snippet: r.snippet ?? ""
+  }));
+}
+__name(normalizeSerperResults, "normalizeSerperResults");
+var SerperProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "SerperProvider");
+  }
+  name = SERPER_PROVIDER_META.name;
+  label = SERPER_PROVIDER_META.label;
+  envVar = SERPER_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(SERPER_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-KEY": this.apiKey
+      },
+      body: JSON.stringify({
+        q: query,
+        num: maxResults
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeSerperResults(raw.organic ?? []) };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/tavily.ts?ext=privateer-web
+var TAVILY_API_URL = "https://api.tavily.com/search";
+var TAVILY_EXTRACT_API_URL = "https://api.tavily.com/extract";
+var TAVILY_API_KEY_ENV_VAR = "TAVILY_API_KEY";
+var TAVILY_PROVIDER_META = {
+  name: "tavily",
+  label: "Tavily",
+  envVar: TAVILY_API_KEY_ENV_VAR,
+  roles: ["search", "fetch"]
+};
+function normalizeTavilyResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.content ?? ""
+  }));
+}
+__name(normalizeTavilyResults, "normalizeTavilyResults");
+var TavilyProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "TavilyProvider");
+  }
+  name = TAVILY_PROVIDER_META.name;
+  label = TAVILY_PROVIDER_META.label;
+  envVar = TAVILY_PROVIDER_META.envVar;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(TAVILY_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        api_key: this.apiKey,
+        query,
+        max_results: maxResults
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeTavilyResults(raw.results ?? []) };
+  }
+  async fetch(url, _raw, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(TAVILY_EXTRACT_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        urls: [url]
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Fetch API error (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    if (data.failed_results && data.failed_results.length > 0) {
+      const failed = data.failed_results[0];
+      throw new Error(
+        `${this.label} Fetch API error: extraction failed for ${failed.url ?? url}: ${failed.error ?? "unknown error"}`
+      );
+    }
+    const result = data.results?.[0];
+    if (!result?.raw_content) {
+      throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+    }
+    return {
+      text: result.raw_content,
+      contentType: "text/plain"
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/youcom.ts?ext=privateer-web
+var YOUCOM_SEARCH_URL = "https://ydc-index.io/v1/search";
+var YOUCOM_CONTENTS_URL = "https://ydc-index.io/v1/contents";
+var YOUCOM_API_KEY_ENV_VAR = "YOUCOM_API_KEY";
+var YOUCOM_PROVIDER_META = {
+  name: "youcom",
+  label: "You.com",
+  envVar: YOUCOM_API_KEY_ENV_VAR,
+  roles: ["search", "fetch"]
+};
+function normalizeYouComResults(results) {
+  return results.map((r) => ({
+    title: r.title ?? "",
+    url: r.url ?? "",
+    snippet: r.snippets?.[0] ?? r.description ?? ""
+  }));
+}
+__name(normalizeYouComResults, "normalizeYouComResults");
+var YouComProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  static {
+    __name(this, "YouComProvider");
+  }
+  name = YOUCOM_PROVIDER_META.name;
+  label = YOUCOM_PROVIDER_META.label;
+  envVar = YOUCOM_API_KEY_ENV_VAR;
+  async search(query, maxResults, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(YOUCOM_SEARCH_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify({
+        query,
+        count: maxResults
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Search API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    return { query, results: normalizeYouComResults(raw.results?.web ?? []) };
+  }
+  async fetch(url, _raw, signal) {
+    if (!this.apiKey) {
+      throw new Error(`${this.envVar} is not set. Run /web-tools to configure, or export the env var.`);
+    }
+    const res = await fetch(YOUCOM_CONTENTS_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify({
+        urls: [url],
+        formats: ["markdown"]
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${this.label} Fetch API error (${res.status}): ${text}`);
+    }
+    const raw = await res.json();
+    const item = raw[0];
+    if (!item?.markdown) {
+      throw new Error(`${this.label} Fetch API error: no content returned for ${url}`);
+    }
+    return {
+      text: item.markdown,
+      title: item.title || void 0,
+      contentType: "text/markdown"
+    };
+  }
+};
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/factory.ts?ext=privateer-web
+function createSearchProvider(name, creds) {
+  const apiKey = creds.apiKey ?? "";
+  switch (name) {
+    case "brave":
+      return new BraveProvider(apiKey);
+    case "tavily":
+      return new TavilyProvider(apiKey);
+    case "serper":
+      return new SerperProvider(apiKey);
+    case "exa":
+      return new ExaProvider(apiKey);
+    case "youcom":
+      return new YouComProvider(apiKey);
+    case "jina":
+      return new JinaProvider(apiKey);
+    case "firecrawl":
+      return new FirecrawlProvider(apiKey);
+    case "perplexity":
+      return new PerplexityProvider(apiKey);
+    case "searxng":
+      return new SearxngProvider({ apiKey: creds.apiKey, baseUrl: creds.baseUrl ?? "" });
+    case "ollama":
+      return new OllamaProvider({ apiKey: creds.apiKey, baseUrl: creds.baseUrl ?? "" });
+    default:
+      throw new Error(`Unknown search provider: "${name}"`);
+  }
+}
+__name(createSearchProvider, "createSearchProvider");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/interceptors/github.ts?ext=privateer-web
+import { execFile } from "node:child_process";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  readSync,
+  realpathSync,
+  rmSync,
+  statSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { extname, join as join2, sep as pathSep, resolve as resolvePath } from "node:path";
+
+// node_modules/@juicesharp/rpiv-config/config.ts?ext=privateer-web
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+function expandTilde(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  return p;
+}
+__name(expandTilde, "expandTilde");
+function defaultConfigDir() {
+  return join(homedir(), ".config");
+}
+__name(defaultConfigDir, "defaultConfigDir");
+function resolveConfigDir() {
+  const xdg = readEnvVar("XDG_CONFIG_HOME");
+  if (!xdg) return defaultConfigDir();
+  const expanded = expandTilde(xdg);
+  return isAbsolute(expanded) ? expanded : defaultConfigDir();
+}
+__name(resolveConfigDir, "resolveConfigDir");
+function legacyConfigPath(name, file = "config.json") {
+  return join(defaultConfigDir(), name, file);
+}
+__name(legacyConfigPath, "legacyConfigPath");
+function configPath(name, file = "config.json") {
+  return join(resolveConfigDir(), name, file);
+}
+__name(configPath, "configPath");
+function loadJsonConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch (err) {
+    console.warn(`rpiv-config: invalid JSON at ${path}, using default ({}) \u2014 ${err.message}`);
+    return {};
+  }
+}
+__name(loadJsonConfig, "loadJsonConfig");
+function loadJsonConfigWithLegacyFallback(name, file = "config.json") {
+  const xdgPath = configPath(name, file);
+  if (existsSync(xdgPath)) {
+    return loadJsonConfig(xdgPath);
+  }
+  return loadJsonConfig(legacyConfigPath(name, file));
+}
+__name(loadJsonConfigWithLegacyFallback, "loadJsonConfigWithLegacyFallback");
+var CONFIG_FILE_MODE = 384;
+function saveJsonConfig(path, data) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
+  } catch {
+    return false;
+  }
+  try {
+    chmodSync(path, CONFIG_FILE_MODE);
+  } catch {
+  }
+  return true;
+}
+__name(saveJsonConfig, "saveJsonConfig");
+var GuidanceFieldsSchema = typebox_exports.Object(
+  {
+    promptSnippet: typebox_exports.Optional(typebox_exports.String()),
+    promptGuidelines: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String())),
+    description: typebox_exports.Optional(typebox_exports.String())
+  },
+  { additionalProperties: true }
+);
+function validateGuidanceFields(fields) {
+  if (!fields || typeof fields !== "object") return {};
+  const g = fields;
+  const result = {};
+  if (typeof g.promptSnippet === "string" && g.promptSnippet.length > 0) {
+    result.promptSnippet = g.promptSnippet;
+  }
+  if (Array.isArray(g.promptGuidelines) && g.promptGuidelines.length > 0 && g.promptGuidelines.every((s) => typeof s === "string" && s.length > 0)) {
+    result.promptGuidelines = g.promptGuidelines;
+  }
+  if (typeof g.description === "string" && g.description.length > 0) {
+    result.description = g.description;
+  }
+  return result;
+}
+__name(validateGuidanceFields, "validateGuidanceFields");
+function readEnvVar(key, fallback) {
+  return process.env[key]?.trim() || fallback;
+}
+__name(readEnvVar, "readEnvVar");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/config.ts?ext=privateer-web
+var WebToolsGuidanceSchema = typebox_exports.Object(
+  {
+    web_search: typebox_exports.Optional(GuidanceFieldsSchema),
+    web_fetch: typebox_exports.Optional(GuidanceFieldsSchema)
+  },
+  { additionalProperties: true }
+);
+var GitHubInterceptorOptionsSchema = typebox_exports.Object(
+  {
+    enabled: typebox_exports.Optional(typebox_exports.Boolean()),
+    maxRepoSizeMB: typebox_exports.Optional(typebox_exports.Number()),
+    cloneTimeoutSeconds: typebox_exports.Optional(typebox_exports.Number()),
+    clonePath: typebox_exports.Optional(typebox_exports.String())
+  },
+  { additionalProperties: true }
+);
+var InterceptorsConfigSchema = typebox_exports.Object(
+  {
+    // Boolean shorthand or per-field overrides. `enabled: false` inside the
+    // object form is allowed but redundant — use the top-level `false`.
+    github: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Boolean(), GitHubInterceptorOptionsSchema]))
+  },
+  { additionalProperties: true }
+);
+var WebToolsConfigSchema = typebox_exports.Object(
+  {
+    provider: typebox_exports.Optional(typebox_exports.String()),
+    apiKeys: typebox_exports.Optional(typebox_exports.Record(typebox_exports.String(), typebox_exports.String())),
+    baseUrls: typebox_exports.Optional(typebox_exports.Record(typebox_exports.String(), typebox_exports.String())),
+    // Legacy top-level Brave key. Auto-migrated to `apiKeys.brave` by the
+    // /web-tools save path — kept here for the load+rewrite round-trip.
+    apiKey: typebox_exports.Optional(typebox_exports.String()),
+    guidance: typebox_exports.Optional(WebToolsGuidanceSchema),
+    interceptors: typebox_exports.Optional(InterceptorsConfigSchema)
+  },
+  { additionalProperties: true }
+);
+var CONFIG_PATH = configPath("rpiv-web-tools");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+__name(getConfigPath, "getConfigPath");
+var pointerSegments = /* @__PURE__ */ __name((instancePath) => instancePath === "" ? [] : instancePath.split("/").slice(1).map((s) => s.replaceAll("~1", "/").replaceAll("~0", "~")), "pointerSegments");
+var deleteAtPointer = /* @__PURE__ */ __name((root, segs) => {
+  let parent = root;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const next = parent[segs[i]];
+    if (next === null || typeof next !== "object") return false;
+    if (Array.isArray(next)) {
+      delete parent[segs[i]];
+      return true;
+    }
+    parent = next;
+  }
+  const leaf = segs[segs.length - 1];
+  if (!(leaf in parent)) return false;
+  delete parent[leaf];
+  return true;
+}, "deleteAtPointer");
+var salvageConfig = /* @__PURE__ */ __name((raw) => {
+  const cfg = structuredClone(raw);
+  for (let pass = 0; pass < 5; pass++) {
+    const errors = [...value_exports.Errors(WebToolsConfigSchema, cfg)];
+    if (errors.length === 0) return cfg;
+    let deleted = false;
+    for (const e of errors) {
+      const segs = pointerSegments(e.instancePath);
+      if (segs.length === 0) return void 0;
+      if (deleteAtPointer(cfg, segs)) deleted = true;
+    }
+    if (!deleted) return void 0;
+  }
+  return value_exports.Check(WebToolsConfigSchema, cfg) ? cfg : void 0;
+}, "salvageConfig");
+function readConfig() {
+  const raw = loadJsonConfigWithLegacyFallback("rpiv-web-tools");
+  if (value_exports.Check(WebToolsConfigSchema, raw)) return raw;
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+  return salvageConfig(raw) ?? {};
+}
+__name(readConfig, "readConfig");
+function writeConfig(c) {
+  return saveJsonConfig(CONFIG_PATH, c);
+}
+__name(writeConfig, "writeConfig");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/interceptors/github.ts?ext=privateer-web
+var GITHUB_TOKEN_ENV_VAR = "GITHUB_TOKEN";
+var MAX_TREE_ENTRIES = 200;
+var MAX_INLINE_FILE_CHARS = 1e5;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".tiff",
+  ".tif",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".flv",
+  ".wmv",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".flac",
+  ".aac",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".zst",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".o",
+  ".a",
+  ".lib",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".sqlite",
+  ".db",
+  ".sqlite3",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".jar",
+  ".war",
+  ".iso",
+  ".img",
+  ".dmg"
+]);
+var NOISE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "vendor",
+  ".next",
+  "dist",
+  "build",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  "target",
+  ".gradle",
+  ".idea",
+  ".vscode"
+]);
+var NON_CODE_SEGMENTS = /* @__PURE__ */ new Set([
+  "issues",
+  "pull",
+  "pulls",
+  "discussions",
+  "releases",
+  "wiki",
+  "actions",
+  "settings",
+  "security",
+  "projects",
+  "graphs",
+  "compare",
+  "commits",
+  "tags",
+  "branches",
+  "stargazers",
+  "watchers",
+  "network",
+  "forks",
+  "milestone",
+  "labels",
+  "packages",
+  "codespaces",
+  "contribute",
+  "community",
+  "sponsors",
+  "invitations",
+  "notifications",
+  "insights"
+]);
+function parseGitHubUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host !== "github.com" && host !== "www.github.com") return null;
+  const segments = parsed.pathname.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  });
+  if (segments.length < 2) return null;
+  const owner = segments[0];
+  const repo = segments[1].replace(/\.git$/, "");
+  if (NON_CODE_SEGMENTS.has(segments[2]?.toLowerCase())) return null;
+  if (segments.length === 2) {
+    return { owner, repo, refIsFullSha: false, type: "root" };
+  }
+  const action = segments[2];
+  if (action !== "blob" && action !== "tree") return null;
+  if (segments.length < 4) return null;
+  const ref = segments[3];
+  const refIsFullSha = /^[0-9a-f]{40}$/.test(ref);
+  const pathParts = segments.slice(4);
+  const path = pathParts.length > 0 ? pathParts.join("/") : "";
+  return { owner, repo, ref, refIsFullSha, path, type: action };
+}
+__name(parseGitHubUrl, "parseGitHubUrl");
+var DEFAULTS = {
+  enabled: false,
+  maxRepoSizeMB: 350,
+  cloneTimeoutSeconds: 30,
+  clonePath: join2(tmpdir(), "pi-github-repos")
+};
+function resolveGitHubOptions(userConfig, consumerDefault) {
+  if (userConfig === false) return { ...DEFAULTS, enabled: false };
+  if (userConfig === true) return { ...DEFAULTS, enabled: true };
+  if (userConfig && typeof userConfig === "object") {
+    const enabled = userConfig.enabled ?? true;
+    return {
+      enabled,
+      maxRepoSizeMB: userConfig.maxRepoSizeMB ?? DEFAULTS.maxRepoSizeMB,
+      cloneTimeoutSeconds: userConfig.cloneTimeoutSeconds ?? DEFAULTS.cloneTimeoutSeconds,
+      clonePath: userConfig.clonePath ?? DEFAULTS.clonePath
+    };
+  }
+  if (consumerDefault === true) return { ...DEFAULTS, enabled: true };
+  return { ...DEFAULTS };
+}
+__name(resolveGitHubOptions, "resolveGitHubOptions");
+function readUserGitHubConfig() {
+  return readConfig().interceptors?.github;
+}
+__name(readUserGitHubConfig, "readUserGitHubConfig");
+function cacheKey(owner, repo, ref) {
+  return ref ? `${owner}/${repo}@${ref}` : `${owner}/${repo}`;
+}
+__name(cacheKey, "cacheKey");
+function cloneDir(clonePath, owner, repo, ref) {
+  const dirName = ref ? `${repo}@${ref}` : repo;
+  return join2(clonePath, owner, dirName);
+}
+__name(cloneDir, "cloneDir");
+var GitHubInterceptor = class {
+  static {
+    __name(this, "GitHubInterceptor");
+  }
+  name = "github";
+  options;
+  ghAvailable = null;
+  ghHintShown = false;
+  cloneCache;
+  constructor(opts = {}) {
+    const { cloneCache, ...rest } = opts;
+    this.options = resolveGitHubOptions(rest, void 0);
+    this.cloneCache = cloneCache ?? /* @__PURE__ */ new Map();
+  }
+  get resolvedOptions() {
+    return this.options;
+  }
+  async intercept(url, opts) {
+    return this.fetchGitHub(url, opts.signal, opts.forceClone);
+  }
+  /** @internal — exposed for direct unit testing of the gh-availability probe. */
+  async checkGhAvailable() {
+    if (this.ghAvailable !== null) return this.ghAvailable;
+    return new Promise((resolve) => {
+      execFile("gh", ["--version"], { timeout: 5e3 }, (err) => {
+        this.ghAvailable = !err;
+        resolve(this.ghAvailable);
+      });
+    });
+  }
+  /** @internal — exposed for direct unit testing of the repo-size probe. */
+  async checkRepoSize(owner, repo) {
+    if (!await this.checkGhAvailable()) return null;
+    return new Promise((resolve) => {
+      execFile("gh", ["api", `repos/${owner}/${repo}`, "--jq", ".size"], { timeout: 1e4 }, (err, stdout) => {
+        if (err) {
+          resolve(null);
+          return;
+        }
+        const kb = parseInt(stdout.trim(), 10);
+        resolve(Number.isNaN(kb) ? null : kb);
+      });
+    });
+  }
+  /**
+   * Injects an entry into the clone cache — for testing generateCloneContent
+   * without running a real git clone. Never call in production.
+   * @internal
+   */
+  _seedCache(key, entry) {
+    this.cloneCache.set(key, entry);
+  }
+  /**
+   * Clears the in-memory clone cache and removes all cloned directories.
+   * Also resets the gh-availability probe so the next intercept re-checks.
+   * @internal
+   */
+  reset() {
+    for (const entry of this.cloneCache.values()) {
+      try {
+        rmSync(entry.localPath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    this.cloneCache.clear();
+    this.ghAvailable = null;
+    this.ghHintShown = false;
+  }
+  showGhHint() {
+    if (!this.ghHintShown) {
+      this.ghHintShown = true;
+      console.error("[rpiv-web-tools] Install `gh` CLI for better GitHub repo access including private repos.");
+    }
+  }
+  async getDefaultBranch(owner, repo) {
+    if (!await this.checkGhAvailable()) return null;
+    return new Promise((resolve) => {
+      execFile(
+        "gh",
+        ["api", `repos/${owner}/${repo}`, "--jq", ".default_branch"],
+        { timeout: 1e4 },
+        (err, stdout) => {
+          if (err) {
+            resolve(null);
+            return;
+          }
+          resolve(stdout.trim() || null);
+        }
+      );
+    });
+  }
+  async fetchTreeViaApi(owner, repo, ref) {
+    if (!await this.checkGhAvailable()) return null;
+    return new Promise((resolve) => {
+      execFile(
+        "gh",
+        ["api", `repos/${owner}/${repo}/git/trees/${ref}?recursive=1`, "--jq", ".tree[].path"],
+        { timeout: 15e3, maxBuffer: 5 * 1024 * 1024 },
+        (err, stdout) => {
+          if (err) {
+            resolve(null);
+            return;
+          }
+          const paths = stdout.trim().split("\n").filter(Boolean);
+          if (paths.length === 0) {
+            resolve(null);
+            return;
+          }
+          const truncated = paths.length > MAX_TREE_ENTRIES;
+          const display = paths.slice(0, MAX_TREE_ENTRIES).join("\n");
+          resolve(truncated ? `${display}
+... (${paths.length} total entries)` : display);
+        }
+      );
+    });
+  }
+  async fetchReadmeViaApi(owner, repo, ref) {
+    if (!await this.checkGhAvailable()) return null;
+    return new Promise((resolve) => {
+      execFile(
+        "gh",
+        ["api", `repos/${owner}/${repo}/readme?ref=${ref}`, "--jq", ".content"],
+        { timeout: 1e4 },
+        (err, stdout) => {
+          if (err) {
+            resolve(null);
+            return;
+          }
+          try {
+            const decoded = Buffer.from(stdout.trim(), "base64").toString("utf-8");
+            resolve(
+              decoded.length > 8192 ? `${decoded.slice(0, 8192)}
+
+[README truncated at 8K chars]` : decoded
+            );
+          } catch {
+            resolve(null);
+          }
+        }
+      );
+    });
+  }
+  async fetchFileViaApi(owner, repo, path, ref) {
+    if (!await this.checkGhAvailable()) return null;
+    return new Promise((resolve) => {
+      execFile(
+        "gh",
+        ["api", `repos/${owner}/${repo}/contents/${path}?ref=${ref}`, "--jq", ".content"],
+        { timeout: 1e4, maxBuffer: 2 * 1024 * 1024 },
+        (err, stdout) => {
+          if (err) {
+            resolve(null);
+            return;
+          }
+          try {
+            resolve(Buffer.from(stdout.trim(), "base64").toString("utf-8"));
+          } catch {
+            resolve(null);
+          }
+        }
+      );
+    });
+  }
+  async fetchViaApi(_url, owner, repo, info, sizeNote) {
+    const ref = info.ref || await this.getDefaultBranch(owner, repo);
+    if (!ref) return null;
+    const lines = [];
+    if (sizeNote) {
+      lines.push(sizeNote);
+      lines.push("");
+    }
+    if (info.type === "blob" && info.path) {
+      const content = await this.fetchFileViaApi(owner, repo, info.path, ref);
+      if (!content) return null;
+      lines.push(`## ${info.path}`);
+      if (content.length > MAX_INLINE_FILE_CHARS) {
+        lines.push(content.slice(0, MAX_INLINE_FILE_CHARS));
+        lines.push("\n[File truncated at 100K chars]");
+      } else {
+        lines.push(content);
+      }
+      const title2 = `${owner}/${repo} - ${info.path}`;
+      return { text: lines.join("\n"), title: title2, contentType: "text/plain" };
+    }
+    const [tree, readme] = await Promise.all([
+      this.fetchTreeViaApi(owner, repo, ref),
+      this.fetchReadmeViaApi(owner, repo, ref)
+    ]);
+    if (!tree && !readme) return null;
+    if (tree) {
+      lines.push("## Structure");
+      lines.push(tree);
+      lines.push("");
+    }
+    if (readme) {
+      lines.push("## README.md");
+      lines.push(readme);
+      lines.push("");
+    }
+    lines.push("This is an API-only view. Clone the repo or use `read`/`bash` for deeper exploration.");
+    const title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+    return { text: lines.join("\n"), title, contentType: "text/plain" };
+  }
+  execClone(args, localPath, timeoutMs, signal) {
+    return new Promise((resolve) => {
+      const child = execFile(args[0], args.slice(1), { timeout: timeoutMs }, (err) => {
+        if (err) {
+          try {
+            rmSync(localPath, { recursive: true, force: true });
+          } catch {
+          }
+          resolve(null);
+          return;
+        }
+        resolve(localPath);
+      });
+      if (signal) {
+        const onAbort = /* @__PURE__ */ __name(() => child.kill(), "onAbort");
+        signal.addEventListener("abort", onAbort, { once: true });
+        child.on("exit", () => signal.removeEventListener("abort", onAbort));
+      }
+    });
+  }
+  async cloneRepo(owner, repo, ref, signal) {
+    const localPath = cloneDir(this.options.clonePath, owner, repo, ref);
+    try {
+      rmSync(localPath, { recursive: true, force: true });
+    } catch {
+    }
+    const timeoutMs = this.options.cloneTimeoutSeconds * 1e3;
+    const hasGh = await this.checkGhAvailable();
+    if (hasGh) {
+      const args2 = ["gh", "repo", "clone", `${owner}/${repo}`, localPath, "--", "--depth", "1", "--single-branch"];
+      if (ref) args2.push("--branch", ref);
+      return this.execClone(args2, localPath, timeoutMs, signal);
+    }
+    this.showGhHint();
+    const gitUrl = `https://github.com/${owner}/${repo}.git`;
+    const args = ["git", "clone", "--depth", "1", "--single-branch"];
+    if (ref) args.push("--branch", ref);
+    args.push(gitUrl, localPath);
+    return this.execClone(args, localPath, timeoutMs, signal);
+  }
+  async awaitCachedClone(cached, url, owner, repo, info, signal) {
+    if (signal?.aborted) return null;
+    const result = await cached.clonePromise;
+    if (signal?.aborted) return null;
+    if (result) {
+      const text = generateCloneContent(result, info);
+      const title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+      return { text, title, contentType: "text/plain" };
+    }
+    return this.fetchViaApi(url, owner, repo, info);
+  }
+  async fetchGitHub(url, signal, forceClone) {
+    const info = parseGitHubUrl(url);
+    if (!info) return null;
+    if (signal?.aborted) return null;
+    if (!this.options.enabled) return null;
+    const { owner, repo } = info;
+    const key = cacheKey(owner, repo, info.ref);
+    const cached = this.cloneCache.get(key);
+    if (cached) return this.awaitCachedClone(cached, url, owner, repo, info, signal);
+    if (info.refIsFullSha) {
+      if (signal?.aborted) return null;
+      const sizeNote = "Note: Commit SHA URLs use the GitHub API instead of cloning.";
+      return this.fetchViaApi(url, owner, repo, info, sizeNote);
+    }
+    if (!forceClone) {
+      const sizeKB = await this.checkRepoSize(owner, repo);
+      if (signal?.aborted) return null;
+      if (sizeKB !== null) {
+        const sizeMB = sizeKB / 1024;
+        if (sizeMB > this.options.maxRepoSizeMB) {
+          if (signal?.aborted) return null;
+          const sizeNote = `Note: Repository is ${Math.round(sizeMB)}MB (threshold: ${this.options.maxRepoSizeMB}MB). Showing API-fetched content instead of full clone. Ask the user if they'd like to clone the full repo \u2014 if yes, call web_fetch again with the same URL.`;
+          const apiView = await this.fetchViaApi(url, owner, repo, info, sizeNote);
+          if (apiView) return apiView;
+          return null;
+        }
+      }
+    }
+    if (signal?.aborted) return null;
+    const cachedAfterCheck = this.cloneCache.get(key);
+    if (cachedAfterCheck) return this.awaitCachedClone(cachedAfterCheck, url, owner, repo, info, signal);
+    const clonePromise = this.cloneRepo(owner, repo, info.ref, signal);
+    const localPath = cloneDir(this.options.clonePath, owner, repo, info.ref);
+    this.cloneCache.set(key, { localPath, clonePromise });
+    const result = await clonePromise;
+    if (signal?.aborted) {
+      if (!result) this.cloneCache.delete(key);
+      return null;
+    }
+    if (!result) {
+      this.cloneCache.delete(key);
+      if (signal?.aborted) return null;
+      return this.fetchViaApi(url, owner, repo, info);
+    }
+    const text = generateCloneContent(result, info);
+    const title = info.path ? `${owner}/${repo} - ${info.path}` : `${owner}/${repo}`;
+    return { text, title, contentType: "text/plain" };
+  }
+};
+function isBinaryFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) return true;
+  let fd;
+  try {
+    fd = openSync(filePath, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const buf = Buffer.alloc(512);
+    const bytesRead = readSync(fd, buf, 0, 512, 0);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buf[i] === 0) return true;
+    }
+  } catch {
+    return false;
+  } finally {
+    closeSync(fd);
+  }
+  return false;
+}
+__name(isBinaryFile, "isBinaryFile");
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+__name(formatFileSize, "formatFileSize");
+function resolveWithinRepo(rootPath, relativePath) {
+  const normalizedRoot = resolvePath(rootPath);
+  const candidate = resolvePath(normalizedRoot, relativePath);
+  if (candidate !== normalizedRoot) {
+    const rootPrefix = normalizedRoot.endsWith(pathSep) ? normalizedRoot : normalizedRoot + pathSep;
+    if (!candidate.startsWith(rootPrefix)) return null;
+  }
+  if (!existsSync2(candidate)) return candidate;
+  try {
+    const realRoot = realpathSync(normalizedRoot);
+    const realCandidate = realpathSync(candidate);
+    if (realCandidate === realRoot) return candidate;
+    const realRootPrefix = realRoot.endsWith(pathSep) ? realRoot : realRoot + pathSep;
+    return realCandidate.startsWith(realRootPrefix) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+__name(resolveWithinRepo, "resolveWithinRepo");
+function buildTree(rootPath) {
+  const entries = [];
+  function walk(dir, relPath) {
+    if (entries.length >= MAX_TREE_ENTRIES) return;
+    let items;
+    try {
+      items = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (entries.length >= MAX_TREE_ENTRIES) return;
+      if (item === ".git") continue;
+      const rel = relPath ? `${relPath}/${item}` : item;
+      const safePath = resolveWithinRepo(rootPath, rel);
+      if (!safePath) {
+        entries.push(`${rel}  [outside repo skipped]`);
+        continue;
+      }
+      let stat;
+      try {
+        stat = statSync(safePath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (NOISE_DIRS.has(item)) {
+          entries.push(`${rel}/  [skipped]`);
+          continue;
+        }
+        entries.push(`${rel}/`);
+        walk(safePath, rel);
+      } else {
+        entries.push(rel);
+      }
+    }
+  }
+  __name(walk, "walk");
+  walk(rootPath, "");
+  if (entries.length >= MAX_TREE_ENTRIES) {
+    entries.push(`... (truncated at ${MAX_TREE_ENTRIES} entries)`);
+  }
+  return entries.join("\n");
+}
+__name(buildTree, "buildTree");
+function buildDirListing(rootPath, subPath) {
+  const targetPath = resolveWithinRepo(rootPath, subPath);
+  if (!targetPath) return "(path escapes repository root)";
+  const lines = [];
+  let items;
+  try {
+    items = readdirSync(targetPath).sort();
+  } catch {
+    return "(directory not readable)";
+  }
+  for (const item of items) {
+    if (item === ".git") continue;
+    const rel = subPath ? `${subPath}/${item}` : item;
+    const safePath = resolveWithinRepo(rootPath, rel);
+    if (!safePath) {
+      lines.push(`  ${item}  (outside repo)`);
+      continue;
+    }
+    try {
+      const stat = statSync(safePath);
+      lines.push(stat.isDirectory() ? `  ${item}/` : `  ${item}  (${formatFileSize(stat.size)})`);
+    } catch {
+      lines.push(`  ${item}  (unreadable)`);
+    }
+  }
+  return lines.join("\n");
+}
+__name(buildDirListing, "buildDirListing");
+function readReadme(localPath) {
+  const candidates = ["README.md", "readme.md", "README", "README.txt", "README.rst"];
+  for (const name of candidates) {
+    const readmePath = join2(localPath, name);
+    if (existsSync2(readmePath)) {
+      try {
+        const content = readFileSync2(readmePath, "utf-8");
+        return content.length > 8192 ? `${content.slice(0, 8192)}
+
+[README truncated at 8K chars]` : content;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+__name(readReadme, "readReadme");
+function generateCloneContent(localPath, info) {
+  const lines = [];
+  lines.push(`Repository cloned to: ${localPath}`);
+  lines.push("");
+  if (info.type === "root") {
+    lines.push("## Structure");
+    lines.push(buildTree(localPath));
+    lines.push("");
+    const readme = readReadme(localPath);
+    if (readme) {
+      lines.push("## README.md");
+      lines.push(readme);
+      lines.push("");
+    }
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  if (info.type === "tree") {
+    const dirPath = info.path || "";
+    const fullDirPath = resolveWithinRepo(localPath, dirPath);
+    if (!fullDirPath || !existsSync2(fullDirPath)) {
+      lines.push(`Path \`${dirPath}\` not found in clone. Showing repository root instead.`);
+      lines.push("");
+      lines.push("## Structure");
+      lines.push(buildTree(localPath));
+    } else {
+      lines.push(`## ${dirPath || "/"}`);
+      lines.push(buildDirListing(localPath, dirPath));
+    }
+    lines.push("");
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  const filePath = info.path || "";
+  const fullFilePath = resolveWithinRepo(localPath, filePath);
+  if (!fullFilePath || !existsSync2(fullFilePath)) {
+    lines.push(`Path \`${filePath}\` not found in clone. Showing repository root instead.`);
+    lines.push("");
+    lines.push("## Structure");
+    lines.push(buildTree(localPath));
+    lines.push("");
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  let stat;
+  try {
+    stat = statSync(fullFilePath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    lines.push(`Could not inspect \`${filePath}\`: ${message}`);
+    lines.push("");
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  if (stat.isDirectory()) {
+    lines.push(`## ${filePath || "/"}`);
+    lines.push(buildDirListing(localPath, filePath));
+    lines.push("");
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  if (isBinaryFile(fullFilePath)) {
+    const ext = extname(filePath).replace(".", "");
+    lines.push(`## ${filePath}`);
+    lines.push(
+      `Binary file (${ext}, ${formatFileSize(stat.size)}). Use \`read\` or \`bash\` tools at the path above to inspect.`
+    );
+    return lines.join("\n");
+  }
+  let content;
+  try {
+    content = readFileSync2(fullFilePath, "utf-8");
+  } catch {
+    lines.push(`Could not read \`${filePath}\` as UTF-8 text.`);
+    lines.push("");
+    lines.push("Use `read` and `bash` tools at the path above to explore further.");
+    return lines.join("\n");
+  }
+  lines.push(`## ${filePath}`);
+  if (content.length > MAX_INLINE_FILE_CHARS) {
+    lines.push(content.slice(0, MAX_INLINE_FILE_CHARS));
+    lines.push(`
+[File truncated at 100K chars. Full file: ${fullFilePath}]`);
+  } else {
+    lines.push(content);
+  }
+  lines.push("");
+  lines.push("Use `read` and `bash` tools at the path above to explore further.");
+  return lines.join("\n");
+}
+__name(generateCloneContent, "generateCloneContent");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/interceptors/index.ts?ext=privateer-web
+var activeInterceptors = [];
+var activeGitHubInterceptor = null;
+function buildInterceptors(consumer) {
+  const userCfg = readUserGitHubConfig();
+  const resolved = resolveGitHubOptions(userCfg, consumer?.github);
+  if (resolved.enabled) {
+    activeGitHubInterceptor = new GitHubInterceptor(resolved);
+    activeInterceptors = [activeGitHubInterceptor];
+  } else {
+    activeGitHubInterceptor = null;
+    activeInterceptors = [];
+  }
+  return activeInterceptors;
+}
+__name(buildInterceptors, "buildInterceptors");
+function getInterceptors() {
+  return activeInterceptors;
+}
+__name(getInterceptors, "getInterceptors");
+function getActiveGitHubInterceptor() {
+  return activeGitHubInterceptor;
+}
+__name(getActiveGitHubInterceptor, "getActiveGitHubInterceptor");
+function clearCloneCache() {
+  activeGitHubInterceptor?.reset();
+}
+__name(clearCloneCache, "clearCloneCache");
+
+// node_modules/@juicesharp/rpiv-web-tools/providers/index.ts?ext=privateer-web
+var PROVIDERS = [
+  BRAVE_PROVIDER_META,
+  TAVILY_PROVIDER_META,
+  SERPER_PROVIDER_META,
+  EXA_PROVIDER_META,
+  YOUCOM_PROVIDER_META,
+  JINA_PROVIDER_META,
+  FIRECRAWL_PROVIDER_META,
+  PERPLEXITY_PROVIDER_META,
+  SEARXNG_PROVIDER_META,
+  OLLAMA_PROVIDER_META
+];
+
+export {
+  validateGuidanceFields,
+  getConfigPath,
+  readConfig,
+  writeConfig,
+  GITHUB_TOKEN_ENV_VAR,
+  parseGitHubUrl,
+  resolveGitHubOptions,
+  GitHubInterceptor,
+  buildInterceptors,
+  getInterceptors,
+  getActiveGitHubInterceptor,
+  clearCloneCache,
+  BRAVE_API_KEY_ENV_VAR,
+  BRAVE_PROVIDER_META,
+  BraveProvider,
+  EXA_API_KEY_ENV_VAR,
+  EXA_PROVIDER_META,
+  ExaProvider,
+  FIRECRAWL_API_KEY_ENV_VAR,
+  FIRECRAWL_PROVIDER_META,
+  FirecrawlProvider,
+  JINA_API_KEY_ENV_VAR,
+  JINA_PROVIDER_META,
+  JinaProvider,
+  OLLAMA_API_KEY_ENV_VAR,
+  OLLAMA_HOST_ENV_VAR,
+  OLLAMA_DEFAULT_URL,
+  OLLAMA_PROVIDER_META,
+  OllamaProvider,
+  configureOllama,
+  PERPLEXITY_API_KEY_ENV_VAR,
+  PERPLEXITY_PROVIDER_META,
+  PerplexityProvider,
+  SEARXNG_API_KEY_ENV_VAR,
+  SEARXNG_URL_ENV_VAR,
+  SEARXNG_DEFAULT_URL,
+  SEARXNG_PROVIDER_META,
+  SearxngProvider,
+  configureSearxng,
+  SERPER_API_KEY_ENV_VAR,
+  SERPER_PROVIDER_META,
+  SerperProvider,
+  TAVILY_API_KEY_ENV_VAR,
+  TAVILY_PROVIDER_META,
+  TavilyProvider,
+  YOUCOM_API_KEY_ENV_VAR,
+  YOUCOM_PROVIDER_META,
+  YouComProvider,
+  createSearchProvider,
+  PROVIDERS
+};