@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/chunk-G4ZGEQFT.js

@@ -1,250 +0,0 @@
-#!/usr/bin/env node
-
-// src/sandbox/proxy/HttpConnectProxy.ts
-import http from "http";
-import net from "net";
-import { EventEmitter } from "events";
-
-// src/sandbox/proxy/domainMatcher.ts
-function normalizeDomain(domain) {
-  let d = domain.toLowerCase().trim();
-  const colonIdx = d.lastIndexOf(":");
-  if (colonIdx > 0) {
-    const afterColon = d.slice(colonIdx + 1);
-    if (/^\d+$/.test(afterColon)) {
-      d = d.slice(0, colonIdx);
-    }
-  }
-  if (d.endsWith(".")) {
-    d = d.slice(0, -1);
-  }
-  return d;
-}
-function matchesDomain(domain, pattern) {
-  const d = normalizeDomain(domain);
-  const p = normalizeDomain(pattern);
-  if (d === p) return true;
-  if (p.startsWith("*.")) {
-    const suffix = p.slice(1);
-    return d.endsWith(suffix) && d.length > suffix.length;
-  }
-  return false;
-}
-function isDomainAllowed(domain, allowedDomains) {
-  if (!domain || allowedDomains.length === 0) return false;
-  return allowedDomains.some((pattern) => matchesDomain(domain, pattern));
-}
-
-// src/sandbox/proxy/HttpConnectProxy.ts
-var HttpConnectProxy = class extends EventEmitter {
-  constructor(options) {
-    super();
-    this.server = null;
-    this.activeSockets = /* @__PURE__ */ new Set();
-    this.allowedDomains = [...options.allowedDomains];
-    this.requestedPort = options.port ?? 0;
-  }
-  async start() {
-    if (this.server) {
-      throw new Error("Proxy is already running");
-    }
-    return new Promise((resolve, reject) => {
-      const server = http.createServer((req, res) => {
-        this.handleHttpRequest(req, res);
-      });
-      server.on("connect", (req, clientSocket, head) => {
-        this.handleConnect(req, clientSocket, head);
-      });
-      server.on("connection", (socket) => {
-        this.activeSockets.add(socket);
-        socket.on("close", () => this.activeSockets.delete(socket));
-      });
-      server.on("error", reject);
-      server.listen(this.requestedPort, "127.0.0.1", () => {
-        const addr = server.address();
-        if (!addr || typeof addr === "string") {
-          reject(new Error("Failed to get server address"));
-          return;
-        }
-        this.server = server;
-        resolve(addr.port);
-      });
-    });
-  }
-  async stop() {
-    if (!this.server) return;
-    for (const socket of this.activeSockets) {
-      socket.destroy();
-    }
-    this.activeSockets.clear();
-    return new Promise((resolve, reject) => {
-      this.server.close((err) => {
-        this.server = null;
-        if (err) reject(err);
-        else resolve();
-      });
-    });
-  }
-  updateAllowedDomains(domains) {
-    this.allowedDomains = [...domains];
-  }
-  getPort() {
-    if (!this.server) return null;
-    const addr = this.server.address();
-    if (!addr || typeof addr === "string") return null;
-    return addr.port;
-  }
-  isRunning() {
-    return this.server !== null;
-  }
-  emitEvent(type, domain, method) {
-    const event = { type, domain, method, timestamp: /* @__PURE__ */ new Date() };
-    this.emit("proxy-event", event);
-  }
-  /**
-   * Handle CONNECT requests (HTTPS tunneling).
-   */
-  handleConnect(req, clientSocket, head) {
-    const target = req.url || "";
-    const [host] = target.split(":");
-    const port = parseInt(target.split(":")[1] || "443", 10);
-    if (!isDomainAllowed(host, this.allowedDomains)) {
-      this.emitEvent("blocked", host, "CONNECT");
-      clientSocket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
-      clientSocket.end();
-      return;
-    }
-    this.emitEvent("allowed", host, "CONNECT");
-    const serverSocket = net.connect(port, host, () => {
-      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-      if (head.length > 0) {
-        serverSocket.write(head);
-      }
-      serverSocket.pipe(clientSocket);
-      clientSocket.pipe(serverSocket);
-    });
-    serverSocket.setTimeout(5e3, () => {
-      serverSocket.destroy();
-      clientSocket.write("HTTP/1.1 504 Gateway Timeout\r\n\r\n");
-      clientSocket.end();
-    });
-    serverSocket.on("error", () => {
-      clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
-      clientSocket.end();
-    });
-    clientSocket.on("error", () => {
-      serverSocket.destroy();
-    });
-  }
-  /**
-   * Handle plain HTTP forward proxy requests.
-   */
-  handleHttpRequest(req, res) {
-    const url = req.url || "";
-    let host;
-    try {
-      const parsed2 = new URL(url);
-      host = parsed2.hostname;
-    } catch {
-      host = (req.headers.host || "").split(":")[0];
-    }
-    if (!host || !isDomainAllowed(host, this.allowedDomains)) {
-      this.emitEvent("blocked", host || "unknown", req.method || "GET");
-      res.writeHead(403, { "Content-Type": "text/plain" });
-      res.end("Blocked by sandbox network proxy");
-      return;
-    }
-    this.emitEvent("allowed", host, req.method || "GET");
-    const parsed = new URL(url);
-    const proxyReq = http.request(
-      {
-        hostname: parsed.hostname,
-        port: parsed.port || 80,
-        path: parsed.pathname + parsed.search,
-        method: req.method,
-        headers: req.headers
-      },
-      (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
-        proxyRes.pipe(res);
-      }
-    );
-    proxyReq.on("error", () => {
-      res.writeHead(502, { "Content-Type": "text/plain" });
-      res.end("Bad Gateway");
-    });
-    req.pipe(proxyReq);
-  }
-};
-
-// src/sandbox/proxy/ProxyManager.ts
-var ProxyManager = class {
-  constructor(networkConfig) {
-    this.proxy = null;
-    this.eventHandlers = /* @__PURE__ */ new Set();
-    this.networkConfig = { ...networkConfig, allowedDomains: [...networkConfig.allowedDomains] };
-  }
-  async start() {
-    if (!this.networkConfig.enabled) return;
-    if (this.proxy?.isRunning()) return;
-    this.proxy = new HttpConnectProxy({
-      allowedDomains: this.networkConfig.allowedDomains
-    });
-    this.proxy.on("proxy-event", (event) => {
-      for (const handler of this.eventHandlers) {
-        handler(event);
-      }
-    });
-    await this.proxy.start();
-  }
-  async stop() {
-    if (!this.proxy) return;
-    await this.proxy.stop();
-    this.proxy = null;
-  }
-  /**
-   * Get proxy env vars for injecting into sandboxed processes.
-   * Returns both upper and lowercase variants for maximum compatibility.
-   */
-  getProxyEnv() {
-    if (!this.proxy?.isRunning()) return {};
-    const port = this.proxy.getPort();
-    if (!port) return {};
-    const proxyUrl = `http://127.0.0.1:${port}`;
-    const noProxy = "localhost,127.0.0.1,::1";
-    return {
-      HTTP_PROXY: proxyUrl,
-      http_proxy: proxyUrl,
-      HTTPS_PROXY: proxyUrl,
-      https_proxy: proxyUrl,
-      NO_PROXY: noProxy,
-      no_proxy: noProxy
-    };
-  }
-  addAllowedDomain(domain) {
-    if (!this.networkConfig.allowedDomains.includes(domain)) {
-      this.networkConfig.allowedDomains.push(domain);
-      this.proxy?.updateAllowedDomains(this.networkConfig.allowedDomains);
-    }
-  }
-  getAllowedDomains() {
-    return [...this.networkConfig.allowedDomains];
-  }
-  isRunning() {
-    return this.proxy?.isRunning() ?? false;
-  }
-  getPort() {
-    return this.proxy?.getPort() ?? null;
-  }
-  /**
-   * Subscribe to proxy events. Returns an unsubscribe function.
-   */
-  onEvent(handler) {
-    this.eventHandlers.add(handler);
-    return () => this.eventHandlers.delete(handler);
-  }
-};
-
-export {
-  ProxyManager
-};