[Init] Initial commit - NetMesh terminal manager

electron/bridges/aiBridge/providerHandlers.cjs

@@ -0,0 +1,514 @@
+/* eslint-disable no-undef */
+const { existsSync } = require("node:fs");
+
+function registerProviderHandlers(ctx) {
+  with (ctx) {
+  ipcMain.handle("netcatty:ai:user-skills:status", async (event) => {
+    if (!validateSenderOrSettings(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    try {
+      const status = await scanUserSkills(electronModule?.app);
+      return { ok: true, ...toPublicUserSkillsStatus(status) };
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  });
+
+  ipcMain.handle("netcatty:ai:user-skills:open", async (event) => {
+    if (!validateSenderOrSettings(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    try {
+      const status = await scanUserSkills(electronModule?.app);
+      const openResult = await electronModule?.shell?.openPath?.(status.directoryPath);
+      return {
+        ok: !openResult,
+        error: openResult || undefined,
+        ...toPublicUserSkillsStatus(status),
+      };
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  });
+
+  ipcMain.handle("netcatty:ai:user-skills:build-context", async (event, { prompt, selectedSkillSlugs }) => {
+    if (!validateSender(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    try {
+      const { context, status } = await buildUserSkillsContext(electronModule?.app, prompt, selectedSkillSlugs);
+      return { ok: true, context, status: toPublicUserSkillsStatus(status) };
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  });
+
+  ipcMain.handle("netcatty:ai:skills-cli:invocation", async (event) => {
+    if (!validateSenderOrSettings(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    try {
+      const invocation = getSkillsCliInvocation();
+      return {
+        ok: true,
+        skillPath: existsSync(NETCATTY_TOOL_SKILL_PATH) ? NETCATTY_TOOL_SKILL_PATH : null,
+        commandPrefix: invocation.commandPrefix,
+        launcherPath: invocation.launcherPath,
+        usesLauncher: invocation.usesLauncher,
+      };
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  });
+
+  // ── Provider config sync (renderer → main, keys stay encrypted) ──
+  ipcMain.handle("netcatty:ai:sync-providers", async (event, { providers }) => {
+    if (!validateSenderOrSettings(event)) return { ok: false };
+    if (Array.isArray(providers)) {
+      providerConfigs = providers;
+      rebuildProviderFetchHosts();
+    }
+    return { ok: true };
+  });
+
+  // ── Web search config sync (renderer → main, for fetch allowlist + key decryption) ──
+  ipcMain.handle("netcatty:ai:sync-web-search", async (event, { apiHost, apiKey }) => {
+    if (!validateSenderOrSettings(event)) return { ok: false };
+    webSearchApiHost = typeof apiHost === "string" ? apiHost : null;
+    webSearchApiKeyEncrypted = typeof apiKey === "string" ? apiKey : null;
+    rebuildProviderFetchHosts();
+    return { ok: true };
+  });
+
+  /**
+   * Inject the decrypted web search API key into request headers.
+   * Replaces __WEB_SEARCH_KEY__ placeholder, similar to __IPC_SECURED__ for providers.
+   */
+  function injectWebSearchKeyIntoHeaders(headers) {
+    if (!webSearchApiKeyEncrypted || !headers) return headers;
+    const realKey = decryptApiKeyValue(webSearchApiKeyEncrypted);
+    if (!realKey) return headers;
+    const patched = {};
+    for (const [k, v] of Object.entries(headers)) {
+      patched[k] = typeof v === "string" ? v.replace(WEB_SEARCH_KEY_PLACEHOLDER, realKey) : v;
+    }
+    return patched;
+  }
+
+  // Temporarily add a host to the fetch allowlist (used by settings model listing).
+  // Entries are auto-removed after 30 seconds unless they belong to a synced provider.
+  const TEMP_ALLOWLIST_TTL = 30_000;
+  // Track temporarily added entries so cleanup can distinguish them from synced ones
+  const tempAllowedHosts = new Set();
+  const tempAllowedPorts = new Set();
+  // Track temporarily added HTTP hosts (for rebuild restoration)
+  const tempHttpHosts = new Set();
+  // Track active expiry timers per host to avoid duplicate/premature expiry
+  const hostExpiryTimers = new Map();
+
+  /** Check if a host is owned by a currently synced provider config */
+  function isHostInProviderConfigs(host) {
+    for (const config of providerConfigs) {
+      if (!config.baseURL) continue;
+      try { if (new URL(config.baseURL).hostname === host) return true; } catch {}
+    }
+    return false;
+  }
+  /** Check if a host is owned by a provider config that uses http:// */
+  function isHttpHostInProviderConfigs(host) {
+    for (const config of providerConfigs) {
+      if (!config.baseURL) continue;
+      try {
+        const p = new URL(config.baseURL);
+        if (p.hostname === host && p.protocol === "http:") return true;
+      } catch {}
+    }
+    return false;
+  }
+  /** Check if a localhost port is owned by a currently synced provider config */
+  function isPortInProviderConfigs(port) {
+    for (const config of providerConfigs) {
+      if (!config.baseURL) continue;
+      try {
+        const p = new URL(config.baseURL);
+        if ((p.hostname === "localhost" || p.hostname === "127.0.0.1") &&
+            Number(p.port || (p.protocol === "https:" ? 443 : 80)) === port) return true;
+      } catch {}
+    }
+    return false;
+  }
+
+  ipcMain.handle("netcatty:ai:allowlist:add-host", async (event, { baseURL }) => {
+    if (!validateSenderOrSettings(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    if (typeof baseURL !== "string") return { ok: false, error: "baseURL must be a string" };
+    try {
+      const parsed = new URL(baseURL);
+      const host = parsed.hostname;
+      if (host === "localhost" || host === "127.0.0.1") {
+        const port = parsed.port ? Number(parsed.port) : (parsed.protocol === "https:" ? 443 : 80);
+        if (!ALLOWED_LOCALHOST_PORTS.has(port)) {
+          ALLOWED_LOCALHOST_PORTS.add(port);
+          tempAllowedPorts.add(port);
+          setTimeout(() => {
+            // Only remove if still temporary (not built-in and not synced by a provider)
+            if (!BUILTIN_LOCALHOST_PORTS.includes(port) && !isPortInProviderConfigs(port)) {
+              ALLOWED_LOCALHOST_PORTS.delete(port);
+            }
+            tempAllowedPorts.delete(port);
+          }, TEMP_ALLOWLIST_TTL);
+        }
+      } else {
+        const isNewHost = !providerFetchHosts.has(host);
+        if (isNewHost) {
+          providerFetchHosts.add(host);
+        }
+        // Always track in tempAllowedHosts so rebuild can restore to providerFetchHosts
+        // even if the original persistent source (e.g. HTTPS provider) is removed mid-TTL
+        tempAllowedHosts.add(host);
+        if (parsed.protocol === "http:") {
+          providerHttpHosts.add(host);
+          if (!isHttpHostInProviderConfigs(host)) tempHttpHosts.add(host);
+        }
+        // Always (re-)schedule expiry timer to clean up temp entries
+        const existing = hostExpiryTimers.get(host);
+        if (existing) clearTimeout(existing);
+        const timer = setTimeout(() => {
+          hostExpiryTimers.delete(host);
+          // Check if host is still needed by a provider config or web search
+          const isWebSearchHost = webSearchApiHost && (() => {
+            try { return new URL(webSearchApiHost).hostname === host; } catch { return false; }
+          })();
+          if (!isHostInProviderConfigs(host) && !isWebSearchHost) {
+            providerFetchHosts.delete(host);
+            providerHttpHosts.delete(host);
+          } else if (!isHttpHostInProviderConfigs(host)) {
+            providerHttpHosts.delete(host);
+          }
+          tempAllowedHosts.delete(host);
+          tempHttpHosts.delete(host);
+        }, TEMP_ALLOWLIST_TTL);
+        hostExpiryTimers.set(host, timer);
+      }
+      return { ok: true };
+    } catch {
+      return { ok: false, error: "Invalid URL" };
+    }
+  });
+
+  // URL allowlist: only permit requests to known AI provider domains + HTTPS
+  const BUILTIN_FETCH_HOSTS = new Set([
+    "api.openai.com",
+    "api.anthropic.com",
+    "generativelanguage.googleapis.com",
+    "openrouter.ai",
+    // Web search providers
+    "api.tavily.com",
+    "api.exa.ai",
+    "api.bochaai.com",
+    "open.bigmodel.cn",
+  ]);
+  // Dynamically populated from configured provider baseURLs
+  const providerFetchHosts = new Set();
+  // Subset of providerFetchHosts where the provider baseURL explicitly uses http://
+  const providerHttpHosts = new Set();
+
+  /**
+   * Rebuild the dynamic host allowlist from the current providerConfigs.
+   * Called whenever providers are synced from the renderer.
+   */
+  function rebuildProviderFetchHosts() {
+    providerFetchHosts.clear();
+    providerHttpHosts.clear();
+    // Reset localhost ports to built-in defaults, then add provider-configured ones
+    ALLOWED_LOCALHOST_PORTS.clear();
+    for (const port of BUILTIN_LOCALHOST_PORTS) ALLOWED_LOCALHOST_PORTS.add(port);
+    // Re-add any still-active temporary entries so a sync doesn't wipe them
+    for (const host of tempAllowedHosts) providerFetchHosts.add(host);
+    for (const host of tempHttpHosts) providerHttpHosts.add(host);
+    for (const port of tempAllowedPorts) ALLOWED_LOCALHOST_PORTS.add(port);
+    for (const config of providerConfigs) {
+      if (!config.baseURL) continue;
+      try {
+        const parsed = new URL(config.baseURL);
+        const host = parsed.hostname;
+        // Skip localhost — handled separately via port allowlist
+        if (host === "localhost" || host === "127.0.0.1") {
+          const port = parsed.port ? Number(parsed.port) : (parsed.protocol === "https:" ? 443 : 80);
+          ALLOWED_LOCALHOST_PORTS.add(port);
+        } else {
+          providerFetchHosts.add(host);
+          if (parsed.protocol === "http:") providerHttpHosts.add(host);
+        }
+      } catch {
+        // Invalid URL in config — skip
+      }
+    }
+    // Add web search apiHost if configured (e.g. SearXNG self-hosted instance)
+    if (webSearchApiHost) {
+      try {
+        const parsed = new URL(webSearchApiHost);
+        const host = parsed.hostname;
+        if (host === "localhost" || host === "127.0.0.1") {
+          const port = parsed.port ? Number(parsed.port) : (parsed.protocol === "https:" ? 443 : 80);
+          ALLOWED_LOCALHOST_PORTS.add(port);
+        } else {
+          providerFetchHosts.add(host);
+        }
+      } catch {}
+    }
+  }
+
+  // Allowed localhost ports to prevent SSRF (Issue #9)
+  const BUILTIN_LOCALHOST_PORTS = [
+    11434,  // Ollama default
+    1234,   // LM Studio default
+    3000,   // Common local dev
+    3001,   // Common local dev
+    5000,   // Common local dev
+    5001,   // Common local dev
+    8000,   // Common local dev
+    8080,   // Common local dev
+    8888,   // Common local dev
+  ];
+  const ALLOWED_LOCALHOST_PORTS = new Set(BUILTIN_LOCALHOST_PORTS);
+  // RFC1918 / link-local / loopback / IPv6 private ranges — used by SSRF guard
+  function isPrivateIp(ip) {
+    if (!ip) return false;
+    // Strip IPv6 brackets that URL.hostname may include
+    const cleaned = ip.replace(/^\[|\]$/g, "");
+    if (cleaned === "::1" || cleaned === "0.0.0.0" || cleaned === "::") return true;
+    // IPv6 private ranges: fc00::/7 (unique local), fe80::/10 (link-local), ::ffff:127.x (mapped loopback)
+    const lower = cleaned.toLowerCase();
+    if (lower.startsWith("fc") || lower.startsWith("fd")) return true;   // fc00::/7
+    if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) return true; // fe80::/10
+    if (lower.startsWith("::ffff:")) {
+      // IPv4-mapped IPv6 — extract IPv4 portion and check
+      const v4 = lower.slice(7);
+      return isPrivateIp(v4);
+    }
+    // IPv4
+    const parts = cleaned.split(".");
+    if (parts.length === 4 && parts.every(p => /^\d+$/.test(p))) {
+      const [a, b] = parts.map(Number);
+      if (a === 10) return true;                           // 10.0.0.0/8
+      if (a === 172 && b >= 16 && b <= 31) return true;   // 172.16.0.0/12
+      if (a === 192 && b === 168) return true;             // 192.168.0.0/16
+      if (a === 127) return true;                          // 127.0.0.0/8
+      if (a === 169 && b === 254) return true;             // 169.254.0.0/16 link-local
+      if (a === 100 && b >= 64 && b <= 127) return true;   // 100.64.0.0/10 CGNAT (Tailscale etc.)
+      if (a === 0) return true;                            // 0.0.0.0/8
+    }
+    return false;
+  }
+
+  function isPrivateHost(hostname) {
+    if (hostname === "localhost") return true;
+    // metadata endpoints (AWS, GCP, Azure)
+    if (hostname === "metadata.google.internal") return true;
+    return isPrivateIp(hostname);
+  }
+
+  function isAllowedFetchUrl(urlString, skipHostCheck) {
+    try {
+      const parsed = new URL(urlString);
+      // Always block private/internal hosts when skipHostCheck is set (SSRF protection)
+      if (skipHostCheck) {
+        if (isPrivateHost(parsed.hostname)) return false;
+        // Require HTTPS for skipHostCheck requests
+        if (parsed.protocol !== "https:") return false;
+        return true;
+      }
+      // Allow localhost/127.0.0.1 only on known ports (e.g. Ollama) — normal fetch path only
+      if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
+        const port = parsed.port ? Number(parsed.port) : (parsed.protocol === "https:" ? 443 : 80);
+        return ALLOWED_LOCALHOST_PORTS.has(port);
+      }
+      // Only allow http: and https: schemes for remote hosts
+      if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+      // For HTTP, only allow providers explicitly configured with http:// or the web search apiHost
+      if (parsed.protocol === "http:") {
+        const isProviderHost = providerHttpHosts.has(parsed.hostname);
+        let isWebSearchHost = false;
+        if (webSearchApiHost) {
+          try { isWebSearchHost = new URL(webSearchApiHost).hostname === parsed.hostname; } catch { }
+        }
+        if (!isProviderHost && !isWebSearchHost) return false;
+      }
+      // Check built-in + provider-configured host allowlist
+      if (BUILTIN_FETCH_HOSTS.has(parsed.hostname)) return true;
+      if (providerFetchHosts.has(parsed.hostname)) return true;
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  // Start a streaming chat request (proxied through main process)
+  ipcMain.handle("netcatty:ai:chat:stream", async (event, {
+    requestId,
+    url,
+    headers,
+    body,
+    providerId,
+    idleTimeoutMs,
+  }) => {
+    // Validate IPC sender (Issue #17)
+    if (!validateSender(event)) {
+      return { ok: false, error: "Unauthorized IPC sender" };
+    }
+    try {
+      // Inject real API key if providerId is given (replaces placeholder in headers/URL)
+      const patched = injectApiKeyIntoRequest(url, headers, providerId);
+      const resolvedUrl = patched.url;
+      const resolvedHeaders = patched.headers;
+
+      // Validate URL: only allow HTTP(S) schemes
+      try {
+        const parsed = new URL(resolvedUrl);
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+          return { ok: false, error: "Only HTTP(S) URLs are allowed" };
+        }
+      } catch {
+        return { ok: false, error: "Invalid URL" };
+      }
+
+      // Check URL against allowed hosts (same as netcatty:ai:fetch)
+      if (!isAllowedFetchUrl(resolvedUrl)) {
+        return { ok: false, error: "URL host is not in the allowed list" };
+      }
+
+      const skipTLS = shouldSkipTLSVerify(providerId);
+      const { statusCode, statusText } = await streamRequest(
+        resolvedUrl,
+        { method: "POST", headers: resolvedHeaders, body, idleTimeoutMs },
+        event,
+        requestId,
+        skipTLS,
+      );
+      return { ok: true, statusCode, statusText };
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        return { ok: false, aborted: true, error: "Aborted" };
+      }
+      return { ok: false, error: err?.message || String(err) };
+    }
+  });
+
+  // Cancel an active stream
+  ipcMain.handle("netcatty:ai:chat:cancel", async (event, { requestId }) => {
+    if (!validateSender(event)) return { ok: false, error: "Unauthorized IPC sender" };
+    const controller = activeStreams.get(requestId);
+    if (controller) {
+      controller.abort();
+      activeStreams.delete(requestId);
+      return true;
+    }
+    return false;
+  });
+
+  // Non-streaming request (for model listing, validation, etc.)
+  ipcMain.handle("netcatty:ai:fetch", async (event, { url, method, headers, body, providerId, skipHostCheck, followRedirects, skipTLSVerify }) => {
+    // Validate IPC sender — settings window needs this for model listing
+    if (!validateSenderOrSettings(event)) {
+      return { ok: false, status: 0, data: "", error: "Unauthorized IPC sender" };
+    }
+
+    // Inject real API key if providerId is given (replaces placeholder in headers/URL)
+    const patched = injectApiKeyIntoRequest(url, headers, providerId);
+    const resolvedUrl = patched.url;
+    // Also inject web search API key if placeholder is present
+    const resolvedHeaders = injectWebSearchKeyIntoHeaders(patched.headers);
+
+    // Validate URL: block non-HTTP(S) schemes and internal network access
+    try {
+      const parsed = new URL(resolvedUrl);
+      if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        return { ok: false, status: 0, data: "", error: "Only HTTP(S) URLs are allowed" };
+      }
+      // Block file:// and other dangerous schemes (already covered above)
+    } catch {
+      return { ok: false, status: 0, data: "", error: "Invalid URL" };
+    }
+
+    // Check URL against allowed hosts; skipHostCheck allows public HTTPS but still blocks private/internal
+    if (!isAllowedFetchUrl(resolvedUrl, !!skipHostCheck)) {
+      return { ok: false, status: 0, data: "", error: "URL host is not in the allowed list" };
+    }
+
+    const MAX_RESPONSE_SIZE = 10 * 1024 * 1024; // 10MB safety limit
+    const MAX_REDIRECTS = followRedirects ? 5 : 0;
+
+    async function doFetch(fetchUrl, redirectsLeft) {
+      // ctx.require is bound from aiBridge.cjs, so this path is relative to that file.
+      const { resolveOutboundHttpAgent } = require("./httpNetworkProxyAgent.cjs");
+      const skipTLS = Boolean(skipTLSVerify || shouldSkipTLSVerify(providerId));
+      let proxyAgent;
+      try {
+        proxyAgent = await resolveOutboundHttpAgent(fetchUrl, {
+          session: electronModule?.session?.defaultSession,
+          rejectUnauthorized: skipTLS ? false : undefined,
+        });
+      } catch {
+        proxyAgent = undefined;
+      }
+
+      return new Promise((resolve) => {
+        const parsedUrl = new URL(fetchUrl);
+        const isHttps = parsedUrl.protocol === "https:";
+        const lib = isHttps ? https : http;
+
+        const fetchOpts = {
+          method: method || "GET",
+          headers: withContentLength(resolvedHeaders || {}, body),
+          timeout: 30000,
+        };
+        if (skipTLS && isHttps) fetchOpts.rejectUnauthorized = false;
+        if (proxyAgent) fetchOpts.agent = proxyAgent;
+        const req = lib.request(parsedUrl, fetchOpts,
+          (res) => {
+            // Handle redirects
+            if (redirectsLeft > 0 && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+              const location = new URL(res.headers.location, fetchUrl).href;
+              res.resume(); // drain the response
+              // Revalidate the redirect target hostname (blocks localhost/metadata etc.)
+              if (!isAllowedFetchUrl(location, !!skipHostCheck)) {
+                resolve({ ok: false, status: 0, data: "", error: "Redirect target is not allowed" });
+                return;
+              }
+              resolve(doFetch(location, redirectsLeft - 1));
+              return;
+            }
+            let data = "";
+            let totalSize = 0;
+            res.on("data", (chunk) => {
+              totalSize += chunk.length;
+              if (totalSize > MAX_RESPONSE_SIZE) {
+                req.destroy();
+                resolve({ ok: false, status: 0, data: "", error: "Response body exceeded maximum size (10MB)" });
+                return;
+              }
+              data += chunk.toString();
+            });
+            res.on("end", () => {
+              resolve({
+                ok: res.statusCode >= 200 && res.statusCode < 300,
+                status: res.statusCode,
+                data,
+              });
+            });
+          }
+        );
+
+        req.on("error", (err) => {
+          resolve({ ok: false, status: 0, data: "", error: err.message });
+        });
+        req.on("timeout", () => {
+          req.destroy();
+          resolve({ ok: false, status: 0, data: "", error: "Request timeout" });
+        });
+
+        if (body) req.write(body);
+        req.end();
+      });
+    }
+
+    return doFetch(resolvedUrl, MAX_REDIRECTS);
+  });
+
+  }
+}
+
+module.exports = { registerProviderHandlers };