@zqagent/core 0.2.20 → 0.3.7

package/dist/tools/media.cjs

@@ -350,6 +350,9 @@ var ShellTaskManager = class {
   }
 };
 
+// src/tools/sandbox.ts
+var import_node_child_process4 = require("child_process");
+
 // src/tools/shell.ts
 var MAX_BUFFER = 1024 * 1024 * 5;
 function decodeOutput(buf) {
@@ -421,7 +424,281 @@ var path3 = __toESM(require("path"), 1);
 var import_node_module = require("module");
 var import_node_crypto = require("crypto");
 var import_promises = require("stream/promises");
-var import_socks_proxy_agent = require("socks-proxy-agent");
+
+// ../../node_modules/.pnpm/socks-proxy-agent@9.0.0_supports-color@7.2.0/node_modules/socks-proxy-agent/dist/index.js
+var import_socks = require("socks");
+
+// ../../node_modules/.pnpm/agent-base@8.0.0/node_modules/agent-base/dist/index.js
+var net = __toESM(require("net"), 1);
+var http = __toESM(require("http"), 1);
+var import_https = require("https");
+var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
+var Agent2 = class extends http.Agent {
+  constructor(opts) {
+    super(opts);
+    this[INTERNAL] = {};
+  }
+  /**
+   * Determine whether this is an `http` or `https` request.
+   */
+  isSecureEndpoint(options) {
+    if (options) {
+      if (typeof options.secureEndpoint === "boolean") {
+        return options.secureEndpoint;
+      }
+      if (typeof options.protocol === "string") {
+        return options.protocol === "https:";
+      }
+    }
+    const { stack } = new Error();
+    if (typeof stack !== "string")
+      return false;
+    return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+  }
+  // In order to support async signatures in `connect()` and Node's native
+  // connection pooling in `http.Agent`, the array of sockets for each origin
+  // has to be updated synchronously. This is so the length of the array is
+  // accurate when `addRequest()` is next called. We achieve this by creating a
+  // fake socket and adding it to `sockets[origin]` and incrementing
+  // `totalSocketCount`.
+  incrementSockets(name) {
+    if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+      return null;
+    }
+    if (!this.sockets[name]) {
+      this.sockets[name] = [];
+    }
+    const fakeSocket = new net.Socket({ writable: false });
+    this.sockets[name].push(fakeSocket);
+    this.totalSocketCount++;
+    return fakeSocket;
+  }
+  decrementSockets(name, socket) {
+    if (!this.sockets[name] || socket === null) {
+      return;
+    }
+    const sockets = this.sockets[name];
+    const index = sockets.indexOf(socket);
+    if (index !== -1) {
+      sockets.splice(index, 1);
+      this.totalSocketCount--;
+      if (sockets.length === 0) {
+        delete this.sockets[name];
+      }
+    }
+  }
+  // In order to properly update the socket pool, we need to call `getName()` on
+  // the core `https.Agent` if it is a secureEndpoint.
+  getName(options) {
+    const secureEndpoint = this.isSecureEndpoint(options);
+    if (secureEndpoint) {
+      return import_https.Agent.prototype.getName.call(this, options);
+    }
+    return super.getName(options);
+  }
+  createSocket(req, options, cb) {
+    const connectOpts = {
+      ...options,
+      secureEndpoint: this.isSecureEndpoint(options)
+    };
+    const name = this.getName(connectOpts);
+    const fakeSocket = this.incrementSockets(name);
+    Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+      this.decrementSockets(name, fakeSocket);
+      if (socket instanceof http.Agent) {
+        try {
+          return socket.addRequest(req, connectOpts);
+        } catch (err) {
+          return cb(err);
+        }
+      }
+      this[INTERNAL].currentSocket = socket;
+      super.createSocket(req, options, cb);
+    }, (err) => {
+      this.decrementSockets(name, fakeSocket);
+      cb(err);
+    });
+  }
+  createConnection() {
+    const socket = this[INTERNAL].currentSocket;
+    this[INTERNAL].currentSocket = void 0;
+    if (!socket) {
+      throw new Error("No socket was returned in the `connect()` function");
+    }
+    return socket;
+  }
+  get defaultPort() {
+    return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+  }
+  set defaultPort(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].defaultPort = v;
+    }
+  }
+  get protocol() {
+    return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+  }
+  set protocol(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].protocol = v;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/socks-proxy-agent@9.0.0_supports-color@7.2.0/node_modules/socks-proxy-agent/dist/index.js
+var import_debug = __toESM(require("debug"), 1);
+var dns = __toESM(require("dns"), 1);
+var net2 = __toESM(require("net"), 1);
+var tls = __toESM(require("tls"), 1);
+var import_url = require("url");
+var debug = (0, import_debug.default)("socks-proxy-agent");
+var setServernameFromNonIpHost = (options) => {
+  if (options.servername === void 0 && options.host && !net2.isIP(options.host)) {
+    return {
+      ...options,
+      servername: options.host
+    };
+  }
+  return options;
+};
+function parseSocksURL(url) {
+  let lookup2 = false;
+  let type = 5;
+  const host = url.hostname;
+  const port = parseInt(url.port, 10) || 1080;
+  switch (url.protocol.replace(":", "")) {
+    case "socks4":
+      lookup2 = true;
+      type = 4;
+      break;
+    // pass through
+    case "socks4a":
+      type = 4;
+      break;
+    case "socks5":
+      lookup2 = true;
+      type = 5;
+      break;
+    // pass through
+    case "socks":
+      type = 5;
+      break;
+    case "socks5h":
+      type = 5;
+      break;
+    default:
+      throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`);
+  }
+  const proxy = {
+    host,
+    port,
+    type
+  };
+  if (url.username) {
+    Object.defineProperty(proxy, "userId", {
+      value: decodeURIComponent(url.username),
+      enumerable: false
+    });
+  }
+  if (url.password != null) {
+    Object.defineProperty(proxy, "password", {
+      value: decodeURIComponent(url.password),
+      enumerable: false
+    });
+  }
+  return { lookup: lookup2, proxy };
+}
+var SocksProxyAgent = class extends Agent2 {
+  constructor(uri, opts) {
+    super(opts);
+    const url = typeof uri === "string" ? new import_url.URL(uri) : uri;
+    const { proxy, lookup: lookup2 } = parseSocksURL(url);
+    this.shouldLookup = lookup2;
+    this.proxy = proxy;
+    this.timeout = opts?.timeout ?? null;
+    this.socketOptions = opts?.socketOptions ?? null;
+  }
+  /**
+   * Initiates a SOCKS connection to the specified SOCKS proxy server,
+   * which in turn connects to the specified remote host and port.
+   */
+  async connect(req, opts) {
+    const { shouldLookup, proxy, timeout } = this;
+    if (!opts.host) {
+      throw new Error("No `host` defined!");
+    }
+    let { host } = opts;
+    const { port, lookup: lookupFn = dns.lookup } = opts;
+    if (shouldLookup) {
+      host = await new Promise((resolve4, reject) => {
+        lookupFn(host, {}, (err, address) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve4(typeof address === "string" ? address : address[0].address);
+          }
+        });
+      });
+    }
+    const socksOpts = {
+      proxy,
+      destination: {
+        host,
+        port: typeof port === "number" ? port : parseInt(port, 10)
+      },
+      command: "connect",
+      timeout: timeout ?? void 0,
+      // @ts-expect-error the type supplied by socks for socket_options is wider
+      // than necessary since socks will always override the host and port
+      socket_options: this.socketOptions ?? void 0
+    };
+    const cleanup = (tlsSocket) => {
+      req.destroy();
+      socket.destroy();
+      if (tlsSocket)
+        tlsSocket.destroy();
+    };
+    debug("Creating socks proxy connection: %o", socksOpts);
+    const { socket } = await import_socks.SocksClient.createConnection(socksOpts);
+    debug("Successfully created socks proxy connection");
+    if (timeout !== null) {
+      socket.setTimeout(timeout);
+      socket.on("timeout", () => cleanup());
+    }
+    if (opts.secureEndpoint) {
+      debug("Upgrading socket connection to TLS");
+      const tlsSocket = tls.connect({
+        ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+        socket
+      });
+      tlsSocket.once("error", (error) => {
+        debug("Socket TLS error", error.message);
+        cleanup(tlsSocket);
+      });
+      return tlsSocket;
+    }
+    return socket;
+  }
+};
+SocksProxyAgent.protocols = [
+  "socks",
+  "socks4",
+  "socks4a",
+  "socks5",
+  "socks5h"
+];
+function omit(obj, ...keys) {
+  const ret = {};
+  let key;
+  for (key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+
+// src/tools/ffmpegRuntime.ts
 var import_node_fetch = __toESM(require("node-fetch"), 1);
 var ENV_FFMPEG = "ZQAGENT_FFMPEG";
 var ENV_FFPROBE = "ZQAGENT_FFPROBE";
@@ -429,10 +706,10 @@ var PROXY_ENV = process.env.SOCKS5_PROXY;
 var socksAgent = null;
 if (PROXY_ENV) {
   try {
-    socksAgent = new import_socks_proxy_agent.SocksProxyAgent(PROXY_ENV);
+    socksAgent = new SocksProxyAgent(PROXY_ENV);
   } catch {
     try {
-      socksAgent = new import_socks_proxy_agent.SocksProxyAgent(PROXY_ENV.replace(/^socks5h:\/\//, "socks5://"));
+      socksAgent = new SocksProxyAgent(PROXY_ENV.replace(/^socks5h:\/\//, "socks5://"));
     } catch {
       socksAgent = null;
     }