@wix/create-new 0.0.89 → 0.0.90

package/build/index.js

@@ -8187,6 +8187,553 @@ var require_index_node = __commonJS({
   }
 });
 
+// ../../node_modules/agent-base/dist/helpers.js
+var require_helpers = __commonJS({
+  "../../node_modules/agent-base/dist/helpers.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding2(result, mod, k);
+      }
+      __setModuleDefault2(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.req = exports.json = exports.toBuffer = void 0;
+    var http3 = __importStar2(__require("http"));
+    var https2 = __importStar2(__require("https"));
+    async function toBuffer(stream) {
+      let length = 0;
+      const chunks = [];
+      for await (const chunk of stream) {
+        length += chunk.length;
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks, length);
+    }
+    exports.toBuffer = toBuffer;
+    async function json(stream) {
+      const buf = await toBuffer(stream);
+      const str = buf.toString("utf8");
+      try {
+        return JSON.parse(str);
+      } catch (_err) {
+        const err = _err;
+        err.message += ` (input: ${str})`;
+        throw err;
+      }
+    }
+    exports.json = json;
+    function req(url, opts = {}) {
+      const href = typeof url === "string" ? url : url.href;
+      const req2 = (href.startsWith("https:") ? https2 : http3).request(url, opts);
+      const promise = new Promise((resolve4, reject) => {
+        req2.once("response", resolve4).once("error", reject).end();
+      });
+      req2.then = promise.then.bind(promise);
+      return req2;
+    }
+    exports.req = req;
+  }
+});
+
+// ../../node_modules/agent-base/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/agent-base/dist/index.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding2(result, mod, k);
+      }
+      __setModuleDefault2(result, mod);
+      return result;
+    };
+    var __exportStar2 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding2(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Agent = void 0;
+    var net2 = __importStar2(__require("net"));
+    var http3 = __importStar2(__require("http"));
+    var https_1 = __require("https");
+    __exportStar2(require_helpers(), exports);
+    var INTERNAL2 = Symbol("AgentBaseInternalState");
+    var Agent3 = class extends http3.Agent {
+      constructor(opts) {
+        super(opts);
+        this[INTERNAL2] = {};
+      }
+      /**
+       * 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 net2.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 = typeof options.secureEndpoint === "boolean" ? options.secureEndpoint : this.isSecureEndpoint(options);
+        if (secureEndpoint) {
+          return https_1.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 http3.Agent) {
+            try {
+              return socket.addRequest(req, connectOpts);
+            } catch (err) {
+              return cb(err);
+            }
+          }
+          this[INTERNAL2].currentSocket = socket;
+          super.createSocket(req, options, cb);
+        }, (err) => {
+          this.decrementSockets(name, fakeSocket);
+          cb(err);
+        });
+      }
+      createConnection() {
+        const socket = this[INTERNAL2].currentSocket;
+        this[INTERNAL2].currentSocket = void 0;
+        if (!socket) {
+          throw new Error("No socket was returned in the `connect()` function");
+        }
+        return socket;
+      }
+      get defaultPort() {
+        return this[INTERNAL2].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+      }
+      set defaultPort(v) {
+        if (this[INTERNAL2]) {
+          this[INTERNAL2].defaultPort = v;
+        }
+      }
+      get protocol() {
+        return this[INTERNAL2].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+      }
+      set protocol(v) {
+        if (this[INTERNAL2]) {
+          this[INTERNAL2].protocol = v;
+        }
+      }
+    };
+    exports.Agent = Agent3;
+  }
+});
+
+// ../../node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS({
+  "../../node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __importDefault2 = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseProxyResponse = void 0;
+    var debug_1 = __importDefault2(require_src());
+    var debug3 = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+    function parseProxyResponse2(socket) {
+      return new Promise((resolve4, reject) => {
+        let buffersLength = 0;
+        const buffers = [];
+        function read() {
+          const b2 = socket.read();
+          if (b2)
+            ondata(b2);
+          else
+            socket.once("readable", read);
+        }
+        function cleanup() {
+          socket.removeListener("end", onend);
+          socket.removeListener("error", onerror);
+          socket.removeListener("readable", read);
+        }
+        function onend() {
+          cleanup();
+          debug3("onend");
+          reject(new Error("Proxy connection ended before receiving CONNECT response"));
+        }
+        function onerror(err) {
+          cleanup();
+          debug3("onerror %o", err);
+          reject(err);
+        }
+        function ondata(b2) {
+          buffers.push(b2);
+          buffersLength += b2.length;
+          const buffered = Buffer.concat(buffers, buffersLength);
+          const endOfHeaders = buffered.indexOf("\r\n\r\n");
+          if (endOfHeaders === -1) {
+            debug3("have not received end of HTTP headers yet...");
+            read();
+            return;
+          }
+          const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+          const firstLine = headerParts.shift();
+          if (!firstLine) {
+            socket.destroy();
+            return reject(new Error("No header received from proxy CONNECT response"));
+          }
+          const firstLineParts = firstLine.split(" ");
+          const statusCode = +firstLineParts[1];
+          const statusText = firstLineParts.slice(2).join(" ");
+          const headers = {};
+          for (const header of headerParts) {
+            if (!header)
+              continue;
+            const firstColon = header.indexOf(":");
+            if (firstColon === -1) {
+              socket.destroy();
+              return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+            }
+            const key = header.slice(0, firstColon).toLowerCase();
+            const value2 = header.slice(firstColon + 1).trimStart();
+            const current = headers[key];
+            if (typeof current === "string") {
+              headers[key] = [current, value2];
+            } else if (Array.isArray(current)) {
+              current.push(value2);
+            } else {
+              headers[key] = value2;
+            }
+          }
+          debug3("got proxy server response: %o %o", firstLine, headers);
+          cleanup();
+          resolve4({
+            connect: {
+              statusCode,
+              statusText,
+              headers
+            },
+            buffered
+          });
+        }
+        socket.on("error", onerror);
+        socket.on("end", onend);
+        read();
+      });
+    }
+    exports.parseProxyResponse = parseProxyResponse2;
+  }
+});
+
+// ../../node_modules/https-proxy-agent/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/https-proxy-agent/dist/index.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar2 = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding2(result, mod, k);
+      }
+      __setModuleDefault2(result, mod);
+      return result;
+    };
+    var __importDefault2 = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HttpsProxyAgent = void 0;
+    var net2 = __importStar2(__require("net"));
+    var tls2 = __importStar2(__require("tls"));
+    var assert_1 = __importDefault2(__require("assert"));
+    var debug_1 = __importDefault2(require_src());
+    var agent_base_1 = require_dist();
+    var url_1 = __require("url");
+    var parse_proxy_response_1 = require_parse_proxy_response();
+    var debug3 = (0, debug_1.default)("https-proxy-agent");
+    var setServernameFromNonIpHost = (options) => {
+      if (options.servername === void 0 && options.host && !net2.isIP(options.host)) {
+        return {
+          ...options,
+          servername: options.host
+        };
+      }
+      return options;
+    };
+    var HttpsProxyAgent3 = class extends agent_base_1.Agent {
+      constructor(proxy, opts) {
+        super(opts);
+        this.options = { path: void 0 };
+        this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+        this.proxyHeaders = opts?.headers ?? {};
+        debug3("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+        const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+        const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+        this.connectOpts = {
+          // Attempt to negotiate http/1.1 for proxy servers that support http/2
+          ALPNProtocols: ["http/1.1"],
+          ...opts ? omit2(opts, "headers") : null,
+          host,
+          port
+        };
+      }
+      /**
+       * Called when the node-core HTTP client library is creating a
+       * new HTTP request.
+       */
+      async connect(req, opts) {
+        const { proxy } = this;
+        if (!opts.host) {
+          throw new TypeError('No "host" provided');
+        }
+        let socket;
+        if (proxy.protocol === "https:") {
+          debug3("Creating `tls.Socket`: %o", this.connectOpts);
+          socket = tls2.connect(setServernameFromNonIpHost(this.connectOpts));
+        } else {
+          debug3("Creating `net.Socket`: %o", this.connectOpts);
+          socket = net2.connect(this.connectOpts);
+        }
+        const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+        const host = net2.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+        let payload7 = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+        if (proxy.username || proxy.password) {
+          const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+          headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+        }
+        headers.Host = `${host}:${opts.port}`;
+        if (!headers["Proxy-Connection"]) {
+          headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+        }
+        for (const name of Object.keys(headers)) {
+          payload7 += `${name}: ${headers[name]}\r
+`;
+        }
+        const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+        socket.write(`${payload7}\r
+`);
+        const { connect: connect3, buffered } = await proxyResponsePromise;
+        req.emit("proxyConnect", connect3);
+        this.emit("proxyConnect", connect3, req);
+        if (connect3.statusCode === 200) {
+          req.once("socket", resume2);
+          if (opts.secureEndpoint) {
+            debug3("Upgrading socket connection to TLS");
+            return tls2.connect({
+              ...omit2(setServernameFromNonIpHost(opts), "host", "path", "port"),
+              socket
+            });
+          }
+          return socket;
+        }
+        socket.destroy();
+        const fakeSocket = new net2.Socket({ writable: false });
+        fakeSocket.readable = true;
+        req.once("socket", (s2) => {
+          debug3("Replaying proxy buffer for failed request");
+          (0, assert_1.default)(s2.listenerCount("data") > 0);
+          s2.push(buffered);
+          s2.push(null);
+        });
+        return fakeSocket;
+      }
+    };
+    HttpsProxyAgent3.protocols = ["http", "https"];
+    exports.HttpsProxyAgent = HttpsProxyAgent3;
+    function resume2(socket) {
+      socket.resume();
+    }
+    function omit2(obj, ...keys) {
+      const ret = {};
+      let key;
+      for (key in obj) {
+        if (!keys.includes(key)) {
+          ret[key] = obj[key];
+        }
+      }
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/proxy-from-env/index.js
+var require_proxy_from_env = __commonJS({
+  "../../node_modules/proxy-from-env/index.js"(exports) {
+    "use strict";
+    init_esm_shims();
+    var parseUrl2 = __require("url").parse;
+    var DEFAULT_PORTS = {
+      ftp: 21,
+      gopher: 70,
+      http: 80,
+      https: 443,
+      ws: 80,
+      wss: 443
+    };
+    var stringEndsWith = String.prototype.endsWith || function(s2) {
+      return s2.length <= this.length && this.indexOf(s2, this.length - s2.length) !== -1;
+    };
+    function getProxyForUrl2(url) {
+      var parsedUrl = typeof url === "string" ? parseUrl2(url) : url || {};
+      var proto2 = parsedUrl.protocol;
+      var hostname2 = parsedUrl.host;
+      var port = parsedUrl.port;
+      if (typeof hostname2 !== "string" || !hostname2 || typeof proto2 !== "string") {
+        return "";
+      }
+      proto2 = proto2.split(":", 1)[0];
+      hostname2 = hostname2.replace(/:\d*$/, "");
+      port = parseInt(port) || DEFAULT_PORTS[proto2] || 0;
+      if (!shouldProxy(hostname2, port)) {
+        return "";
+      }
+      var proxy = getEnv2("npm_config_" + proto2 + "_proxy") || getEnv2(proto2 + "_proxy") || getEnv2("npm_config_proxy") || getEnv2("all_proxy");
+      if (proxy && proxy.indexOf("://") === -1) {
+        proxy = proto2 + "://" + proxy;
+      }
+      return proxy;
+    }
+    function shouldProxy(hostname2, port) {
+      var NO_PROXY = (getEnv2("npm_config_no_proxy") || getEnv2("no_proxy")).toLowerCase();
+      if (!NO_PROXY) {
+        return true;
+      }
+      if (NO_PROXY === "*") {
+        return false;
+      }
+      return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+        if (!proxy) {
+          return true;
+        }
+        var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+        var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+        var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+        if (parsedProxyPort && parsedProxyPort !== port) {
+          return true;
+        }
+        if (!/^[.*]/.test(parsedProxyHostname)) {
+          return hostname2 !== parsedProxyHostname;
+        }
+        if (parsedProxyHostname.charAt(0) === "*") {
+          parsedProxyHostname = parsedProxyHostname.slice(1);
+        }
+        return !stringEndsWith.call(hostname2, parsedProxyHostname);
+      });
+    }
+    function getEnv2(key) {
+      return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
+    }
+    exports.getProxyForUrl = getProxyForUrl2;
+  }
+});
+
 // ../../node_modules/react/cjs/react.production.min.js
 var require_react_production_min = __commonJS({
   "../../node_modules/react/cjs/react.production.min.js"(exports) {
@@ -30494,7 +31041,7 @@ var require_bi_logger_factory = __commonJS({
 });
 
 // ../../node_modules/@wix/wix-bi-logger-client/dist/index.js
-var require_dist = __commonJS({
+var require_dist3 = __commonJS({
   "../../node_modules/@wix/wix-bi-logger-client/dist/index.js"(exports, module2) {
     "use strict";
     init_esm_shims();
@@ -47355,7 +47902,7 @@ var require_startCase = __commonJS({
 });
 
 // ../../node_modules/@vercel/detect-agent/dist/index.js
-var require_dist2 = __commonJS({
+var require_dist4 = __commonJS({
   "../../node_modules/@vercel/detect-agent/dist/index.js"(exports, module2) {
     "use strict";
     init_esm_shims();
@@ -48395,6 +48942,8 @@ function revokeRefreshToken(payload7) {
 // ../cli-http-client/src/create-http-client.ts
 init_esm_shims();
 var import_http_client2 = __toESM(require_index_node(), 1);
+var import_https_proxy_agent = __toESM(require_dist2(), 1);
+var import_proxy_from_env = __toESM(require_proxy_from_env(), 1);
 
 // ../cli-http-client/src/is-http-error.ts
 init_esm_shims();
@@ -48471,6 +49020,10 @@ var baseUrls = {
   api: "https://www.wixapis.com",
   standalone: void 0
 };
+function createProxyAgent(baseUrl) {
+  const proxyUrl = baseUrl ? (0, import_proxy_from_env.getProxyForUrl)(baseUrl) : process.env.HTTPS_PROXY ?? process.env.https_proxy ?? "";
+  return proxyUrl ? new import_https_proxy_agent.HttpsProxyAgent(proxyUrl) : void 0;
+}
 function interceptRequest(client2, fn) {
   return (...args) => fn.apply(client2, args).catch((error) => {
     if (isHttpError(error) && !client2.isCancel(error) && !error.response) {
@@ -48500,6 +49053,8 @@ function createHttpClient({
       Cookie: "XSRF-TOKEN=nocheck",
       "User-Agent": "wix-cli"
     }),
+    proxy: false,
+    httpsAgent: createProxyAgent(baseUrls[type]),
     // https://github.com/axios/axios/issues/4263 - fixed in Axios ^1.x.x but currently cannot be bumped in Wix Http Client
     maxBodyLength: Infinity,
     maxContentLength: Infinity
@@ -68392,7 +68947,7 @@ function parseProxyResponse(socket) {
 function debug2(...args) {
   logger.log("[https-proxy-agent]", ...args);
 }
-var HttpsProxyAgent = class extends Agent2 {
+var HttpsProxyAgent2 = class extends Agent2 {
   static __initStatic() {
     this.protocols = ["http", "https"];
   }
@@ -68479,7 +69034,7 @@ var HttpsProxyAgent = class extends Agent2 {
     return fakeSocket;
   }
 };
-HttpsProxyAgent.__initStatic();
+HttpsProxyAgent2.__initStatic();
 function resume(socket) {
   socket.resume();
 }
@@ -68523,7 +69078,7 @@ function makeNodeTransport(options) {
   );
   const nativeHttpModule = isHttps ? https : http2;
   const keepAlive = options.keepAlive === void 0 ? false : options.keepAlive;
-  const agent = proxy ? new HttpsProxyAgent(proxy) : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2e3 });
+  const agent = proxy ? new HttpsProxyAgent2(proxy) : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2e3 });
   return suppressTracing(() => {
     const requestExecutor = createRequestExecutor(options, _nullishCoalesce(options.httpModule, () => nativeHttpModule), agent);
     return createTransport(options, requestExecutor);
@@ -70726,7 +71281,7 @@ init_esm_shims();
 // ../../node_modules/@wix/standalone-node-bi-logger/dist/es/src/index.js
 init_esm_shims();
 init_tslib_es6();
-var import_wix_bi_logger_client = __toESM(require_dist());
+var import_wix_bi_logger_client = __toESM(require_dist3());
 var import_http_client6 = __toESM(require_index_node());
 var defaultOptions2 = {
   baseUrl: process.env.BI_BASE_URL || "https://frog.wix.com",
@@ -72018,7 +72573,7 @@ function queryApp(payload7) {
   return __queryApp;
 }
 
-// ../../node_modules/@wix/ambassador-headless-v1-o-auth-app/build/es/http.impl.js
+// ../../node_modules/@wix/ambassador-headless-v1-o-auth-app/es/build/http.impl.js
 init_esm_shims();
 var _createOAuthAppRequest = { oAuthApp: "_oAuthApp" };
 var _createOAuthAppResponse = { oAuthApp: "_oAuthApp" };
@@ -79586,7 +80141,8 @@ var DevCenterClient = class {
           mask: [
             "allowedDomains",
             "allowedRedirectUris",
-            "redirectUrlWixPages"
+            "redirectUrlWixPages",
+            "origin"
           ]
         })
       );
@@ -82858,7 +83414,8 @@ var useCreateProject = (businessId) => {
           `${prodBaseDomain}/${loginRoute}`,
           `${prodBaseDomain}/${logoutRoute}`
         ],
-        redirectUrlWixPages: prodBaseDomain
+        redirectUrlWixPages: prodBaseDomain,
+        origin: "other"
       });
       const environmentVariables = await upsertAppEnvironmentVariables(
         appProject.id,
@@ -94430,14 +94987,14 @@ var getHeadlessCommand = ({
 };
 
 // src/index.tsx
-var import_detect_agent = __toESM(require_dist2(), 1);
+var import_detect_agent = __toESM(require_dist4(), 1);
 import { randomUUID as randomUUID3 } from "node:crypto";
 
 // package.json
 var package_default = {
   name: "@wix/create-new",
   description: "General entry point for creating Wix projects",
-  version: "0.0.89",
+  version: "0.0.90",
   bin: "bin/index.cjs",
   devDependencies: {
     "@commander-js/extra-typings": "^13.0.0",