@shopify/cli-kit 3.0.18 → 3.0.21

package/dist/{index-46c26c7f.js → index-21b8e2fe.js}

@@ -1,4 +1,5 @@
 import require$$0$2, { sep as sep$1, extname as extname$1, resolve as resolve$4, dirname as dirname$2 } from 'path';
+import Url, { fileURLToPath as fileURLToPath$1 } from 'url';
 import path$I from 'node:path';
 import url$2, { fileURLToPath, pathToFileURL, format as format$6 } from 'node:url';
 import process$2, { platform as platform$2 } from 'node:process';
@@ -28,9 +29,8 @@ import http$4 from 'node:http';
 import https$3 from 'node:https';
 import zlib$2 from 'node:zlib';
 import { isIP } from 'node:net';
-import http$5 from 'http';
+import require$$4 from 'http';
 import require$$1$3 from 'https';
-import Url from 'url';
 import require$$0$b from 'readline';
 import inquirer from 'inquirer';
 import require$$0$c from 'dns';
@@ -40,6 +40,7 @@ import require$$1$4 from 'tls';
 import require$$0$e, { createServer } from 'net';
 import require$$0$f from 'punycode';
 import { parse as parse$i, stringify as stringify$f } from 'envfile';
+import Fastify__default from 'fastify';
 import { createRequire } from 'module';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -7127,10 +7128,14 @@ function relativize(path) {
     return relativePath;
   }
 }
+function moduleDirectory(moduleURL) {
+  return dirname$1(fileURLToPath$1(moduleURL));
+}
 
 var path$w = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	relativize: relativize,
+	moduleDirectory: moduleDirectory,
 	findUp: findUp$2,
 	glob: out,
 	pathToFileURL: pathToFileURL,
@@ -7151,7 +7156,7 @@ var path$w = /*#__PURE__*/Object.freeze({
 });
 
 var name = "@shopify/cli-kit";
-var version$2 = "3.0.18";
+var version$2 = "3.0.21";
 var description$1 = "A set of utilities, interfaces, and models that are common across all the platform features";
 var keywords = [
 	"shopify",
@@ -7169,7 +7174,8 @@ var exports = {
 	}
 };
 var files = [
-	"/dist"
+	"/dist",
+	"/assets"
 ];
 var publishConfig = {
 	access: "public",
@@ -7206,7 +7212,8 @@ var dependencies$1 = {
 	open: "^8.4.0",
 	prettier: "^2.6.2",
 	"source-map-support": "^0.5.21",
-	stacktracey: "^2.1.8"
+	stacktracey: "^2.1.8",
+	fastify: "^4.0.0-rc.4"
 };
 var devDependencies = {
 	"@iarna/toml": "^2.2.5",
@@ -7247,7 +7254,7 @@ var devDependencies = {
 	tempy: "^2.0.0",
 	"term-size": "^3.0.1",
 	"terminal-link": "^3.0.0",
-	vitest: "0.13.1",
+	vitest: "^0.15.1",
 	zod: "^3.17.3"
 };
 var cliKitPackageJson = {
@@ -13352,51 +13359,65 @@ async function inTemporaryDirectory(callback) {
   return tempy.directory.task(callback);
 }
 async function read$1(path, options = { encoding: "utf-8" }) {
-  const content = await fs$j.readFile(path, options);
-  return content;
+  debug$5(content`Reading the content of file at ${token.path(path)}...`);
+  const content$1 = await fs$j.readFile(path, options);
+  return content$1;
 }
 function readSync(path, options = { encoding: "utf-8" }) {
-  const content = fs$j.readFileSync(path, options);
-  return content.toString();
+  debug$5(content`Sync-reading the content of file at ${token.path(path)}...`);
+  const content$1 = fs$j.readFileSync(path, options);
+  return content$1.toString();
 }
 async function copy(from, to) {
+  debug$5(content`Copying file from ${token.path(from)} to ${token.path(to)}...`);
   await fs$j.copy(from, to);
 }
 async function touch(path) {
+  debug$5(content`Creating an empty file at ${token.path(path)}...`);
   await fs$j.ensureFile(path);
 }
 async function write$1(path, data) {
+  debug$5(content`Writing some content to file at ${token.path(path)}...`);
   await fs$j.writeFile(path, data);
 }
 function writeSync(path, data) {
+  debug$5(content`File-writing some content to file at ${token.path(path)}...`);
   fs$j.writeFileSync(path, data);
 }
 async function append$2(path, data) {
   await fs$j.appendFile(path, data);
 }
 async function mkdir(path) {
+  debug$5(content`Creating directory at ${token.path(path)}...`);
   await fs$j.mkdirp(path);
 }
 function mkdirSync(path) {
+  debug$5(content`Sync-reating directory at ${token.path(path)}...`);
   fs$j.mkdirpSync(path);
 }
 async function remove$4(path) {
+  debug$5(content`Removing file at ${token.path(path)}...`);
   await fs$j.remove(path);
 }
 async function rmdir(path, { force } = {}) {
+  debug$5(content`Removing directory at ${token.path(path)}...`);
   await del$1(path, { force });
 }
 async function mkTmpDir() {
+  debug$5(content`Creating a temporary directory...`);
   const directory = await fs$j.mkdtemp("tmp-");
   return directory;
 }
 async function isDirectory(path) {
+  debug$5(content`Checking if ${token.path(path)} is a directory...`);
   return (await fs$j.promises.lstat(path)).isDirectory();
 }
 async function size$1(path) {
+  debug$5(content`Getting the size of file file at ${token.path(path)}...`);
   return (await fs$j.stat(path)).size;
 }
 function sizeSync(path) {
+  debug$5(content`Sync-getting the size of file file at ${token.path(path)}...`);
   return fs$j.statSync(path).size;
 }
 async function move(src, dest, options = {}) {
@@ -16679,6 +16700,7 @@ const getUsernameFromOsUserInfo = () => {
 const cleanWindowsCommand = (value) => value.replace(/^.*\\/, "");
 const makeUsernameFromId = (userId) => `no-username-${userId}`;
 const username = async (platform = platform$2) => {
+  debug$5(content`Obtaining user name...`);
   const environmentVariable = getEnvironmentVariable();
   if (environmentVariable) {
     return environmentVariable;
@@ -16803,15 +16825,31 @@ var system = /*#__PURE__*/Object.freeze({
 	page: page
 });
 
+const SpinInstanceNotFound = (spinInstance, error) => {
+  const errorMessage = content`${token.genericShellCommand(`spin`)} yielded the following error trying to obtain the fully qualified domain name of the Spin instance:
+${error}
+  `;
+  let nextSteps;
+  if (spinInstance) {
+    nextSteps = `Make sure ${spinInstance} is the instance name and not a fully qualified domain name`;
+  }
+  return new Abort(errorMessage, nextSteps);
+};
 async function fqdn$1(env = process.env) {
   const spinInstance = await instance(env);
-  const showResponse = await show(spinInstance === void 0);
+  const showResponse = await show(spinInstance, env);
   return showResponse.fqdn;
 }
-async function show(latest) {
+async function show(spinInstance, env = process.env) {
+  const latest = spinInstance === void 0;
   const args = latest ? ["show", "--latest", "--json"] : ["show", "--json"];
-  const output = await captureOutput("spin", args);
-  return JSON.parse(output);
+  const output = await captureOutput("spin", args, { env });
+  const json = JSON.parse(output);
+  if (json.error) {
+    throw SpinInstanceNotFound(spinInstance, json.error);
+  } else {
+    return json;
+  }
 }
 function isSpin(env = process.env) {
   return isTruthy$1(env[constants$2.environmentVariables.spin]);
@@ -16841,9 +16879,8 @@ function isVerbose(env = process.env) {
   return isTruthy$1(env[constants$2.environmentVariables.verbose]) || process.argv.includes("--verbose");
 }
 async function isShopify(env = process.env) {
-  const runAsUser = isTruthy$1(env[constants$2.environmentVariables.runAsUser]);
-  if (runAsUser) {
-    return false;
+  if (Object.prototype.hasOwnProperty.call(env, constants$2.environmentVariables.runAsUser)) {
+    return !isTruthy$1(env[constants$2.environmentVariables.runAsUser]);
   }
   const devInstalled = await exists$1(constants$2.paths.executables.dev);
   return devInstalled || isSpin();
@@ -21839,7 +21876,7 @@ class Body$1 {
 			return formData;
 		}
 
-		const {toFormData} = await import('./multipart-parser-247e7258.js');
+		const {toFormData} = await import('./multipart-parser-6958f711.js');
 		return toFormData(this.body, ct);
 	}
 
@@ -35220,7 +35257,7 @@ var populate$3 = function(dst, src) {
 var CombinedStream$1 = combined_stream;
 var util$3 = require$$0$3;
 var path$9 = require$$0$2;
-var http$3 = http$5;
+var http$3 = require$$4;
 var https$2 = require$$1$3;
 var parseUrl$1 = Url.parse;
 var fs$a = require$$0$5;
@@ -46230,8 +46267,8 @@ async function execCLI(args, adminSession) {
   };
   spawn$1("bundle", ["exec", "shopify"].concat(args), {
     stdio: "inherit",
-    shell: true,
     cwd: shopifyCLIDirectory(),
+    shell: true,
     env
   });
 }
@@ -57611,10 +57648,14 @@ const cliKit = new Conf({
   projectVersion: cliKitPackageJson.version
 });
 function getAppInfo(directory) {
+  debug$5(content`Reading cached app information for directory ${token.path(directory)}...`);
   const apps = cliKit.get("appInfo") ?? [];
   return apps.find((app) => app.directory === directory);
 }
 function setAppInfo(options) {
+  debug$5(content`Storing app information for directory ${token.path(options.directory)}:
+${token.json(options)}
+`);
   const apps = cliKit.get("appInfo") ?? [];
   const index = apps.findIndex((saved) => saved.directory === options.directory);
   if (index === -1) {
@@ -57632,6 +57673,7 @@ function setAppInfo(options) {
   cliKit.set("appInfo", apps);
 }
 function clearAppInfo(directory) {
+  debug$5(content`Clearning app information for directory ${token.path(directory)}...`);
   const apps = cliKit.get("appInfo") ?? [];
   const index = apps.findIndex((saved) => saved.directory === directory);
   if (index !== -1) {
@@ -57640,9 +57682,11 @@ function clearAppInfo(directory) {
   cliKit.set("appInfo", apps);
 }
 function getThemeStore() {
+  debug$5(content`Getting theme store...`);
   return cliKit.get("themeStore");
 }
 function setThemeStore(store) {
+  debug$5(content`Setting theme store...`);
   cliKit.set("themeStore", store);
 }
 
@@ -62423,7 +62467,7 @@ var calculateServerName$1 = options => {
 	return servername;
 };
 
-const http$1 = http$5;
+const http$1 = require$$4;
 const https$1 = require$$1$3;
 const resolveALPN = resolveAlpn;
 const QuickLRU = quickLru;
@@ -63100,8 +63144,8 @@ const util_1 = require$$0$3;
 const stream_1 = require$$0$4;
 const fs_1 = require$$0$5;
 const url_1 = Url;
-const http = http$5;
-const http_1 = http$5;
+const http = require$$4;
+const http_1 = require$$4;
 const https = require$$1$3;
 const http_timer_1 = source$3.exports;
 const cacheable_lookup_1 = source$1.exports;
@@ -66281,7 +66325,7 @@ function getLegacyAuthToken (tok) {
   return { token: token, type: 'Basic' }
 }
 
-const {Agent: HttpAgent} = http$5;
+const {Agent: HttpAgent} = require$$4;
 const {Agent: HttpsAgent} = require$$1$3;
 const got = source$4.exports;
 const registryUrl = registryUrl$2.exports;
@@ -66400,6 +66444,7 @@ async function latestVersion(packageName, options) {
 }
 
 async function latestNpmPackageVersion(name) {
+  debug$5(content`Getting the latest version of NPM package: ${token.raw(name)}`);
   return latestVersion(name);
 }
 function cliVersion() {
@@ -66424,7 +66469,7 @@ const reportEvent = async (command, args) => {
     const headers = buildHeaders$1(currentTime);
     const response = await fetch$3(url, { method: "POST", body, headers });
     if (response.status === 200) {
-      debug$5(`Analytics event sent: ${body}`);
+      debug$5(content`Analytics event sent: ${token.json(payload)}`);
     } else {
       debug$5(`Failed to report usage analytics: ${response.statusText}`);
     }
@@ -147317,7 +147362,7 @@ function createHeadersLenient(obj) {
 const INTERNALS$1 = Symbol('Response internals');
 
 // fix an issue where "STATUS_CODES" aren't a named export for node <10
-const STATUS_CODES = http$5.STATUS_CODES;
+const STATUS_CODES = require$$4.STATUS_CODES;
 
 /**
  * Response class
@@ -147713,7 +147758,7 @@ function fetch$2(url, opts) {
 		const request = new Request(url, opts);
 		const options = getNodeRequestOptions(request);
 
-		const send = (options.protocol === 'https:' ? require$$1$3 : http$5).request;
+		const send = (options.protocol === 'https:' ? require$$1$3 : require$$4).request;
 		const signal = request.signal;
 
 		let response = null;
@@ -152382,7 +152427,7 @@ var populate$1 = function(dst, src) {
 var CombinedStream = combined_stream;
 var util$1 = require$$0$3;
 var path$2 = require$$0$2;
-var http = http$5;
+var http = require$$4;
 var https = require$$1$3;
 var parseUrl = Url.parse;
 var fs$4 = require$$0$5;
@@ -153914,6 +153959,7 @@ const FindOrganizationQuery = dist$3.gql`
             id
             title
             apiKey
+            organizationId
             apiSecretKeys {
               secret
             }
@@ -153933,17 +153979,6 @@ const AllOrganizationsQuery = dist$3.gql`
         businessName
         website
         appsNext
-        apps {
-          nodes {
-            id
-            title
-            apiKey
-            apiSecretKeys {
-              secret
-            }
-            appType
-          }
-        }
       }
     }
   }
@@ -153997,6 +154032,7 @@ const FindAppQuery = dist$3.gql`
       id
       title
       apiKey
+      organizationId
       apiSecretKeys {
         secret
       }
@@ -154209,6 +154245,7 @@ const AppFunctionSetMutation = dist$3.gql`
     $library: LibraryInput
     $inputQuery: String
     $appBridge: AppBridgeInput
+    $apiVersion: String
   ) {
     appScriptSet(
       uuid: $uuid
@@ -154225,6 +154262,7 @@ const AppFunctionSetMutation = dist$3.gql`
       library: $library
       inputQuery: $inputQuery
       appBridge: $appBridge
+      apiVersion: $apiVersion
     ) {
       userErrors {
         field
@@ -154242,6 +154280,19 @@ const AppFunctionSetMutation = dist$3.gql`
   }
 `;
 
+const FindOrganizationBasicQuery = dist$3.gql`
+  query FindOrganization($id: ID!) {
+    organizations(id: $id, first: 1) {
+      nodes {
+        id
+        businessName
+        website
+        appsNext
+      }
+    }
+  }
+`;
+
 var index = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	FindOrganizationQuery: FindOrganizationQuery,
@@ -154261,7 +154312,8 @@ var index = /*#__PURE__*/Object.freeze({
 	ScriptServiceProxyQuery: ScriptServiceProxyQuery,
 	GetAppFunctionsQuery: GetAppFunctionsQuery,
 	ModuleUploadUrlGenerateMutation: ModuleUploadUrlGenerateMutation,
-	AppFunctionSetMutation: AppFunctionSetMutation
+	AppFunctionSetMutation: AppFunctionSetMutation,
+	FindOrganizationBasicQuery: FindOrganizationBasicQuery
 });
 
 async function request(query, token$1, variables) {
@@ -154496,6 +154548,7 @@ function getUnzipArgs (inPath, outPath) {
 }
 
 async function zip(inputDirectory, outputZipPath) {
+  debug$5(content`Zipping ${token.path(inputDirectory)} into ${token.path(outputZipPath)}`);
   const cwd = process.cwd();
   process.chdir(inputDirectory);
   await new Promise((resolve, reject) => {
@@ -154567,6 +154620,7 @@ const InvalidChecksumError = ({ file, expected, got }) => {
   return new Abort(`The validation of ${file} failed. We expected the checksum ${expected}, but got ${got})`);
 };
 async function validateMD5({ file, md5FileURL }) {
+  debug$5(`Checking MD5 of file ${token.path(file)} against the MD5 in ${token.link("URL", md5FileURL)}`);
   const md5Digest = await md5File$1(file);
   const md5Response = await fetch$3(md5FileURL);
   const md5Contents = await md5Response.text();
@@ -154621,6 +154675,7 @@ function dependencyManagerUsedForCreating(env = process.env) {
   }
 }
 async function getDependencyManager(directory) {
+  debug$5(content`Obtaining the dependency manager in directory ${token.path(directory)}...`);
   const yarnLockPath = join$3(directory, genericConfigurationFileNames.yarn.lockfile);
   const pnpmLockPath = join$3(directory, genericConfigurationFileNames.pnpm.lockfile);
   if (await exists$1(yarnLockPath)) {
@@ -154664,6 +154719,7 @@ async function getDependencies(packageJsonPath) {
   return { ...dependencies, ...devDependencies };
 }
 async function checkForNewVersion(dependency, currentVersion) {
+  debug$5(content`Checking if there's a version of ${dependency} newer than ${currentVersion}`);
   try {
     const lastVersion = await latestNpmPackageVersion(dependency);
     if (lastVersion && new semver$3(currentVersion).compare(lastVersion) < 0) {
@@ -154686,29 +154742,38 @@ async function packageJSONContents(packageJsonPath) {
   return JSON.parse(await read$1(packageJsonPath));
 }
 async function addNPMDependenciesIfNeeded(dependencies, options) {
+  debug$5(content`Adding the following dependencies if needed:
+${token.json(dependencies)}
+With options:
+${token.json(options)}
+  `);
   const packageJsonPath = join$3(options.directory, "package.json");
   if (!await exists$1(packageJsonPath)) {
     throw PackageJsonNotFoundError(options.directory);
   }
   const existingDependencies = Object.keys(await getDependencies(packageJsonPath));
   const dependenciesToAdd = dependencies.filter((dep) => {
-    return !existingDependencies.includes(dep);
+    return !existingDependencies.includes(dep.name);
   });
   if (dependenciesToAdd.length === 0) {
     return;
   }
   let args;
+  const depedenciesWithVersion = dependenciesToAdd.map((dep) => {
+    return dep.version ? `${dep.name}@${dep.version}` : dep.name;
+  });
   switch (options.dependencyManager) {
     case "npm":
-      args = argumentsToAddDependenciesWithNPM(dependenciesToAdd, options.type);
+      args = argumentsToAddDependenciesWithNPM(depedenciesWithVersion, options.type);
       break;
     case "yarn":
-      args = argumentsToAddDependenciesWithYarn(dependenciesToAdd, options.type);
+      args = argumentsToAddDependenciesWithYarn(depedenciesWithVersion, options.type);
       break;
     case "pnpm":
-      args = argumentsToAddDependenciesWithPNPM(dependenciesToAdd, options.type);
+      args = argumentsToAddDependenciesWithPNPM(depedenciesWithVersion, options.type);
       break;
   }
+  options.stdout?.write(`Executing...${args.join(" ")}`);
   await exec$2(options.dependencyManager, args, {
     cwd: options.directory,
     stdout: options.stdout,
@@ -154716,8 +154781,15 @@ async function addNPMDependenciesIfNeeded(dependencies, options) {
     signal: options.signal
   });
 }
+async function addNPMDependenciesWithoutVersionIfNeeded(dependencies, options) {
+  await addNPMDependenciesIfNeeded(dependencies.map((dependency) => {
+    return { name: dependency, version: void 0 };
+  }), options);
+}
 async function addLatestNPMDependencies(dependencies, options) {
-  await addNPMDependenciesIfNeeded(dependencies.map((dependency) => `${dependency}@latest`), options);
+  await addNPMDependenciesIfNeeded(dependencies.map((dependency) => {
+    return { name: dependency, version: "latest" };
+  }), options);
 }
 function argumentsToAddDependenciesWithNPM(dependencies, type) {
   let command = ["install"];
@@ -154783,6 +154855,7 @@ var dependency = /*#__PURE__*/Object.freeze({
 	getOutputUpdateCLIReminder: getOutputUpdateCLIReminder,
 	packageJSONContents: packageJSONContents,
 	addNPMDependenciesIfNeeded: addNPMDependenciesIfNeeded,
+	addNPMDependenciesWithoutVersionIfNeeded: addNPMDependenciesWithoutVersionIfNeeded,
 	addLatestNPMDependencies: addLatestNPMDependencies
 });
 
@@ -154790,13 +154863,14 @@ const DotEnvNotFoundError = (path) => {
   return new Abort(`The environment file at ${path} does not exist.`);
 };
 async function read(path) {
+  debug$5(content`Reading the .env file at ${token.path(path)}`);
   if (!await exists$1(path)) {
     throw DotEnvNotFoundError(path);
   }
-  const content = await read$1(path);
+  const content$1 = await read$1(path);
   return {
     path,
-    variables: parse$i(content)
+    variables: parse$i(content$1)
   };
 }
 async function write(file) {
@@ -159586,17 +159660,32 @@ const GitNotPresentError = () => {
   return new Abort(`Git is necessary in the environment to continue`, content`Install ${token.link("git", "https://git-scm.com/book/en/v2/Getting-Started-Installing-Git")}`);
 };
 async function initializeRepository(directory) {
+  debug$5(content`Initializing git repository at ${token.path(directory)}...`);
   await ensurePresentOrAbort();
   await esm_default(directory).init();
 }
-async function downloadRepository({ repoUrl, destination }) {
+async function downloadRepository({
+  repoUrl,
+  destination,
+  progressUpdater,
+  shallow
+}) {
+  debug$5(content`Git-cloning repository ${repoUrl} into ${token.path(destination)}...`);
   await ensurePresentOrAbort();
   const [repository, branch] = repoUrl.split("#");
   const options = { "--recurse-submodules": null };
   if (branch) {
     options["--branch"] = branch;
   }
-  await esm_default().clone(repository, destination, options, (err) => {
+  if (shallow) {
+    options["--depth"] = 1;
+  }
+  const progress = ({ stage, progress: progress2, processed, total }) => {
+    const updateString = `${stage}, ${processed}/${total} objects (${progress2}% complete)`;
+    if (progressUpdater)
+      progressUpdater(updateString);
+  };
+  await esm_default({ progress }).clone(repository, destination, options, (err) => {
     if (err) {
       const abortError = new Abort(err.message);
       abortError.stack = err.stack;
@@ -159625,6 +159714,7 @@ class GitHubClientError extends Error {
   }
 }
 async function getLatestRelease(user, repo, { filter } = { filter: () => true }) {
+  debug$5(content`Getting the latest release of GitHub repository ${user}/${repo}...`);
   const url = `https://api.github.com/repos/${user}/${repo}/releases`;
   const fetchResult = await fetch$3(url);
   const jsonBody = await fetchResult.json();
@@ -159650,10 +159740,12 @@ function parseRepoUrl(src) {
   const user = match[4];
   const name = match[5].replace(/\.git$/, "");
   const subDirectory = match[6]?.slice(1);
-  const ref = match[7] || "HEAD";
+  const ref = match[7];
+  const branch = ref ? `#${ref}` : "";
   const ssh = `git@${normalizedSite}:${user}/${name}`;
   const http = `https://${normalizedSite}/${user}/${name}`;
-  return { site: normalizedSite, user, name, ref, subDirectory, ssh, http };
+  const full = ["https:/", normalizedSite, user, name, subDirectory].join("/").concat(branch);
+  return { full, site: normalizedSite, user, name, ref, subDirectory, ssh, http };
 }
 function parseGithubRepoReference(src) {
   const url = new URL(src);
@@ -160752,11 +160844,13 @@ var id = /*#__PURE__*/Object.freeze({
 });
 
 async function readPackageJSON(directory) {
+  debug$5(content`Reading and decoding the content from package.json at ${token.path(directory)}...`);
   const packagePath = join$3(directory, "package.json");
   const packageJSON = JSON.parse(await read$1(packagePath));
   return packageJSON;
 }
 async function writePackageJSON(directory, packageJSON) {
+  debug$5(content`JSON-encoding and writing content to package.json at ${token.path(directory)}...`);
   const packagePath = join$3(directory, "package.json");
   await write$1(packagePath, JSON.stringify(packageJSON, null, 2));
 }
@@ -160774,6 +160868,7 @@ var npm = /*#__PURE__*/Object.freeze({
 
 const TUNNEL_PLUGINS = ["@shopify/plugin-ngrok"];
 async function lookupTunnelPlugin(plugins) {
+  debug$5(content`Looking up the Ngrok tunnel plugin...`);
   const tunnelPlugin = plugins.find((plugin) => TUNNEL_PLUGINS.includes(plugin.name));
   if (!tunnelPlugin)
     return void 0;
@@ -160986,7 +161081,10 @@ function getLocalHosts(additional) {
 }
 
 async function getRandomPort() {
-  return getRandomPort$1();
+  debug$5(content`Getting a random port...`);
+  const randomPort = await getRandomPort$1();
+  debug$5(content`Random port obtained: ${token.raw(`${randomPort}`)}`);
+  return randomPort;
 }
 
 var port = /*#__PURE__*/Object.freeze({
@@ -164150,68 +164248,109 @@ function buildApplicationToken(result) {
   };
 }
 
-const EmptyUrlError = new Abort("We received the authentication redirect but the URL is empty");
-const AuthenticationError = (message) => {
-  return new Abort(message);
+const HTMLFileNames = ["empty-url.html", "auth-error.html", "missing-code.html", "missing-state.html", "success.html"];
+const StylesheetFilename = "style.css";
+const FaviconFileName = "favicon.svg";
+const getFilePath = async (fileName) => {
+  const filePath = await findUp$2(`assets/${fileName}`, {
+    type: "file",
+    cwd: moduleDirectory(import.meta.url)
+  });
+  if (!filePath) {
+    throw RedirectPageAssetNotFoundError();
+  }
+  return filePath;
+};
+const getEmptyUrlHTML = async () => {
+  const filePath = await getFilePath(HTMLFileNames[0]);
+  return read$1(filePath);
+};
+const getAuthErrorHTML = async () => {
+  const filePath = await getFilePath(HTMLFileNames[1]);
+  return read$1(filePath);
+};
+const getMissingCodeHTML = async () => {
+  const filePath = await getFilePath(HTMLFileNames[2]);
+  return read$1(filePath);
+};
+const getMissingStateHTML = async () => {
+  const filePath = await getFilePath(HTMLFileNames[3]);
+  return read$1(filePath);
+};
+const getSuccessHTML = async () => {
+  const filePath = await getFilePath(HTMLFileNames[4]);
+  return read$1(filePath);
 };
-const MissingCodeError = new Bug(`The authentication can't continue because the redirect doesn't include the code.`);
-const MissingStateError = new Bug(`The authentication can't continue because the redirect doesn't include the state.`);
-const redirectResponseBody = `You're logged in on the Shopify CLI in your terminal`;
+const getStylesheet = async () => {
+  const filePath = await getFilePath(StylesheetFilename);
+  return read$1(filePath);
+};
+const getFavicon = async () => {
+  const filePath = await getFilePath(FaviconFileName);
+  return read$1(filePath);
+};
+const EmptyUrlString = "We received the authentication redirect but the URL is empty.";
+const MissingCodeString = "The authentication can't continue because the redirect doesn't include the code.";
+const MissingStateString = "The authentication can't continue because the redirect doesn't include the state.";
+const RedirectPageAssetNotFoundError = () => new Bug(`Redirect page asset not found`);
+
 const ResponseTimeoutSeconds = 10;
+const ServerStopDelaySeconds = 0.5;
 class RedirectListener {
   static createServer(callback) {
-    return http$5.createServer((request, response) => {
+    const server = Fastify__default().get("*", async (request, reply) => {
       const requestUrl = request.url;
-      if (requestUrl === "/favicon.ico")
+      if (requestUrl === "/favicon.svg") {
+        const faviconFile = await getFavicon();
+        reply.header("Content-Type", "image/svg+xml").send(faviconFile);
+        return {};
+      } else if (requestUrl === "/style.css") {
+        const stylesheetFile = await getStylesheet();
+        reply.header("Content-Type", "text/css").send(stylesheetFile);
+        return {};
+      }
+      const respond = (contents, error, state, code) => {
+        reply.header("Content-Type", "text/html").send(contents);
+        callback(error, state, code);
         return {};
-      const respond = () => {
-        response.writeHead(200, { "Content-Type": "text/html" });
-        response.end(redirectResponseBody);
       };
       if (!requestUrl) {
-        respond();
-        return callback(EmptyUrlError, void 0, void 0);
+        const file2 = await getEmptyUrlHTML();
+        const err = new Bug(EmptyUrlString);
+        return respond(file2, err, void 0, void 0);
       }
       const queryObject = Url.parse(requestUrl, true).query;
       if (queryObject.error && queryObject.error_description) {
-        respond();
-        return callback(AuthenticationError(`${queryObject.error_description}`), void 0, void 0);
+        const file2 = await getAuthErrorHTML();
+        const err = new Abort(`${queryObject.error_description}`);
+        return respond(file2, err, void 0, void 0);
       }
       if (!queryObject.code) {
-        respond();
-        return callback(MissingCodeError, void 0, void 0);
+        const file2 = await getMissingCodeHTML();
+        const err = new Bug(MissingCodeString);
+        return respond(file2, err, void 0, void 0);
       }
       if (!queryObject.state) {
-        respond();
-        return callback(MissingStateError, void 0, void 0);
+        const file2 = await getMissingStateHTML();
+        const err = new Bug(MissingStateString);
+        return respond(file2, err, void 0, void 0);
       }
-      respond();
-      return callback(void 0, `${queryObject.code}`, `${queryObject.state}`);
+      const file = await getSuccessHTML();
+      return respond(file, void 0, `${queryObject.code}`, `${queryObject.state}`);
     });
+    return server;
   }
   constructor(options) {
     this.port = options.port;
     this.host = options.host;
     this.server = RedirectListener.createServer(options.callback);
   }
-  async start() {
-    await new Promise((resolve) => {
-      this.server.listen(this.port, this.host, void 0, () => {
-        resolve();
-      });
+  start() {
+    this.server.listen({ port: this.port, host: this.host }, () => {
     });
   }
   async stop() {
-    await new Promise((resolve, reject) => {
-      this.server.setTimeout(1);
-      this.server.close((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
-    });
+    await this.server.close();
   }
 }
 async function listenRedirect(host, port, url2) {
@@ -164220,22 +164359,17 @@ async function listenRedirect(host, port, url2) {
       const message = "\nAuto-open timed out. Open the login page: ";
       info(content`${message}${token.link("Log in to Shopify Partners", url2)}\n`);
     }, ResponseTimeoutSeconds * 1e3);
-    const redirectListener = new RedirectListener({
-      host,
-      port,
-      callback: (error, code, state) => {
-        clearTimeout(timeout);
+    const callback = async (error, code, state) => {
+      clearTimeout(timeout);
+      setTimeout(() => {
         redirectListener.stop();
-        if (error) {
+        if (error)
           reject(error);
-        } else {
-          resolve({
-            code,
-            state
-          });
-        }
-      }
-    });
+        else
+          resolve({ code, state });
+      }, ServerStopDelaySeconds * 1e3);
+    };
+    const redirectListener = new RedirectListener({ host, port, callback });
     redirectListener.start();
   });
   return result;
@@ -164420,15 +164554,18 @@ const SessionSchema = mod.object({}).catchall(mod.object({
 }));
 
 async function fetch$1(identifier) {
+  debug$5(content`Reading ${identifier} from the secure store...`);
   const keytar = await import('keytar');
-  const content = await keytar.getPassword(constants$2.keychain.service, identifier);
-  return content;
+  const content$1 = await keytar.getPassword(constants$2.keychain.service, identifier);
+  return content$1;
 }
-async function store$1(identifier, content) {
+async function store$1(identifier, content$1) {
+  debug$5(content`Updating ${identifier} in the secure store with new content...`);
   const keytar = await import('keytar');
-  await keytar.default.setPassword(constants$2.keychain.service, identifier, content);
+  await keytar.default.setPassword(constants$2.keychain.service, identifier, content$1);
 }
 async function remove$2(identifier) {
+  debug$5(content`Removing ${identifier} from the secure store...`);
   const keytar = await import('keytar');
   const result = await keytar.default.deletePassword(constants$2.keychain.service, identifier);
   return result;
@@ -164462,6 +164599,9 @@ const MissingPartnerTokenError = new Bug("No partners token found after ensuring
 const MissingAdminTokenError = new Bug("No admin token found after ensuring authenticated");
 const MissingStorefrontTokenError = new Bug("No storefront token found after ensuring authenticated");
 async function ensureAuthenticatedPartners(scopes = [], env = process.env) {
+  debug$5(content`Ensuring that the user is authenticated with the Partners API with the following scopes:
+${token.json(scopes)}
+`);
   const envToken = env[constants$2.environmentVariables.partnersToken];
   if (envToken) {
     return (await exchangeCustomPartnerToken(envToken)).accessToken;
@@ -164473,6 +164613,9 @@ async function ensureAuthenticatedPartners(scopes = [], env = process.env) {
   return tokens.partners;
 }
 async function ensureAuthenticatedStorefront(scopes = []) {
+  debug$5(content`Ensuring that the user is authenticated with the Storefront API with the following scopes:
+${token.json(scopes)}
+`);
   const tokens = await ensureAuthenticated({ storefrontRendererApi: { scopes } });
   if (!tokens.storefront) {
     throw MissingStorefrontTokenError;
@@ -164480,6 +164623,9 @@ async function ensureAuthenticatedStorefront(scopes = []) {
   return tokens.storefront;
 }
 async function ensureAuthenticatedAdmin(store, scopes = []) {
+  debug$5(content`Ensuring that the user is authenticated with the Admin API with the following scopes for the store ${token.raw(store)}:
+${token.json(scopes)}
+`);
   const tokens = await ensureAuthenticated({ adminApi: { scopes, storeFqdn: store } });
   if (!tokens.admin) {
     throw MissingAdminTokenError;
@@ -164494,11 +164640,18 @@ async function ensureAuthenticated(applications, env = process.env) {
   const currentSession = await fetch() || {};
   const fqdnSession = currentSession[fqdn];
   const scopes = getFlattenScopes(applications);
+  debug$5(content`Validating existing session against the scopes:
+${token.json(scopes)}
+For applications:
+${token.json(applications)}
+`);
   const validationResult = await validateSession(scopes, applications, fqdnSession);
   let newSession = {};
   if (validationResult === "needs_full_auth") {
+    debug$5(content`Initiating the full authentication flow...`);
     newSession = await executeCompleteFlow(applications, fqdn);
   } else if (validationResult === "needs_refresh") {
+    debug$5(content`The current session is valid but needs refresh. Refreshing...`);
     try {
       newSession = await refreshTokens(fqdnSession.identity, applications, fqdn);
     } catch (error) {
@@ -164522,8 +164675,11 @@ async function executeCompleteFlow(applications, identityFqdn2) {
   const scopes = getFlattenScopes(applications);
   const exchangeScopes = getExchangeScopes(applications);
   const store = applications.adminApi?.storeFqdn;
+  debug$5(content`Authorizing through Identity's website...`);
   const code = await authorize(scopes);
+  debug$5(content`Authorization code received. Exchanging it for a CLI token...`);
   const identityToken = await exchangeCodeForAccessToken(code);
+  debug$5(content`CLI token received. Exchanging it for application tokens...`);
   const result = await exchangeAccessForApplicationTokens(identityToken, exchangeScopes, store);
   const session = {
     [identityFqdn2]: {
@@ -164534,8 +164690,8 @@ async function executeCompleteFlow(applications, identityFqdn2) {
   completed("Logged in");
   return session;
 }
-async function refreshTokens(token, applications, fqdn) {
-  const identityToken = await refreshAccessToken(token);
+async function refreshTokens(token2, applications, fqdn) {
+  const identityToken = await refreshAccessToken(token2);
   const exchangeScopes = getExchangeScopes(applications);
   const applicationTokens = await exchangeAccessForApplicationTokens(identityToken, exchangeScopes, applications.adminApi?.storeFqdn);
   return {
@@ -164554,9 +164710,9 @@ async function tokensFor(applications, session, fqdn) {
   if (applications.adminApi) {
     const appId = applicationId("admin");
     const realAppId = `${applications.adminApi.storeFqdn}-${appId}`;
-    const token = fqdnSession.applications[realAppId]?.accessToken;
-    if (token) {
-      tokens.admin = { token, storeFqdn: applications.adminApi.storeFqdn };
+    const token2 = fqdnSession.applications[realAppId]?.accessToken;
+    if (token2) {
+      tokens.admin = { token: token2, storeFqdn: applications.adminApi.storeFqdn };
     }
   }
   if (applications.partnersApi) {
@@ -169077,6 +169233,7 @@ function create(templateContent) {
   };
 }
 async function recursiveDirectoryCopy(from, to, data) {
+  debug$5(content`Copying template from directory ${token.path(from)} to ${token.path(to)}`);
   const templateFiles = await out(join$3(from, "**/*"), { dot: true });
   const sortedTemplateFiles = templateFiles.map((path) => path.split("/")).sort((lhs, rhs) => lhs.length < rhs.length ? 1 : -1).map((components) => components.join("/"));
   await Promise.all(sortedTemplateFiles.map(async (templateItemPath) => {
@@ -169085,8 +169242,8 @@ async function recursiveDirectoryCopy(from, to, data) {
       await mkdir(outputPath);
     } else if (templateItemPath.endsWith(".liquid")) {
       await mkdir(dirname$1(outputPath));
-      const content = await read$1(templateItemPath);
-      const contentOutput = await create(content)(data);
+      const content2 = await read$1(templateItemPath);
+      const contentOutput = await create(content2)(data);
       const isExecutable = await hasExecutablePermissions(templateItemPath);
       const outputPathWithoutLiquid = outputPath.replace(".liquid", "");
       await copy(templateItemPath, outputPathWithoutLiquid);
@@ -171192,6 +171349,7 @@ var toml = /*#__PURE__*/Object.freeze({
 });
 
 const isVSCode = async (root = process.cwd()) => {
+  debug$5(content`Checking if the directory ${token.path(root)} or any of its parents has a .vscode directory... `);
   const config = await findUp$2(join$3(root, ".vscode"), { type: "directory" });
   if (!config) {
     return false;
@@ -171199,6 +171357,9 @@ const isVSCode = async (root = process.cwd()) => {
   return exists$1(config);
 };
 async function addRecommendedExtensions(directory, recommendations) {
+  debug$5(content`Adding VSCode recommended extensions at ${token.path(directory)}:
+${token.json(recommendations)}
+  `);
   const extensionsPath = join$3(directory, ".vscode/extensions.json");
   if (await isVSCode(directory)) {
     let originalExtensionsJson = { recommendations: [] };
@@ -175026,4 +175187,4 @@ var yaml = /*#__PURE__*/Object.freeze({
 });
 
 export { semver$2 as A, session as B, store$2 as C, string as D, system as E, FormData$3 as F, template as G, temporary as H, toml as I, ui as J, version as K, vscode as L, yaml as M, File$1 as a, abort$3 as b, constants$2 as c, analytics as d, api as e, archiver as f, checksum as g, cli as h, dependency as i, dotEnv as j, environment as k, error$k as l, file$1 as m, git as n, github as o, haiku as p, http$2 as q, id as r, npm as s, os$3 as t, output as u, path$w as v, plugins as w, port as x, ruby as y, schema$1 as z };
-//# sourceMappingURL=index-46c26c7f.js.map
+//# sourceMappingURL=index-21b8e2fe.js.map