@shopify/create-app 3.68.0 → 3.69.0

package/dist/{chunk-TOQEXS2N.js → chunk-XMQLNGN7.js}

@@ -12,11 +12,10 @@ import {
   removeSession,
   setCachedPartnerAccountStatus,
   setSession
-} from "./chunk-EY2NO5UP.js";
+} from "./chunk-UWDJJNDC.js";
 import {
   AbortError,
   BugError,
-  CancelExecution,
   Environment,
   FatalError,
   addPublicMetadata,
@@ -25,7 +24,6 @@ import {
   cloudEnvironment,
   currentProcessIsGlobal,
   execa,
-  findPathUp,
   firstPartyDev,
   import_ts_error,
   isCloudEnvironment,
@@ -41,25 +39,21 @@ import {
   outputInfo,
   outputToken,
   outputWarn,
-  readFile,
-  renderConfirmationPrompt,
   runWithTimer,
   serviceEnvironment,
   spinFqdn,
   stringifyMessage,
-  themeToken,
-  useDeviceAuth
-} from "./chunk-MAWDESEZ.js";
+  themeToken
+} from "./chunk-NQUHO34K.js";
 import {
   defaultThemeKitAccessDomain,
   environmentVariables,
   sessionConstants,
   systemEnvironmentVariables
-} from "./chunk-NZDBLGNM.js";
+} from "./chunk-G6AY2JW5.js";
 import {
-  cwd,
-  moduleDirectory
-} from "./chunk-T2GATXSP.js";
+  cwd
+} from "./chunk-BB6N2XSA.js";
 import {
   __commonJS,
   __require,
@@ -24426,11 +24420,11 @@ var require_url_state_machine = __commonJS({
     function isSpecialScheme(scheme) {
       return specialSchemes[scheme] !== void 0;
     }
-    function isSpecial(url2) {
-      return isSpecialScheme(url2.scheme);
+    function isSpecial(url) {
+      return isSpecialScheme(url.scheme);
     }
-    function isNotSpecial(url2) {
-      return !isSpecialScheme(url2.scheme);
+    function isNotSpecial(url) {
+      return !isSpecialScheme(url.scheme);
     }
     function defaultPort(scheme) {
       return specialSchemes[scheme];
@@ -24590,30 +24584,30 @@ var require_url_state_machine = __commonJS({
       });
       return result === null || result === "" ? failure : result;
     }
-    function trimControlChars(url2) {
-      return url2.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/ug, "");
+    function trimControlChars(url) {
+      return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/ug, "");
     }
-    function trimTabAndNewline(url2) {
-      return url2.replace(/\u0009|\u000A|\u000D/ug, "");
+    function trimTabAndNewline(url) {
+      return url.replace(/\u0009|\u000A|\u000D/ug, "");
     }
-    function shortenPath(url2) {
-      let { path } = url2;
-      path.length !== 0 && (url2.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0]) || path.pop());
+    function shortenPath(url) {
+      let { path } = url;
+      path.length !== 0 && (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0]) || path.pop());
     }
-    function includesCredentials(url2) {
-      return url2.username !== "" || url2.password !== "";
+    function includesCredentials(url) {
+      return url.username !== "" || url.password !== "";
     }
-    function cannotHaveAUsernamePasswordPort(url2) {
-      return url2.host === null || url2.host === "" || url2.scheme === "file";
+    function cannotHaveAUsernamePasswordPort(url) {
+      return url.host === null || url.host === "" || url.scheme === "file";
     }
-    function hasAnOpaquePath(url2) {
-      return typeof url2.path == "string";
+    function hasAnOpaquePath(url) {
+      return typeof url.path == "string";
     }
     function isNormalizedWindowsDriveLetter(string) {
       return /^[A-Za-z]:$/u.test(string);
     }
-    function URLStateMachine(input, base, encodingOverride, url2, stateOverride) {
-      if (this.pointer = 0, this.input = input, this.base = base || null, this.encodingOverride = encodingOverride || "utf-8", this.stateOverride = stateOverride, this.url = url2, this.failure = !1, this.parseError = !1, !this.url) {
+    function URLStateMachine(input, base, encodingOverride, url, stateOverride) {
+      if (this.pointer = 0, this.input = input, this.base = base || null, this.encodingOverride = encodingOverride || "utf-8", this.stateOverride = stateOverride, this.url = url, this.failure = !1, this.parseError = !1, !this.url) {
         this.url = {
           scheme: "",
           username: "",
@@ -24800,28 +24794,28 @@ var require_url_state_machine = __commonJS({
     URLStateMachine.prototype["parse fragment"] = function(c) {
       return isNaN(c) || (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2])) && (this.parseError = !0), this.url.fragment += utf8PercentEncodeCodePoint(c, isFragmentPercentEncode)), !0;
     };
-    function serializeURL(url2, excludeFragment) {
-      let output = `${url2.scheme}:`;
-      return url2.host !== null && (output += "//", (url2.username !== "" || url2.password !== "") && (output += url2.username, url2.password !== "" && (output += `:${url2.password}`), output += "@"), output += serializeHost(url2.host), url2.port !== null && (output += `:${url2.port}`)), url2.host === null && !hasAnOpaquePath(url2) && url2.path.length > 1 && url2.path[0] === "" && (output += "/."), output += serializePath(url2), url2.query !== null && (output += `?${url2.query}`), !excludeFragment && url2.fragment !== null && (output += `#${url2.fragment}`), output;
+    function serializeURL(url, excludeFragment) {
+      let output = `${url.scheme}:`;
+      return url.host !== null && (output += "//", (url.username !== "" || url.password !== "") && (output += url.username, url.password !== "" && (output += `:${url.password}`), output += "@"), output += serializeHost(url.host), url.port !== null && (output += `:${url.port}`)), url.host === null && !hasAnOpaquePath(url) && url.path.length > 1 && url.path[0] === "" && (output += "/."), output += serializePath(url), url.query !== null && (output += `?${url.query}`), !excludeFragment && url.fragment !== null && (output += `#${url.fragment}`), output;
     }
     function serializeOrigin(tuple) {
       let result = `${tuple.scheme}://`;
       return result += serializeHost(tuple.host), tuple.port !== null && (result += `:${tuple.port}`), result;
     }
-    function serializePath(url2) {
-      if (hasAnOpaquePath(url2))
-        return url2.path;
+    function serializePath(url) {
+      if (hasAnOpaquePath(url))
+        return url.path;
       let output = "";
-      for (let segment of url2.path)
+      for (let segment of url.path)
         output += `/${segment}`;
       return output;
     }
     module2.exports.serializeURL = serializeURL;
     module2.exports.serializePath = serializePath;
-    module2.exports.serializeURLOrigin = function(url2) {
-      switch (url2.scheme) {
+    module2.exports.serializeURLOrigin = function(url) {
+      switch (url.scheme) {
         case "blob": {
-          let pathURL = module2.exports.parseURL(serializePath(url2));
+          let pathURL = module2.exports.parseURL(serializePath(url));
           return pathURL === null || pathURL.scheme !== "http" && pathURL.scheme !== "https" ? "null" : module2.exports.serializeURLOrigin(pathURL);
         }
         case "ftp":
@@ -24830,9 +24824,9 @@ var require_url_state_machine = __commonJS({
         case "ws":
         case "wss":
           return serializeOrigin({
-            scheme: url2.scheme,
-            host: url2.host,
-            port: url2.port
+            scheme: url.scheme,
+            host: url.host,
+            port: url.port
           });
         case "file":
           return "null";
@@ -24845,11 +24839,11 @@ var require_url_state_machine = __commonJS({
       let usm = new URLStateMachine(input, options2.baseURL, options2.encodingOverride, options2.url, options2.stateOverride);
       return usm.failure ? null : usm.url;
     };
-    module2.exports.setTheUsername = function(url2, username2) {
-      url2.username = utf8PercentEncodeString(username2, isUserinfoPercentEncode);
+    module2.exports.setTheUsername = function(url, username2) {
+      url.username = utf8PercentEncodeString(username2, isUserinfoPercentEncode);
     };
-    module2.exports.setThePassword = function(url2, password) {
-      url2.password = utf8PercentEncodeString(password, isUserinfoPercentEncode);
+    module2.exports.setThePassword = function(url, password) {
+      url.password = utf8PercentEncodeString(password, isUserinfoPercentEncode);
     };
     module2.exports.serializeHost = serializeHost;
     module2.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
@@ -25386,18 +25380,18 @@ var require_URL_impl = __commonJS({
       // Unlike the spec, we duplicate some code between the constructor and canParse, because we want to give useful error
       // messages in the constructor that distinguish between the different causes of failure.
       constructor(globalObject, constructorArgs) {
-        let url2 = constructorArgs[0], base = constructorArgs[1], parsedBase = null;
+        let url = constructorArgs[0], base = constructorArgs[1], parsedBase = null;
         if (base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null))
           throw new TypeError(`Invalid base URL: ${base}`);
-        let parsedURL = usm.basicURLParse(url2, { baseURL: parsedBase });
+        let parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
         if (parsedURL === null)
-          throw new TypeError(`Invalid URL: ${url2}`);
+          throw new TypeError(`Invalid URL: ${url}`);
         let query = parsedURL.query !== null ? parsedURL.query : "";
         this._url = parsedURL, this._query = URLSearchParams2.createImpl(globalObject, [query], { doNotStripQMark: !0 }), this._query._url = this;
       }
-      static canParse(url2, base) {
+      static canParse(url, base) {
         let parsedBase = null;
-        return !(base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null) || usm.basicURLParse(url2, { baseURL: parsedBase }) === null);
+        return !(base !== void 0 && (parsedBase = usm.basicURLParse(base), parsedBase === null) || usm.basicURLParse(url, { baseURL: parsedBase }) === null);
       }
       get href() {
         return usm.serializeURL(this._url);
@@ -25432,8 +25426,8 @@ var require_URL_impl = __commonJS({
         usm.cannotHaveAUsernamePasswordPort(this._url) || usm.setThePassword(this._url, v);
       }
       get host() {
-        let url2 = this._url;
-        return url2.host === null ? "" : url2.port === null ? usm.serializeHost(url2.host) : `${usm.serializeHost(url2.host)}:${usm.serializeInteger(url2.port)}`;
+        let url = this._url;
+        return url.host === null ? "" : url.port === null ? usm.serializeHost(url.host) : `${usm.serializeHost(url.host)}:${usm.serializeInteger(url.port)}`;
       }
       set host(v) {
         usm.hasAnOpaquePath(this._url) || usm.basicURLParse(v, { url: this._url, stateOverride: "host" });
@@ -25460,13 +25454,13 @@ var require_URL_impl = __commonJS({
         return this._url.query === null || this._url.query === "" ? "" : `?${this._url.query}`;
       }
       set search(v) {
-        let url2 = this._url;
+        let url = this._url;
         if (v === "") {
-          url2.query = null, this._query._list = [], this._potentiallyStripTrailingSpacesFromAnOpaquePath();
+          url.query = null, this._query._list = [], this._potentiallyStripTrailingSpacesFromAnOpaquePath();
           return;
         }
         let input = v[0] === "?" ? v.substring(1) : v;
-        url2.query = "", usm.basicURLParse(input, { url: url2, stateOverride: "query" }), this._query._list = urlencoded.parseUrlencodedString(input);
+        url.query = "", usm.basicURLParse(input, { url, stateOverride: "query" }), this._query._list = urlencoded.parseUrlencodedString(input);
       }
       get searchParams() {
         return this._query;
@@ -25536,7 +25530,7 @@ var require_URL = __commonJS({
         return;
       let ctorRegistry = utils.initCtorRegistry(globalObject);
       class URL2 {
-        constructor(url2) {
+        constructor(url) {
           if (arguments.length < 1)
             throw new globalObject.TypeError(
               `Failed to construct 'URL': 1 argument required, but only ${arguments.length} present.`
@@ -25732,7 +25726,7 @@ var require_URL = __commonJS({
             globals: globalObject
           }), esValue[implSymbol].hash = V;
         }
-        static canParse(url2) {
+        static canParse(url) {
           if (arguments.length < 1)
             throw new globalObject.TypeError(
               `Failed to execute 'canParse' on 'URL': 1 argument required, but only ${arguments.length} present.`
@@ -26496,11 +26490,11 @@ var require_lib2 = __commonJS({
       let orig = new URL$1(original).protocol, dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch4(url2, opts) {
+    function fetch4(url, opts) {
       if (!fetch4.Promise)
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       return Body2.Promise = fetch4.Promise, new fetch4.Promise(function(resolve, reject) {
-        let request = new Request2(url2, opts), options2 = getNodeRequestOptions2(request), send = (options2.protocol === "https:" ? https3 : http3).request, signal = request.signal, response = null, abort = function() {
+        let request = new Request2(url, opts), options2 = getNodeRequestOptions2(request), send = (options2.protocol === "https:" ? https3 : http3).request, signal = request.signal, response = null, abort = function() {
           let error = new AbortError3("The user aborted a request.");
           reject(error), request.body && request.body instanceof Stream3.Readable && destroyStream(request.body, error), !(!response || !response.body) && response.body.emit("error", error);
         };
@@ -26663,8 +26657,8 @@ var require_lib2 = __commonJS({
 var require_node_ponyfill = __commonJS({
   "../../node_modules/.pnpm/cross-fetch@3.1.8/node_modules/cross-fetch/dist/node-ponyfill.js"(exports2, module2) {
     init_cjs_shims();
-    var nodeFetch = require_lib2(), realFetch = nodeFetch.default || nodeFetch, fetch4 = function(url2, options2) {
-      return /^\/\//.test(url2) && (url2 = "https:" + url2), realFetch.call(this, url2, options2);
+    var nodeFetch = require_lib2(), realFetch = nodeFetch.default || nodeFetch, fetch4 = function(url, options2) {
+      return /^\/\//.test(url) && (url = "https:" + url), realFetch.call(this, url, options2);
     };
     fetch4.ponyfill = !0;
     module2.exports = exports2 = fetch4;
@@ -26840,428 +26834,6 @@ var require_form_data2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/utils.js
-var require_utils2 = __commonJS({
-  "../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/utils.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    var cp = __require("child_process"), UNIT_MB = 1024 * 1024, utils = {
-      /**
-       * exec command with maxBuffer size
-       */
-      exec(cmd, callback) {
-        cp.exec(cmd, {
-          maxBuffer: 2 * UNIT_MB,
-          windowsHide: !0
-        }, callback);
-      },
-      /**
-       * spawn command
-       */
-      spawn(cmd, args, options2) {
-        return cp.spawn(cmd, args, options2);
-      },
-      /**
-       * Strip top lines of text
-       *
-       * @param  {String} text
-       * @param  {Number} num
-       * @return {String}
-       */
-      stripLine(text, num) {
-        let idx = 0;
-        for (; num-- > 0; ) {
-          let nIdx = text.indexOf(`
-`, idx);
-          nIdx >= 0 && (idx = nIdx + 1);
-        }
-        return idx > 0 ? text.substring(idx) : text;
-      },
-      /**
-       * Split string and stop at max parts
-       *
-       * @param  {Number} line
-       * @param  {Number} max
-       * @return {Array}
-       */
-      split(line, max) {
-        let cols = line.trim().split(/\s+/);
-        return cols.length > max && (cols[max - 1] = cols.slice(max - 1).join(" ")), cols;
-      },
-      /**
-       * Extract columns from table text
-       *
-       * Example:
-       *
-       * ```
-       * extractColumns(text, [0, 2], 3)
-       * ```
-       *
-       * From:
-       * ```
-       * foo       bar        bar2
-       * valx      valy       valz
-       * ```
-       *
-       * To:
-       * ```
-       * [ ['foo', 'bar2'], ['valx', 'valz'] ]
-       * ```
-       *
-       * @param  {String} text  raw table text
-       * @param  {Array} idxes  the column index list to extract
-       * @param  {Number} max   max column number of table
-       * @return {Array}
-       */
-      extractColumns(text, idxes, max) {
-        let lines = text.split(/(\r\n|\n|\r)/), columns = [];
-        return max || (max = Math.max.apply(null, idxes) + 1), lines.forEach((line) => {
-          let cols = utils.split(line, max), column = [];
-          idxes.forEach((idx) => {
-            column.push(cols[idx] || "");
-          }), columns.push(column);
-        }), columns;
-      },
-      /**
-       * parse table text to array
-       *
-       * From:
-       * ```
-       * Header1 : foo
-       * Header2 : bar
-       * Header3 : val
-       *
-       * Header1 : foo2
-       * Header2 : bar2
-       * Header3 : val2
-       * ```
-       *
-       * To:
-       * ```
-       * [{ Header1: 'foo', Header2: 'bar', Header3: 'val' }, ...]
-       * ```
-       *
-       * @param  {String} data raw table data
-       * @return {Array}
-       */
-      parseTable(data) {
-        let lines = data.split(/(\r\n\r\n|\r\n\n|\n\r\n)|\n\n/).filter((line) => line.trim().length > 0).map((e) => e.split(/(\r\n|\n|\r)/).filter((line) => line.trim().length > 0));
-        return lines.forEach((line) => {
-          for (let index = 0; line[index]; ) {
-            let entry = line[index];
-            entry.startsWith(" ") ? (line[index - 1] += entry.trimLeft(), line.splice(index, 1)) : index += 1;
-          }
-        }), lines.map((line) => {
-          let row = {};
-          return line.forEach((string) => {
-            let splitterIndex = string.indexOf(":"), key = string.slice(0, splitterIndex).trim();
-            row[key] = string.slice(splitterIndex + 1).trim();
-          }), row;
-        });
-      }
-    };
-    module2.exports = utils;
-  }
-});
-
-// ../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find_pid.js
-var require_find_pid = __commonJS({
-  "../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find_pid.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    var os = __require("os"), fs = __require("fs"), utils = require_utils2(), ensureDir = (path) => new Promise((resolve, reject) => {
-      fs.existsSync(path) ? resolve() : fs.mkdir(path, (err2) => {
-        err2 ? reject(err2) : resolve();
-      });
-    }), finders = {
-      darwin(port) {
-        return new Promise((resolve, reject) => {
-          utils.exec("netstat -anv -p TCP && netstat -anv -p UDP", function(err2, stdout, stderr) {
-            if (err2)
-              reject(err2);
-            else {
-              if (err2 = stderr.toString().trim(), err2) {
-                reject(err2);
-                return;
-              }
-              let data = utils.stripLine(stdout.toString(), 2), found = utils.extractColumns(data, [0, 3, 8], 10).filter((row) => !!String(row[0]).match(/^(udp|tcp)/)).find((row) => {
-                let matches = String(row[1]).match(/\.(\d+)$/);
-                if (matches && matches[1] === String(port))
-                  return !0;
-              });
-              found && found[2].length ? resolve(parseInt(found[2], 10)) : reject(new Error(`pid of port (${port}) not found`));
-            }
-          });
-        });
-      },
-      freebsd: "darwin",
-      sunos: "darwin",
-      linux(port) {
-        return new Promise((resolve, reject) => {
-          let cmd = "netstat -tunlp";
-          utils.exec(cmd, function(err2, stdout, stderr) {
-            if (err2)
-              reject(err2);
-            else {
-              let warn = stderr.toString().trim();
-              warn && console.warn(warn);
-              let data = utils.stripLine(stdout.toString(), 2), columns = utils.extractColumns(data, [3, 6], 7).find((column) => {
-                let matches = String(column[0]).match(/:(\d+)$/);
-                if (matches && matches[1] === String(port))
-                  return !0;
-              });
-              if (columns && columns[1]) {
-                let pid = columns[1].split("/", 1)[0];
-                pid.length ? resolve(parseInt(pid, 10)) : reject(new Error(`pid of port (${port}) not found`));
-              } else
-                reject(new Error(`pid of port (${port}) not found`));
-            }
-          });
-        });
-      },
-      win32(port) {
-        return new Promise((resolve, reject) => {
-          utils.exec("netstat -ano", function(err2, stdout, stderr) {
-            if (err2)
-              reject(err2);
-            else {
-              if (err2 = stderr.toString().trim(), err2) {
-                reject(err2);
-                return;
-              }
-              let data = utils.stripLine(stdout.toString(), 4), columns = utils.extractColumns(data, [1, 4], 5).find((column) => {
-                let matches = String(column[0]).match(/:(\d+)$/);
-                if (matches && matches[1] === String(port))
-                  return !0;
-              });
-              columns && columns[1].length && parseInt(columns[1], 10) > 0 ? resolve(parseInt(columns[1], 10)) : reject(new Error(`pid of port (${port}) not found`));
-            }
-          });
-        });
-      },
-      android(port) {
-        return new Promise((resolve, reject) => {
-          let dir = os.tmpdir() + "/.find-process", file = dir + "/" + process.pid, cmd = 'netstat -tunp >> "' + file + '"';
-          ensureDir(dir).then(() => {
-            utils.exec(cmd, () => {
-              fs.readFile(file, "utf8", (err2, data) => {
-                if (fs.unlink(file, () => {
-                }), err2)
-                  reject(err2);
-                else {
-                  data = utils.stripLine(data, 2);
-                  let columns = utils.extractColumns(data, [3, 6], 7).find((column) => {
-                    let matches = String(column[0]).match(/:(\d+)$/);
-                    if (matches && matches[1] === String(port))
-                      return !0;
-                  });
-                  if (columns && columns[1]) {
-                    let pid = columns[1].split("/", 1)[0];
-                    pid.length ? resolve(parseInt(pid, 10)) : reject(new Error(`pid of port (${port}) not found`));
-                  } else
-                    reject(new Error(`pid of port (${port}) not found`));
-                }
-              });
-            });
-          });
-        });
-      }
-    };
-    function findPidByPort(port) {
-      let platform = process.platform;
-      return new Promise((resolve, reject) => {
-        if (!(platform in finders))
-          return reject(new Error(`platform ${platform} is unsupported`));
-        let findPid = finders[platform];
-        typeof findPid == "string" && (findPid = finders[findPid]), findPid(port).then(resolve, reject);
-      });
-    }
-    module2.exports = findPidByPort;
-  }
-});
-
-// ../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find_process.js
-var require_find_process = __commonJS({
-  "../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find_process.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    var path = __require("path"), utils = require_utils2();
-    function matchName(text, name) {
-      return name ? text && text.match ? text.match(name) : !1 : !0;
-    }
-    function fetchBin(cmd) {
-      let pieces = cmd.split(path.sep), last = pieces[pieces.length - 1];
-      last && (pieces[pieces.length - 1] = last.split(" ")[0]);
-      let fixed = [];
-      for (let part of pieces) {
-        let optIdx = part.indexOf(" -");
-        if (optIdx >= 0) {
-          fixed.push(part.substring(0, optIdx).trim());
-          break;
-        } else if (part.endsWith(" ")) {
-          fixed.push(part.trim());
-          break;
-        }
-        fixed.push(part);
-      }
-      return fixed.join(path.sep);
-    }
-    function fetchName(fullpath) {
-      if (process.platform === "darwin") {
-        let idx = fullpath.indexOf(".app/");
-        if (idx >= 0)
-          return path.basename(fullpath.substring(0, idx));
-      }
-      return path.basename(fullpath);
-    }
-    var finders = {
-      darwin(cond) {
-        return new Promise((resolve, reject) => {
-          let cmd;
-          "pid" in cond ? cmd = `ps -p ${cond.pid} -ww -o pid,ppid,uid,gid,args` : cmd = "ps ax -ww -o pid,ppid,uid,gid,args", utils.exec(cmd, function(err2, stdout, stderr) {
-            if (err2)
-              "pid" in cond ? resolve([]) : reject(err2);
-            else {
-              if (err2 = stderr.toString().trim(), err2) {
-                reject(err2);
-                return;
-              }
-              let data = utils.stripLine(stdout.toString(), 1), list = utils.extractColumns(data, [0, 1, 2, 3, 4], 5).filter((column) => column[0] && cond.pid ? column[0] === String(cond.pid) : column[4] && cond.name ? matchName(column[4], cond.name) : !!column[0]).map((column) => {
-                let cmd2 = String(column[4]), bin = fetchBin(cmd2);
-                return {
-                  pid: parseInt(column[0], 10),
-                  ppid: parseInt(column[1], 10),
-                  uid: parseInt(column[2], 10),
-                  gid: parseInt(column[3], 10),
-                  name: fetchName(bin),
-                  bin,
-                  cmd: column[4]
-                };
-              });
-              cond.strict && cond.name && (list = list.filter((item) => item.name === cond.name)), resolve(list);
-            }
-          });
-        });
-      },
-      linux: "darwin",
-      sunos: "darwin",
-      freebsd: "darwin",
-      win32(cond) {
-        return new Promise((resolve, reject) => {
-          let cmd = "Get-CimInstance -className win32_process | select Name,ProcessId,ParentProcessId,CommandLine,ExecutablePath", lines = [], proc = utils.spawn("powershell.exe", ["/c", cmd], { detached: !1, windowsHide: !0 });
-          proc.stdout.on("data", (data) => {
-            lines.push(data.toString());
-          }), proc.on("close", (code) => {
-            if (code !== 0)
-              return reject(new Error("Command '" + cmd + "' terminated with code: " + code));
-            let list = utils.parseTable(lines.join("")).filter((row) => {
-              if ("pid" in cond)
-                return row.ProcessId === String(cond.pid);
-              if (cond.name) {
-                let rowName = row.Name || "";
-                return cond.strict ? rowName === cond.name || rowName.endsWith(".exe") && rowName.slice(0, -4) === cond.name : matchName(row.CommandLine || rowName, cond.name);
-              } else
-                return !0;
-            }).map((row) => ({
-              pid: parseInt(row.ProcessId, 10),
-              ppid: parseInt(row.ParentProcessId, 10),
-              // uid: void 0,
-              // gid: void 0,
-              bin: row.ExecutablePath,
-              name: row.Name || "",
-              cmd: row.CommandLine
-            }));
-            resolve(list);
-          });
-        });
-      },
-      android(cond) {
-        return new Promise((resolve, reject) => {
-          let cmd = "ps";
-          utils.exec(cmd, function(err2, stdout, stderr) {
-            if (err2)
-              "pid" in cond ? resolve([]) : reject(err2);
-            else {
-              if (err2 = stderr.toString().trim(), err2) {
-                reject(err2);
-                return;
-              }
-              let data = utils.stripLine(stdout.toString(), 1), list = utils.extractColumns(data, [0, 3], 4).filter((column) => column[0] && cond.pid ? column[0] === String(cond.pid) : column[1] && cond.name ? matchName(column[1], cond.name) : !!column[0]).map((column) => {
-                let cmd2 = String(column[1]), bin = fetchBin(cmd2);
-                return {
-                  pid: parseInt(column[0], 10),
-                  // ppid: void 0,
-                  // uid: void 0,
-                  // gid: void 0,
-                  name: fetchName(bin),
-                  bin,
-                  cmd: cmd2
-                };
-              });
-              cond.strict && cond.name && (list = list.filter((item) => item.name === cond.name)), resolve(list);
-            }
-          });
-        });
-      }
-    };
-    function findProcess2(cond) {
-      let platform = process.platform;
-      return new Promise((resolve, reject) => {
-        if (!(platform in finders))
-          return reject(new Error(`platform ${platform} is unsupported`));
-        let find = finders[platform];
-        typeof find == "string" && (find = finders[find]), find(cond).then(resolve, reject);
-      });
-    }
-    module2.exports = findProcess2;
-  }
-});
-
-// ../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find.js
-var require_find = __commonJS({
-  "../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/lib/find.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    var findPid = require_find_pid(), findProcess2 = require_find_process(), findBy = {
-      port(port, strict) {
-        return findPid(port, strict).then((pid) => findBy.pid(pid, strict), () => []);
-      },
-      pid(pid, strict) {
-        return findProcess2({
-          pid,
-          strict
-        });
-      },
-      name(name, strict) {
-        return findProcess2({
-          name,
-          strict
-        });
-      }
-    };
-    function find(by, value, strict) {
-      return new Promise((resolve, reject) => {
-        if (!(by in findBy))
-          reject(new Error(`do not support find by "${by}"`));
-        else {
-          let isNumber = /^\d+$/.test(value);
-          by === "pid" && !isNumber ? reject(new Error("pid must be a number")) : by === "port" && !isNumber ? reject(new Error("port must be a number")) : findBy[by](value, strict).then(resolve, reject);
-        }
-      });
-    }
-    module2.exports = find;
-  }
-});
-
-// ../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/index.js
-var require_find_process2 = __commonJS({
-  "../../node_modules/.pnpm/find-process@1.4.7/node_modules/find-process/index.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    module2.exports = require_find();
-  }
-});
-
 // ../../node_modules/.pnpm/bottleneck@2.19.5/node_modules/bottleneck/lib/parser.js
 var require_parser2 = __commonJS({
   "../../node_modules/.pnpm/bottleneck@2.19.5/node_modules/bottleneck/lib/parser.js"(exports2) {
@@ -29719,7 +29291,7 @@ var require_lib3 = __commonJS({
 
 // ../cli-kit/dist/public/common/version.js
 init_cjs_shims();
-var CLI_KIT_VERSION = "3.68.0";
+var CLI_KIT_VERSION = "3.69.0";
 
 // ../cli-kit/dist/private/node/analytics.js
 init_cjs_shims();
@@ -32640,8 +32212,8 @@ async function shouldRejectUnauthorizedRequests() {
 
 // ../cli-kit/dist/private/node/api/urls.js
 init_cjs_shims();
-function sanitizeURL(url2) {
-  let parsedUrl = new URL(url2);
+function sanitizeURL(url) {
+  let parsedUrl = new URL(url);
   return parsedUrl.searchParams.has("subject_token") && parsedUrl.searchParams.set("subject_token", "****"), parsedUrl.searchParams.has("token") && parsedUrl.searchParams.set("token", "****"), parsedUrl.toString();
 }
 
@@ -32900,7 +32472,7 @@ var resolveHeaders = (headers) => {
   }), acc), []);
   return `query=${encodeURIComponent(params_.jsonSerializer.stringify(payload))}`;
 }, createHttpMethodFetcher = (method) => async (params) => {
-  let { url: url2, query, variables, operationName, fetch: fetch4, fetchOptions, middleware } = params, headers = { ...params.headers }, queryParams = "", body;
+  let { url, query, variables, operationName, fetch: fetch4, fetchOptions, middleware } = params, headers = { ...params.headers }, queryParams = "", body;
   method === "POST" ? (body = createRequestBody_default(query, variables, operationName, fetchOptions.jsonSerializer), typeof body == "string" && (headers["Content-Type"] = "application/json")) : queryParams = buildRequestConfig({
     query,
     variables,
@@ -32912,20 +32484,20 @@ var resolveHeaders = (headers) => {
     headers,
     body,
     ...fetchOptions
-  }, urlResolved = url2, initResolved = init;
+  }, urlResolved = url, initResolved = init;
   if (middleware) {
-    let result = await Promise.resolve(middleware({ ...init, url: url2, operationName, variables })), { url: urlNew, ...initNew } = result;
+    let result = await Promise.resolve(middleware({ ...init, url, operationName, variables })), { url: urlNew, ...initNew } = result;
     urlResolved = urlNew, initResolved = initNew;
   }
   return queryParams && (urlResolved = `${urlResolved}?${queryParams}`), await fetch4(urlResolved, initResolved);
 }, GraphQLClient = class {
-  constructor(url2, requestConfig = {}) {
-    this.url = url2, this.requestConfig = requestConfig, this.rawRequest = async (...args) => {
-      let [queryOrOptions, variables, requestHeaders] = args, rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url3 } = this;
+  constructor(url, requestConfig = {}) {
+    this.url = url, this.requestConfig = requestConfig, this.rawRequest = async (...args) => {
+      let [queryOrOptions, variables, requestHeaders] = args, rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url2 } = this;
       rawRequestOptions.signal !== void 0 && (fetchOptions.signal = rawRequestOptions.signal);
       let { operationName } = resolveRequestDocument(rawRequestOptions.query);
       return makeRequest({
-        url: url3,
+        url: url2,
         query: rawRequestOptions.query,
         variables: rawRequestOptions.variables,
         headers: {
@@ -32943,11 +32515,11 @@ var resolveHeaders = (headers) => {
     };
   }
   async request(documentOrOptions, ...variablesAndRequestHeaders) {
-    let [variables, requestHeaders] = variablesAndRequestHeaders, requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url: url2 } = this;
+    let [variables, requestHeaders] = variablesAndRequestHeaders, requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders), { headers, fetch: fetch4 = CrossFetch.default, method = "POST", requestMiddleware, responseMiddleware, ...fetchOptions } = this.requestConfig, { url } = this;
     requestOptions.signal !== void 0 && (fetchOptions.signal = requestOptions.signal);
     let { query, operationName } = resolveRequestDocument(requestOptions.document);
     return makeRequest({
-      url: url2,
+      url,
       query,
       variables: requestOptions.variables,
       headers: {
@@ -33042,8 +32614,8 @@ var allAPIs = ["admin", "storefront-renderer", "partners", "business-platform",
 function responseHeaderIsInteresting(header) {
   return interestingResponseHeaders.has(header);
 }
-async function makeVerboseRequest({ request, url: url2 }) {
-  let t0 = performance.now(), duration = 0, responseHeaders = {}, sanitizedUrl = sanitizeURL(url2), response = {};
+async function makeVerboseRequest({ request, url }) {
+  let t0 = performance.now(), duration = 0, responseHeaders = {}, sanitizedUrl = sanitizeURL(url), response = {};
   try {
     response = await request(), response.headers.forEach((value, key) => {
       responseHeaderIsInteresting(key) && (responseHeaders[key] = value);
@@ -33051,11 +32623,11 @@ async function makeVerboseRequest({ request, url: url2 }) {
   } catch (err2) {
     let t12 = performance.now();
     if (duration = Math.round(t12 - t0), err2 instanceof ClientError) {
-      if (err2.response?.headers)
-        for (let [key, value] of err2.response?.headers)
+      if (err2.response.headers)
+        for (let [key, value] of err2.response.headers)
           responseHeaderIsInteresting(key) && (responseHeaders[key] = value);
       let sanitizedHeaders = sanitizedHeadersOutput(responseHeaders);
-      if (err2.response.errors?.some((error) => error.extensions?.code === "429") || err2.response.status === 429) {
+      if (err2.response.errors?.some((error) => error.extensions.code === "429") || err2.response.status === 429) {
         let delayMs;
         try {
           delayMs = responseHeaders["retry-after"] ? Number.parseInt(responseHeaders["retry-after"], 10) : void 0;
@@ -33099,8 +32671,8 @@ async function makeVerboseRequest({ request, url: url2 }) {
     requestId: responseHeaders["x-request-id"]
   };
 }
-async function simpleRequestWithDebugLog({ request, url: url2 }, errorHandler2) {
-  let result = await makeVerboseRequest({ request, url: url2 });
+async function simpleRequestWithDebugLog({ request, url }, errorHandler2) {
+  let result = await makeVerboseRequest({ request, url });
   switch (outputDebug(`Request to ${result.sanitizedUrl} completed in ${result.duration} ms
 With response headers:
 ${result.sanitizedHeaders}
@@ -33115,10 +32687,10 @@ ${result.sanitizedHeaders}
       throw errorHandler2 ? errorHandler2(result.clientError, result.requestId) : result.clientError;
   }
 }
-async function retryAwareRequest({ request, url: url2 }, errorHandler2, retryOptions = {
+async function retryAwareRequest({ request, url }, errorHandler2, retryOptions = {
   scheduleDelay: setTimeout
 }) {
-  let retriesUsed = 0, limitRetriesTo = retryOptions.limitRetriesTo ?? DEFAULT_RETRY_LIMIT, result = await makeVerboseRequest({ request, url: url2 });
+  let retriesUsed = 0, limitRetriesTo = retryOptions.limitRetriesTo ?? DEFAULT_RETRY_LIMIT, result = await makeVerboseRequest({ request, url });
   for (outputDebug(`Request to ${result.sanitizedUrl} completed in ${result.duration} ms
 With response headers:
 ${result.sanitizedHeaders}
@@ -33133,9 +32705,11 @@ ${result.sanitizedHeaders}
       throw outputDebug(`${limitRetriesTo} retries exhausted for request to ${result.sanitizedUrl}`), errorHandler2 ? errorHandler2(result.clientError, result.requestId) : result.clientError;
     retriesUsed += 1;
     let retryDelayMs = result.delayMs ?? retryOptions.defaultDelayMs ?? DEFAULT_RETRY_DELAY_MS;
-    outputDebug(`Scheduling retry request #${retriesUsed} to ${result.sanitizedUrl} in ${retryDelayMs} ms`), result = await new Promise((resolve) => retryOptions.scheduleDelay(() => {
-      resolve(makeVerboseRequest({ request, url: url2 }));
-    }, retryDelayMs));
+    outputDebug(`Scheduling retry request #${retriesUsed} to ${result.sanitizedUrl} in ${retryDelayMs} ms`), result = await new Promise((resolve) => {
+      retryOptions.scheduleDelay(() => {
+        resolve(makeVerboseRequest({ request, url }));
+      }, retryDelayMs);
+    });
   }
 }
 
@@ -33571,12 +33145,12 @@ var INTERNALS2 = Symbol("Response internals"), Response = class _Response extend
    * @param {number} status An optional status code for the response (e.g., 302.)
    * @returns {Response}    A Response object.
    */
-  static redirect(url2, status = 302) {
+  static redirect(url, status = 302) {
     if (!isRedirect(status))
       throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
     return new _Response(null, {
       headers: {
-        location: new URL(url2).toString()
+        location: new URL(url).toString()
       },
       status
     });
@@ -33627,8 +33201,8 @@ var getSearch = (parsedURL) => {
 // ../../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/referrer.js
 init_cjs_shims();
 import { isIP } from "node:net";
-function stripURLForUseAsAReferrer(url2, originOnly = !1) {
-  return url2 == null || (url2 = new URL(url2), /^(about|blob|data):$/.test(url2.protocol)) ? "no-referrer" : (url2.username = "", url2.password = "", url2.hash = "", originOnly && (url2.pathname = "", url2.search = ""), url2);
+function stripURLForUseAsAReferrer(url, originOnly = !1) {
+  return url == null || (url = new URL(url), /^(about|blob|data):$/.test(url.protocol)) ? "no-referrer" : (url.username = "", url.password = "", url.hash = "", originOnly && (url.pathname = "", url.search = ""), url);
 }
 var ReferrerPolicy = /* @__PURE__ */ new Set([
   "",
@@ -33646,14 +33220,14 @@ function validateReferrerPolicy(referrerPolicy) {
     throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
   return referrerPolicy;
 }
-function isOriginPotentiallyTrustworthy(url2) {
-  if (/^(http|ws)s:$/.test(url2.protocol))
+function isOriginPotentiallyTrustworthy(url) {
+  if (/^(http|ws)s:$/.test(url.protocol))
     return !0;
-  let hostIp = url2.host.replace(/(^\[)|(]$)/g, ""), hostIPVersion = isIP(hostIp);
-  return hostIPVersion === 4 && /^127\./.test(hostIp) || hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp) ? !0 : url2.host === "localhost" || url2.host.endsWith(".localhost") ? !1 : url2.protocol === "file:";
+  let hostIp = url.host.replace(/(^\[)|(]$)/g, ""), hostIPVersion = isIP(hostIp);
+  return hostIPVersion === 4 && /^127\./.test(hostIp) || hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp) ? !0 : url.host === "localhost" || url.host.endsWith(".localhost") ? !1 : url.protocol === "file:";
 }
-function isUrlPotentiallyTrustworthy(url2) {
-  return /^about:(blank|srcdoc)$/.test(url2) || url2.protocol === "data:" || /^(blob|filesystem):$/.test(url2.protocol) ? !0 : isOriginPotentiallyTrustworthy(url2);
+function isUrlPotentiallyTrustworthy(url) {
+  return /^about:(blank|srcdoc)$/.test(url) || url.protocol === "data:" || /^(blob|filesystem):$/.test(url.protocol) ? !0 : isOriginPotentiallyTrustworthy(url);
 }
 function determineRequestsReferrer(request, { referrerURLCallback, referrerOriginCallback } = {}) {
   if (request.referrer === "no-referrer" || request.referrerPolicy === "")
@@ -33828,11 +33402,11 @@ var AbortError2 = class extends FetchBaseError {
 
 // ../../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/index.js
 var supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
-async function fetch(url2, options_) {
+async function fetch(url, options_) {
   return new Promise((resolve, reject) => {
-    let request = new Request(url2, options_), { parsedURL, options: options2 } = getNodeRequestOptions(request);
+    let request = new Request(url, options_), { parsedURL, options: options2 } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol))
-      throw new TypeError(`node-fetch cannot load ${url2}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
+      throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
     if (parsedURL.protocol === "data:") {
       let data = dist_default(request.url), response2 = new Response(data, { headers: { "Content-Type": data.typeFull } });
       resolve(response2);
@@ -34003,11 +33577,11 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
 function formData() {
   return new import_form_data2.default();
 }
-async function fetch2(url2, init) {
-  return runWithTimer("cmd_all_timing_network_ms")(() => simpleRequestWithDebugLog({ url: url2.toString(), request: () => fetch(url2, init) }));
+async function fetch2(url, init) {
+  return runWithTimer("cmd_all_timing_network_ms")(() => simpleRequestWithDebugLog({ url: url.toString(), request: () => fetch(url, init) }));
 }
-async function shopifyFetch(url2, init) {
-  let sanitizedUrl = sanitizeURL(url2.toString()), options2 = {
+async function shopifyFetch(url, init) {
+  let sanitizedUrl = sanitizeURL(url.toString()), options2 = {
     ...init ?? {},
     headers: {
       ...await buildHeaders(),
@@ -34016,10 +33590,10 @@ async function shopifyFetch(url2, init) {
   };
   return outputDebug(outputContent`Sending ${options2.method ?? "GET"} request to URL ${sanitizedUrl}
 With request headers:
-${sanitizedHeadersOutput(options2?.headers ?? {})}
+${sanitizedHeadersOutput(options2.headers ?? {})}
 `), runWithTimer("cmd_all_timing_network_ms")(async () => simpleRequestWithDebugLog({
-    url: url2.toString(),
-    request: async () => fetch(url2, { ...init, agent: await httpsAgent() })
+    url: url.toString(),
+    request: async () => fetch(url, { ...init, agent: await httpsAgent() })
   }));
 }
 
@@ -34368,24 +33942,12 @@ function decodeJwt(jwt) {
 // ../cli-kit/dist/public/node/crypto.js
 init_cjs_shims();
 import crypto from "crypto";
-function randomHex(size) {
-  return crypto.randomBytes(size).toString("hex");
-}
-function base64URLEncode(str) {
-  return str.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/[=]/g, "");
-}
-function sha256(str) {
-  return crypto.createHash("sha256").update(str).digest();
-}
 function hashString(str) {
   return crypto.createHash("sha1").update(str).digest("hex");
 }
 function fileHash(buff) {
   return crypto.createHash("md5").update(buff).digest("hex");
 }
-function randomBytes(size) {
-  return crypto.randomBytes(size);
-}
 function randomUUID() {
   return crypto.randomUUID();
 }
@@ -34399,16 +33961,6 @@ var InvalidGrantError = class extends import_ts_error.ExtendableError {
 }, InvalidRequestError = class extends import_ts_error.ExtendableError {
 }, InvalidTargetError = class extends AbortError {
 };
-async function exchangeCodeForAccessToken(codeData) {
-  let clientId2 = await clientId(), params = {
-    grant_type: "authorization_code",
-    code: codeData.code,
-    redirect_uri: "http://127.0.0.1:3456",
-    client_id: clientId2,
-    code_verifier: codeData.codeVerifier
-  }, value = (await tokenRequest(params)).mapError(tokenRequestErrorHandler).valueOrBug();
-  return buildIdentityToken(value);
-}
 async function exchangeAccessForApplicationTokens(identityToken, scopes, store2) {
   let token = identityToken.accessToken, appManagementEnabled = isTruthy(process.env.USE_APP_MANAGEMENT_API), [partners, storefront, businessPlatform, admin, appManagement] = await Promise.all([
     requestAppToken("partners", token, scopes.partners),
@@ -34478,9 +34030,9 @@ If you're the store owner, then you need to log in to the store directly using t
   return error === "invalid_grant" ? new InvalidGrantError() : error === "invalid_request" ? new InvalidRequestError() : error === "invalid_target" ? new InvalidTargetError(invalidTargetErrorMessage) : new AbortError(error);
 }
 async function tokenRequest(params) {
-  let fqdn = await identityFqdn(), url2 = new URL(`https://${fqdn}/oauth/token`);
-  url2.search = new URLSearchParams(Object.entries(params)).toString();
-  let res = await shopifyFetch(url2.href, { method: "POST" }), payload = await res.json();
+  let fqdn = await identityFqdn(), url = new URL(`https://${fqdn}/oauth/token`);
+  url.search = new URLSearchParams(Object.entries(params)).toString();
+  let res = await shopifyFetch(url.href, { method: "POST" }), payload = await res.json();
   return res.ok ? ok(payload) : err(payload.error);
 }
 function buildIdentityToken(result, existingUserId) {
@@ -34503,288 +34055,6 @@ function buildApplicationToken(result) {
   };
 }
 
-// ../cli-kit/dist/private/node/session/authorize.js
-init_cjs_shims();
-
-// ../cli-kit/dist/private/node/session/redirect-listener.js
-init_cjs_shims();
-
-// ../cli-kit/dist/private/node/session/post-auth.js
-init_cjs_shims();
-var HTMLFileNames = [
-  "empty-url.html",
-  "auth-error.html",
-  "missing-code.html",
-  "missing-state.html",
-  "success.html"
-], StylesheetFilename = "style.css", FaviconFileName = "favicon.svg", getFilePath = async (fileName) => {
-  let filePath = await findPathUp(`assets/${fileName}`, {
-    type: "file",
-    cwd: moduleDirectory(import.meta.url)
-  });
-  if (!filePath)
-    throw RedirectPageAssetNotFoundError();
-  return filePath;
-}, getEmptyUrlHTML = async () => {
-  let filePath = await getFilePath(HTMLFileNames[0]);
-  return readFile(filePath);
-}, getAuthErrorHTML = async () => {
-  let filePath = await getFilePath(HTMLFileNames[1]);
-  return readFile(filePath);
-}, getMissingCodeHTML = async () => {
-  let filePath = await getFilePath(HTMLFileNames[2]);
-  return readFile(filePath);
-}, getMissingStateHTML = async () => {
-  let filePath = await getFilePath(HTMLFileNames[3]);
-  return readFile(filePath);
-}, getSuccessHTML = async () => {
-  let filePath = await getFilePath(HTMLFileNames[4]);
-  return readFile(filePath);
-}, getStylesheet = async () => {
-  let filePath = await getFilePath(StylesheetFilename);
-  return readFile(filePath);
-}, getFavicon = async () => {
-  let filePath = await getFilePath(FaviconFileName);
-  return readFile(filePath);
-}, EmptyUrlString = "We received the authentication redirect but the URL is empty.", MissingCodeString = "The authentication can't continue because the redirect doesn't include the code.", MissingStateString = "The authentication can't continue because the redirect doesn't include the state.", RedirectPageAssetNotFoundError = () => new BugError("Redirect page asset not found");
-
-// ../cli-kit/dist/private/node/session/redirect-listener.js
-import url from "url";
-import { createServer } from "http";
-var ResponseTimeoutSeconds = 10, ServerStopDelaySeconds = 0.5, RedirectListener = class _RedirectListener {
-  static createServer(callback) {
-    return createServer(async (request, response) => {
-      let requestUrl = request.url;
-      if (requestUrl?.includes("favicon")) {
-        let faviconFile = await getFavicon();
-        return response.setHeader("Content-Type", "image/svg+xml"), response.write(faviconFile), response.end(), {};
-      } else if (requestUrl === "/style.css") {
-        let stylesheetFile = await getStylesheet();
-        return response.setHeader("Content-Type", "text/css"), response.write(stylesheetFile), response.end(), {};
-      }
-      let respond = async (contents, error, state, code) => (response.setHeader("Content-Type", "text/html"), response.write(contents), response.end(), callback(error, state, code), {});
-      if (!requestUrl) {
-        let file2 = await getEmptyUrlHTML(), err2 = new BugError(EmptyUrlString);
-        return respond(file2, err2, void 0, void 0);
-      }
-      let queryObject = url.parse(requestUrl, !0).query;
-      if (queryObject.error && queryObject.error_description) {
-        let file2 = await getAuthErrorHTML(), err2 = new AbortError(`${queryObject.error_description}`);
-        return respond(file2, err2, void 0, void 0);
-      }
-      if (!queryObject.code) {
-        let file2 = await getMissingCodeHTML(), err2 = new BugError(MissingCodeString);
-        return respond(file2, err2, void 0, void 0);
-      }
-      if (!queryObject.state) {
-        let file2 = await getMissingStateHTML(), err2 = new BugError(MissingStateString);
-        return respond(file2, err2, void 0, void 0);
-      }
-      let file = await getSuccessHTML();
-      return respond(file, void 0, `${queryObject.code}`, `${queryObject.state}`);
-    });
-  }
-  constructor(options2) {
-    this.port = options2.port, this.host = options2.host, this.server = _RedirectListener.createServer(options2.callback);
-  }
-  start() {
-    this.server.listen({ port: this.port, host: this.host }, () => {
-    });
-  }
-  async stop() {
-    await this.server.close();
-  }
-};
-async function listenRedirect(host, port, url2) {
-  return await new Promise((resolve, reject) => {
-    let timeout = setTimeout(() => {
-      outputInfo(outputContent`${`
-Auto-open timed out. Open the login page: `}${outputToken.link("Log in to Shopify Partners", url2)}\n`);
-    }, ResponseTimeoutSeconds * 1e3), callback = (error, code, state) => {
-      clearTimeout(timeout), setTimeout(() => {
-        redirectListener.stop(), error ? reject(error) : resolve({ code, state });
-      }, ServerStopDelaySeconds * 1e3);
-    }, redirectListener = new RedirectListener({ host, port, callback });
-    redirectListener.start();
-  });
-}
-
-// ../../node_modules/.pnpm/get-port-please@3.0.1/node_modules/get-port-please/dist/index.mjs
-init_cjs_shims();
-import { createServer as createServer2 } from "node:net";
-import { networkInterfaces } from "node:os";
-var unsafePorts = /* @__PURE__ */ new Set([
-  1,
-  7,
-  9,
-  11,
-  13,
-  15,
-  17,
-  19,
-  20,
-  21,
-  22,
-  23,
-  25,
-  37,
-  42,
-  43,
-  53,
-  69,
-  77,
-  79,
-  87,
-  95,
-  101,
-  102,
-  103,
-  104,
-  109,
-  110,
-  111,
-  113,
-  115,
-  117,
-  119,
-  123,
-  135,
-  137,
-  139,
-  143,
-  161,
-  179,
-  389,
-  427,
-  465,
-  512,
-  513,
-  514,
-  515,
-  526,
-  530,
-  531,
-  532,
-  540,
-  548,
-  554,
-  556,
-  563,
-  587,
-  601,
-  636,
-  989,
-  990,
-  993,
-  995,
-  1719,
-  1720,
-  1723,
-  2049,
-  3659,
-  4045,
-  5060,
-  5061,
-  6e3,
-  6566,
-  6665,
-  6666,
-  6667,
-  6668,
-  6669,
-  6697,
-  10080
-]);
-function isUnsafePort(port) {
-  return unsafePorts.has(port);
-}
-function isSafePort(port) {
-  return !isUnsafePort(port);
-}
-function log(...arguments_) {
-  console.log("[get-port]", ...arguments_);
-}
-async function getRandomPort(host) {
-  let port = await checkPort(0, host);
-  if (port === !1)
-    throw new Error("Unable to obtain an available random port number!");
-  return port;
-}
-async function checkPort(port, host = process.env.HOST, _verbose) {
-  if (host || (host = getLocalHosts([void 0, "0.0.0.0"])), !Array.isArray(host))
-    return _checkPort(port, host);
-  for (let _host of host) {
-    let _port = await _checkPort(port, _host);
-    if (_port === !1)
-      return port < 1024 && _verbose && log("Unable to listen to priviliged port:", `${_host}:${port}`), !1;
-    port === 0 && _port !== 0 && (port = _port);
-  }
-  return port;
-}
-function _checkPort(port, host) {
-  return new Promise((resolve) => {
-    let server = createServer2();
-    server.unref(), server.on("error", (error) => {
-      error.code === "EINVAL" || error.code === "EADDRNOTAVAIL" ? resolve(port !== 0 && isSafePort(port) && port) : resolve(!1);
-    }), server.listen({ port, host }, () => {
-      let { port: port2 } = server.address();
-      server.close(() => {
-        resolve(isSafePort(port2) && port2);
-      });
-    });
-  });
-}
-function getLocalHosts(additional) {
-  let hosts = new Set(additional);
-  for (let _interface of Object.values(networkInterfaces()))
-    for (let config of _interface || [])
-      hosts.add(config.address);
-  return [...hosts];
-}
-
-// ../cli-kit/dist/private/node/session/authorize.js
-var import_find_process = __toESM(require_find_process2(), 1);
-async function authorize(scopes, state = randomHex(30)) {
-  let host = "127.0.0.1", redirectUri = `http://${host}:3456`, fqdn = await identityFqdn(), identityClientId = clientId();
-  await validateRedirectionPortAvailability(3456);
-  let url2 = `http://${fqdn}/oauth/authorize`, { codeVerifier, codeChallenge } = generateRandomChallengePair(), params = {
-    client_id: identityClientId,
-    scope: scopes.join(" "),
-    redirect_uri: redirectUri,
-    state,
-    response_type: "code",
-    code_challenge_method: "S256",
-    code_challenge: codeChallenge
-  };
-  return outputInfo(`
-To run this command, log in to Shopify.`), outputInfo("\u{1F449} Press any key to open the login page on your browser"), await keypress(), url2 = `${url2}?${new URLSearchParams(params).toString()}`, await openURL(url2), runWithTimer("cmd_all_timing_prompts_ms")(async () => {
-    let result = await listenRedirect(host, 3456, url2);
-    if (result.state !== state)
-      throw new AbortError("The state received from the authentication doesn't match the one that initiated the authentication process.");
-    return { code: result.code, codeVerifier };
-  });
-}
-function generateRandomChallengePair() {
-  let codeVerifier = base64URLEncode(randomBytes(32)), codeChallenge = base64URLEncode(sha256(codeVerifier));
-  return { codeVerifier, codeChallenge };
-}
-async function validateRedirectionPortAvailability(port) {
-  let { killPortProcess } = await import("./lib-H3ZZGS7I.js");
-  if (!await checkPort(port))
-    if (await terminateBlockingPortProcessPrompt(port, "Authentication"))
-      await killPortProcess(port);
-    else
-      throw new CancelExecution();
-}
-async function terminateBlockingPortProcessPrompt(port, stepDescription) {
-  let processInfo = await (0, import_find_process.default)("port", port), formattedProcessName = processInfo && processInfo.length > 0 && processInfo[0]?.name ? ` (${processInfo[0].name})` : "";
-  return renderConfirmationPrompt({
-    message: `${stepDescription} requires a port ${port} that's unavailable because it's running another process${formattedProcessName}. Terminate that process?`,
-    confirmationMessage: "Yes, terminate process in order to log in now",
-    cancellationMessage: "No, cancel command and try later"
-  });
-}
-
 // ../cli-kit/dist/private/node/session/store.js
 init_cjs_shims();
 async function store(session) {
@@ -34807,7 +34077,7 @@ async function remove() {
 // ../cli-kit/dist/private/node/session/device-authorization.js
 init_cjs_shims();
 async function requestDeviceAuthorization(scopes) {
-  let fqdn = await identityFqdn(), queryParams = { client_id: clientId(), scope: scopes.join(" ") }, url2 = `https://${fqdn}/oauth/device_authorization`, jsonResult = await (await shopifyFetch(url2, {
+  let fqdn = await identityFqdn(), queryParams = { client_id: clientId(), scope: scopes.join(" ") }, url = `https://${fqdn}/oauth/device_authorization`, jsonResult = await (await shopifyFetch(url, {
     method: "POST",
     headers: { "Content-type": "application/x-www-form-urlencoded" },
     body: convertRequestToParams(queryParams)
@@ -34833,18 +34103,26 @@ async function pollForDeviceAuthorization(code, interval = 5) {
   return new Promise((resolve, reject) => {
     let onPoll = async () => {
       let result = await exchangeDeviceCodeForAccessToken(code);
-      if (!result.isErr())
-        return resolve(result.value);
+      if (!result.isErr()) {
+        resolve(result.value);
+        return;
+      }
       let error = result.error ?? "unknown_failure";
       switch (outputDebug(outputContent`Polling for device authorization... status: ${error}`), error) {
-        case "authorization_pending":
-          return startPolling();
+        case "authorization_pending": {
+          startPolling();
+          return;
+        }
         case "slow_down":
-          return currentIntervalInSeconds += 5, startPolling();
+          currentIntervalInSeconds += 5;
+          {
+            startPolling();
+            return;
+          }
         case "access_denied":
         case "expired_token":
         case "unknown_failure":
-          return reject(result);
+          reject(result);
       }
     }, startPolling = () => {
       setTimeout(onPoll, currentIntervalInSeconds * 1e3);
@@ -34863,8 +34141,10 @@ function restRequestBody(requestBody) {
     return JSON.stringify(requestBody);
 }
 function restRequestUrl(session, apiVersion, path, searchParams = {}, env = process.env) {
-  let themeKitAccessDomain = env[environmentVariables.themeKitAccessDomain] || defaultThemeKitAccessDomain, url2 = new URL(isThemeAccessSession(session) ? `https://${themeKitAccessDomain}/cli/admin/api/${apiVersion}${path}.json` : `https://${session.storeFqdn}/admin/api/${apiVersion}${path}.json`);
-  return Object.entries(searchParams).forEach(([name, value]) => url2.searchParams.set(name, value)), url2.toString();
+  let themeKitAccessDomain = env[environmentVariables.themeKitAccessDomain] || defaultThemeKitAccessDomain, url = new URL(isThemeAccessSession(session) ? `https://${themeKitAccessDomain}/cli/admin/api/${apiVersion}${path}.json` : `https://${session.storeFqdn}/admin/api/${apiVersion}${path}.json`);
+  return Object.entries(searchParams).forEach(([name, value]) => {
+    url.searchParams.set(name, value);
+  }), url.toString();
 }
 function restRequestHeaders(session) {
   let store2 = session.storeFqdn, token = session.token, headers = buildHeaders(session.token);
@@ -34917,15 +34197,23 @@ Request ID: ${requestId}
 
 // ../cli-kit/dist/public/node/api/graphql.js
 async function performGraphQLRequest(options2) {
-  let { token, addedHeaders, queryAsString, variables, api, url: url2, responseOptions } = options2, headers = {
+  let { token, addedHeaders, queryAsString, variables, api, url, responseOptions } = options2, headers = {
     ...addedHeaders,
     ...buildHeaders(token)
   };
   debugLogRequestInfo(api, queryAsString, variables, headers);
-  let clientOptions = { agent: await httpsAgent(), headers }, client = new GraphQLClient(url2, clientOptions);
+  let clientOptions = { agent: await httpsAgent(), headers }, client = new GraphQLClient(url, clientOptions);
   return runWithTimer("cmd_all_timing_network_ms")(async () => {
-    let response = await retryAwareRequest({ request: () => client.rawRequest(queryAsString, variables), url: url2 }, responseOptions?.handleErrors === !1 ? void 0 : errorHandler(api));
-    return responseOptions?.onResponse && responseOptions.onResponse(response), response.data;
+    let response = await retryAwareRequest({ request: () => client.rawRequest(queryAsString, variables), url }, responseOptions?.handleErrors === !1 ? void 0 : errorHandler(api));
+    responseOptions?.onResponse && responseOptions.onResponse(response);
+    try {
+      let requestId = response.headers.get("x-request-id");
+      await addPublicMetadata(async () => ({
+        cmd_all_last_graphql_request_id: requestId ?? void 0
+      }));
+    } catch {
+    }
+    return response.data;
   });
 }
 async function graphqlRequest(options2) {
@@ -34971,11 +34259,11 @@ var import_bottleneck = __toESM(require_lib3(), 1), limiter = new import_bottlen
   maxConcurrent: 10
 });
 async function setupRequest(token) {
-  let api = "Partners", url2 = `https://${await partnersFqdn()}/api/cli/graphql`;
+  let api = "Partners", url = `https://${await partnersFqdn()}/api/cli/graphql`;
   return {
     token,
     api,
-    url: url2,
+    url,
     responseOptions: { onResponse: handleDeprecations }
   };
 }
@@ -35102,14 +34390,10 @@ async function executeCompleteFlow(applications, identityFqdn2) {
   let identityToken, identityTokenInformation = getIdentityTokenInformation();
   if (identityTokenInformation)
     identityToken = buildIdentityTokenFromEnv(scopes, identityTokenInformation);
-  else if (useDeviceAuth()) {
+  else {
     outputDebug(outputContent`Requesting device authorization code...`);
     let deviceAuth = await requestDeviceAuthorization(scopes);
     outputDebug(outputContent`Starting polling for the identity token...`), identityToken = await pollForDeviceAuthorization(deviceAuth.deviceCode, deviceAuth.interval);
-  } else {
-    outputDebug(outputContent`Authorizing through Identity's website...`);
-    let code = await authorize(scopes);
-    outputDebug(outputContent`Authorization code received. Exchanging it for a CLI token...`), identityToken = await exchangeCodeForAccessToken(code);
   }
   outputDebug(outputContent`CLI token received. Exchanging it for application tokens...`);
   let result = await exchangeAccessForApplicationTokens(identityToken, exchangeScopes, store2), session = {
@@ -35337,8 +34621,6 @@ export {
   ok,
   err,
   exchangeCustomPartnerToken,
-  getRandomPort,
-  checkPort,
   restRequestBody,
   restRequestUrl,
   restRequestHeaders,
@@ -35375,4 +34657,4 @@ mime-types/index.js:
    * MIT Licensed
    *)
 */
-//# sourceMappingURL=chunk-TOQEXS2N.js.map
+//# sourceMappingURL=chunk-XMQLNGN7.js.map