gigadrive 0.0.3 → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/build/index.ts
+var import_build_utils = require("@gigadrive/build-utils");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/util/pm.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+
+// ../build-utils/src/exec.ts
+var import_child_process = require("child_process");
+async function exec({
+  command,
+  cwd = process.cwd(),
+  env,
+  onOutput = (data) => console.log(data),
+  onError = (data) => console.error(data)
+}) {
+  return new Promise((resolve, reject) => {
+    let spawnCommand;
+    let spawnArgs = [];
+    if (typeof command === "string") {
+      const parts = command.split(" ");
+      spawnCommand = parts[0];
+      spawnArgs = parts.slice(1);
+    } else {
+      spawnCommand = command.command;
+      spawnArgs = command.args || [];
+    }
+    const childProcess = (0, import_child_process.spawn)(spawnCommand, spawnArgs, {
+      cwd,
+      shell: true,
+      env
+    });
+    childProcess.stdout.on("data", (data) => {
+      onOutput(data.toString().trim());
+    });
+    childProcess.stderr.on("data", (data) => {
+      onError(data.toString().trim());
+    });
+    childProcess.on("error", (error2) => {
+      reject(new Error(`Failed to start process: ${error2.message}`));
+    });
+    childProcess.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/util/pm.ts
+var getPackageManager = async ({ cwd }) => {
+  const packageJsonPath = import_path.default.join(cwd, "package.json");
+  if (!import_fs.default.existsSync(packageJsonPath)) {
+    return null;
+  }
+  if (import_fs.default.existsSync(import_path.default.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (import_fs.default.existsSync(import_path.default.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (import_fs.default.existsSync(import_path.default.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (import_fs.default.existsSync(import_path.default.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  try {
+    await exec({ command: "bun --version", cwd });
+    return "bun";
+  } catch (e) {
+    return "npm";
+  }
+};
+var installCommand = (pm) => {
+  return {
+    bun: "bun install",
+    npm: "npm install",
+    pnpm: "pnpm install",
+    yarn: "yarn install"
+  }[pm] || "npm install";
+};
+var buildCommand = (pm) => {
+  return {
+    bun: "bun run build",
+    npm: "npm run build",
+    pnpm: "pnpm build",
+    yarn: "yarn build"
+  }[pm] || "npm run build";
+};
+
+// src/commands/build/index.ts
+var build = (parent) => {
+  parent.command("build").description("Build the current project").action(async () => {
+    const env = {
+      ...process.env,
+      NODE_ENV: "production",
+      NEBULA: "1",
+      VERCEL: "1",
+      // Vercel compatibility
+      NOW_BUILDER: "1"
+    };
+    const cwd = process.cwd();
+    const packageJsonPath = import_path2.default.join(cwd, "package.json");
+    if (!import_fs2.default.existsSync(packageJsonPath)) {
+      console.log("No package.json found");
+      return;
+    }
+    const packageJson = JSON.parse(import_fs2.default.readFileSync(packageJsonPath, "utf-8"));
+    const buildScript = packageJson.scripts?.build;
+    if (!buildScript) {
+      console.log("No build script found in package.json");
+      return;
+    }
+    const packageManager = await getPackageManager({ cwd });
+    if (!packageManager) {
+      console.log("No package manager found");
+      return;
+    }
+    await (0, import_build_utils.exec)({
+      command: installCommand(packageManager),
+      cwd,
+      env,
+      onOutput: (chunk) => {
+        console.log(chunk);
+      }
+    });
+    await (0, import_build_utils.exec)({
+      command: buildCommand(packageManager),
+      cwd,
+      env,
+      onOutput: (chunk) => {
+        console.log(chunk);
+      }
+    });
+  });
+};
+
+// src/commands/platform/deploy/index.ts
+var import_commons = require("@gigadrive/commons");
+var import_network_config = require("@gigadrive/network-config");
+var import_fs4 = __toESM(require("fs"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_path4 = __toESM(require("path"), 1);
+
+// src/util/log.ts
+var import_consola = require("consola");
+var verbose = false;
+var consola = (0, import_consola.createConsola)({
+  level: verbose ? 4 : 3,
+  // 4 includes debug messages, 3 is the default (info and above)
+  formatOptions: {
+    colors: true
+  }
+});
+var updateConsola = () => {
+  consola.level = verbose ? 4 : 3;
+};
+var setVerbose = (value) => {
+  verbose = value;
+  updateConsola();
+};
+var log = (message) => {
+  consola.info(message);
+};
+var error = (message) => {
+  consola.error(message);
+};
+var success = (message) => {
+  consola.success(message);
+};
+var warn = (message) => {
+  consola.warn(message);
+};
+var debug = (message, ...optionalParams) => {
+  if (!verbose) {
+    console.log("debug", message, ...optionalParams);
+    return;
+  }
+  consola.debug("[DEBUG]", message, ...optionalParams);
+};
+var spinner = (message) => {
+  log(message);
+};
+
+// src/util/zip.ts
+var import_archiver = __toESM(require("archiver"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_ignore = __toESM(require("ignore"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var ignoreFileNames = [
+  /*'.gitignore', */
+  ".gigadriveignore",
+  ".vercelignore",
+  ".dockerignore",
+  ".nowignore"
+];
+function readIgnoreFile(ignorePath) {
+  if (import_fs3.default.existsSync(ignorePath)) {
+    return import_fs3.default.readFileSync(ignorePath, "utf8").split("\n").filter((line) => line.trim() !== "");
+  }
+  return [];
+}
+function collectIgnorePatterns(dir, baseDir, ignoreRules) {
+  const items = import_fs3.default.readdirSync(dir);
+  items.forEach((item) => {
+    const fullPath = import_path3.default.join(dir, item);
+    const relativePath = import_path3.default.relative(baseDir, fullPath);
+    const stat = import_fs3.default.lstatSync(fullPath);
+    if (stat.isDirectory()) {
+      if (ignoreRules.ignores(`${relativePath}/`)) {
+        return;
+      }
+      ignoreFileNames.forEach((ignoreFileName) => {
+        const ignoreFilePath = import_path3.default.join(fullPath, ignoreFileName);
+        if (import_fs3.default.existsSync(ignoreFilePath)) {
+          const patterns = readIgnoreFile(ignoreFilePath).map((pattern) => {
+            return pattern.startsWith("!") ? `!${import_path3.default.join(relativePath, pattern.slice(1))}` : import_path3.default.join(relativePath, pattern);
+          });
+          ignoreRules.add(patterns);
+        }
+      });
+      collectIgnorePatterns(fullPath, baseDir, ignoreRules);
+    }
+  });
+}
+function initializeIgnoreRules(baseDir) {
+  const ignoreRules = (0, import_ignore.default)();
+  ignoreRules.add([".git/", "**/.DS_Store", "**/Thumbs.db"]);
+  ignoreFileNames.forEach((ignoreFileName) => {
+    const ignoreFilePath = import_path3.default.join(baseDir, ignoreFileName);
+    if (import_fs3.default.existsSync(ignoreFilePath)) {
+      const patterns = readIgnoreFile(ignoreFilePath).map((pattern) => {
+        return pattern.startsWith("!") ? `!${pattern.slice(1)}` : pattern;
+      });
+      ignoreRules.add(patterns);
+    }
+  });
+  collectIgnorePatterns(baseDir, baseDir, ignoreRules);
+  return ignoreRules;
+}
+async function getFilesToInclude(dir, ignoreRules) {
+  const filesToInclude = [];
+  function walkSync(currentDir) {
+    const items = import_fs3.default.readdirSync(currentDir);
+    items.forEach((item) => {
+      const fullPath = import_path3.default.join(currentDir, item);
+      const relativePath = import_path3.default.relative(dir, fullPath);
+      const stat = import_fs3.default.lstatSync(fullPath);
+      if (stat.isDirectory()) {
+        if (ignoreRules.ignores(`${relativePath}/`)) {
+          return;
+        }
+        walkSync(fullPath);
+      } else {
+        if (!ignoreRules.ignores(relativePath)) {
+          filesToInclude.push(fullPath);
+        } else if (ignoreRules.ignores(relativePath) && ignoreRules.test(relativePath).unignored) {
+          filesToInclude.push(fullPath);
+        } else {
+        }
+      }
+    });
+  }
+  walkSync(dir);
+  return filesToInclude;
+}
+async function createZipArchive(inputDir, outputFile, options = {}) {
+  const ignoreRules = options.useIgnoreFiles !== false ? initializeIgnoreRules(inputDir) : (0, import_ignore.default)();
+  const filesToInclude = await getFilesToInclude(inputDir, ignoreRules);
+  const output = import_fs3.default.createWriteStream(outputFile);
+  const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
+  return new Promise((resolve, reject) => {
+    output.on("close", () => resolve());
+    archive.on("error", reject);
+    archive.pipe(output);
+    filesToInclude.forEach((file) => {
+      archive.file(file, { name: import_path3.default.relative(inputDir, file) });
+    });
+    archive.finalize();
+  });
+}
+
+// src/commands/platform/deploy/index.ts
+var deploy = (parent) => {
+  parent.command("deploy").description("Deploy the current project").action(async () => {
+    debug("Starting deploy command");
+    const configPath = (0, import_network_config.findConfig)(process.cwd());
+    if (!configPath) {
+      debug("No config file found");
+      throw new Error("The current project folder does not have a valid config file.");
+    }
+    debug(`Found config at: ${configPath}`);
+    const config = await (0, import_network_config.parseConfig)(configPath, process.cwd());
+    debug("Parsed config", config);
+    if (config.warnings.length > 0) {
+      debug(`Found ${config.warnings.length} warnings in config`);
+      config.warnings.forEach((message) => {
+        warn(message);
+      });
+    }
+    if (config.errors.length > 0) {
+      debug(`Found ${config.errors.length} errors in config`);
+      config.errors.forEach((message) => {
+        error(message);
+      });
+      throw new Error("The current project folder does not have a valid config file.");
+    }
+    debug("Creating deployment");
+    const deploymentId = await createDeployment({
+      applicationId: "test"
+      // TODO
+    });
+    debug(`Deployment ID: ${deploymentId}`);
+    debug("Starting deployment process");
+    await handleDeployment(deploymentId, config);
+  });
+};
+var handleDeployment = async (deploymentId, config) => {
+  debug("Deployment process initialized");
+  let status = "PENDING";
+  const logs = [];
+  addLog("Deployment ID: " + deploymentId, "INFO", logs);
+  try {
+    debug("Starting upload process");
+    await uploadArchive(deploymentId, logs);
+    debug("Upload completed successfully");
+    addLog("Upload complete.", "INFO", logs);
+    addLog("The deployment pipeline is now being provisioned. This may take a few seconds.", "INFO", logs);
+  } catch (err) {
+    debug(`Upload failed with error: ${err.message}`);
+    addLog(`Upload failed: ${err.message}`, "ERROR", logs);
+    status = "FAILED";
+    error("The deployment failed. Please check the logs for more information.");
+    return;
+  }
+  const statusInterval = setInterval(async () => {
+    try {
+      debug(`Fetching deployment status for ${deploymentId}`);
+      const newStatus = await getDeploymentStatus(deploymentId);
+      debug(`Current status: ${status}, New status: ${newStatus}`);
+      if (newStatus === "ACTIVE" || newStatus === "FAILED") {
+        debug(`Final status reached: ${newStatus}, clearing interval`);
+        clearInterval(statusInterval);
+        clearInterval(logsInterval);
+        if (newStatus === "ACTIVE") {
+          success(`Deployed to https://${deploymentId}.gigadrivedev.com`);
+        } else {
+          error("The deployment failed. Please check the logs for more information.");
+        }
+        return;
+      }
+      if (newStatus !== status) {
+        debug(`Updating status from ${status} to ${newStatus}`);
+        status = newStatus;
+        spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
+      }
+    } catch (err) {
+      debug(`Error fetching status: ${err.message}`);
+    }
+  }, 1e3);
+  const logsInterval = setInterval(async () => {
+    try {
+      debug(`Fetching logs for ${deploymentId}, current log count: ${logs.length}`);
+      const newLogs = await getLogs(deploymentId, {
+        offset: logs.length,
+        limit: 100,
+        "createdAt[gt]": logs[logs.length - 1]?.createdAt
+      });
+      debug(`Fetched ${newLogs.items.length} new logs`);
+      for (const logEntry of newLogs.items) {
+        logs.push(logEntry);
+        if (logEntry.type === "ERROR") {
+          error(logEntry.message);
+        } else if (logEntry.type === "WARN") {
+          warn(logEntry.message);
+        } else {
+          log(logEntry.message);
+        }
+      }
+    } catch (err) {
+      debug(`Error fetching logs: ${err.message}`);
+    }
+  }, 1e3);
+  spinner(`Status: ${status.toLowerCase().replace(/^\w/, (c) => c.toUpperCase())}`);
+};
+var addLog = (message, type, logs) => {
+  debug(`Adding log: [${type}] ${message}`);
+  logs.push({
+    id: String(logs.length),
+    message,
+    type,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (type === "ERROR") {
+    error(message);
+  } else if (type === "WARN") {
+    warn(message);
+  } else {
+    log(message);
+  }
+};
+var uploadArchive = async (deploymentId, logs) => {
+  debug("Starting uploadArchive");
+  addLog("Creating archive...", "INFO", logs);
+  const archivePath = import_path4.default.join(process.env.TEMP || import_os.default.tmpdir(), `project-${Date.now()}.zip`);
+  debug(`Archive path: ${archivePath}`);
+  if (import_fs4.default.existsSync(archivePath)) {
+    debug(`Archive already exists, removing: ${archivePath}`);
+    import_fs4.default.unlinkSync(archivePath);
+  }
+  debug("Creating zip archive");
+  await createZipArchive(process.cwd(), archivePath, { useIgnoreFiles: false, useManagedIgnore: false });
+  const fileStats = import_fs4.default.statSync(archivePath);
+  const fileSize = fileStats.size;
+  debug(`Archive created, size: ${fileSize} bytes (${(0, import_commons.formatFileSize)(fileSize)})`);
+  addLog(`Archive created (${(0, import_commons.formatFileSize)(fileSize)})`, "INFO", logs);
+  addLog("Uploading archive...", "INFO", logs);
+  debug(`Starting multipart upload for deployment: ${deploymentId}`);
+  const uploadId = await startMultipartUpload(deploymentId);
+  debug(`Upload ID: ${uploadId}`);
+  debug("Uploading archive...");
+  const fileChunkSize = 10 * 1024 * 1024;
+  const numChunks = Math.ceil(fileSize / fileChunkSize);
+  debug(`File size: ${fileSize}, chunk size: ${fileChunkSize}, number of chunks: ${numChunks}`);
+  const promises = [];
+  let start, end;
+  for (let index = 1; index < numChunks + 1; index++) {
+    start = (index - 1) * fileChunkSize;
+    end = index * fileChunkSize;
+    debug(`Processing chunk ${index}/${numChunks}, start: ${start}, end: ${end}`);
+    const presignedUrl = await getPresignedUrl(deploymentId, uploadId, index);
+    debug("Presigned URL for part", index, presignedUrl);
+    const promise = new Promise(async (resolve, reject) => {
+      try {
+        debug(`Reading chunk ${index} data`);
+        const readStream = import_fs4.default.createReadStream(archivePath, {
+          start,
+          end: index < numChunks ? end - 1 : void 0
+        });
+        const chunks = [];
+        readStream.on("data", (chunk) => {
+          chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        });
+        await new Promise((resolveRead) => {
+          readStream.on("end", () => resolveRead());
+          readStream.on("error", reject);
+        });
+        const buffer = Buffer.concat(chunks);
+        debug(`Uploading chunk ${index} to presigned URL (${buffer.length} bytes)`);
+        const response = await fetch(presignedUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/zip",
+            "Content-Length": String(buffer.length)
+          },
+          body: buffer
+        });
+        resolve(response);
+      } catch (err) {
+        reject(err);
+      }
+    });
+    promises.push(promise);
+  }
+  const finishedParts = [];
+  try {
+    debug(`Waiting for all ${promises.length} upload promises to complete`);
+    const responses = await Promise.all(promises);
+    debug("All upload promises completed");
+    for (let index = 0; index < responses.length; index++) {
+      const res = responses[index];
+      debug(`Checking response for part ${index + 1}, status: ${res.status}`);
+      if (!res.ok) {
+        debug(`Failed to upload part ${index + 1}: ${res.statusText} ${await res.text()}`);
+        throw new Error(`Failed to upload part ${index + 1}: ${res.statusText}`);
+      }
+      const etag = res.headers.get("ETag");
+      if (!etag) {
+        debug(`Failed to get ETag for part ${index + 1}`);
+        throw new Error(`Failed to get ETag for part ${index + 1}`);
+      }
+      debug(`Part ${index + 1} uploaded successfully, ETag: ${etag}`);
+      finishedParts.push({
+        partNumber: index + 1,
+        etag
+      });
+    }
+    debug(`Completing upload with ${finishedParts.length} parts`);
+    await completeUpload(deploymentId, uploadId, finishedParts);
+    debug("Upload completed successfully");
+  } catch (err) {
+    const error2 = err;
+    debug(`Upload error: ${error2.message}`);
+    addLog(`Upload error: ${error2.message}`, "ERROR", logs);
+    throw error2;
+  }
+};
+var createDeployment = async ({ applicationId }) => {
+  debug(`Creating deployment for application: ${applicationId}`);
+  const res = await fetch(`http://localhost:3000/${applicationId}/deployments`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({}),
+    duplex: "half"
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to create deployment: ${errorText}`);
+    throw new Error("Failed to create deployment: " + errorText);
+  }
+  const deployment = await res.json();
+  debug(`Deployment created with ID: ${deployment.id}`);
+  return deployment.id;
+};
+var startMultipartUpload = async (deploymentId) => {
+  debug(`Starting multipart upload for deployment: ${deploymentId}`);
+  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/pre-signed-url/start`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to start multipart upload: ${errorText}`);
+    throw new Error("Failed to start multipart upload: " + errorText);
+  }
+  const upload = await res.json();
+  debug(`Multipart upload started with ID: ${upload.uploadId}`);
+  return upload.uploadId;
+};
+var getPresignedUrl = async (deploymentId, uploadId, partNumber) => {
+  debug(`Getting presigned URL for deployment: ${deploymentId}, upload: ${uploadId}, part: ${partNumber}`);
+  const res = await fetch(
+    `http://localhost:3000/deployments/${deploymentId}/pre-signed-url/part?uploadId=${uploadId}&partNumber=${partNumber}`,
+    {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+  );
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to get pre-signed URL: ${errorText}`);
+    throw new Error("Failed to get pre-signed URL: " + errorText);
+  }
+  const upload = await res.json();
+  debug(`Got presigned URL for part ${partNumber}`);
+  return upload.url;
+};
+var completeUpload = async (deploymentId, uploadId, parts) => {
+  debug(`Completing upload for deployment: ${deploymentId}, upload: ${uploadId}, parts: ${parts.length}`);
+  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/pre-signed-url/complete`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      uploadId,
+      parts
+    }),
+    duplex: "half"
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to complete upload: ${errorText}`);
+    throw new Error("Failed to complete upload: " + errorText);
+  }
+  debug("Upload completed successfully");
+};
+var getDeploymentStatus = async (deploymentId) => {
+  debug(`Getting deployment status for: ${deploymentId}`);
+  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to get deployment status: ${errorText}`);
+    throw new Error("Failed to get deployment status: " + errorText);
+  }
+  const deployment = await res.json();
+  debug(`Deployment status: ${deployment.status}`);
+  return deployment.status;
+};
+var getLogs = async (deploymentId, options) => {
+  debug(`Getting logs for deployment: ${deploymentId}, options:`, options);
+  const res = await fetch(`http://localhost:3000/deployments/${deploymentId}/logs${(0, import_commons.objectToQueryString)(options)}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!res.ok) {
+    const errorText = await res.text();
+    debug(`Failed to get logs: ${errorText}`);
+    throw new Error("Failed to get logs: " + errorText);
+  }
+  const logs = await res.json();
+  debug(`Got ${logs.items.length} logs, total: ${logs.totalItems}`);
+  return logs;
+};
+
+// src/commands/platform/index.ts
+var platform = (program) => {
+  const platform2 = program.command("platform").description("Manage the platform");
+  deploy(platform2);
+};
+
+// src/index.ts
+var { isTTY } = process.stdout;
+var main = async () => {
+  if (process.env.FORCE_TTY === "1") {
+    isTTY = true;
+    process.stdout.isTTY = true;
+    process.stdin.isTTY = true;
+  }
+  let exitCode = 0;
+  const program = new import_commander.Command();
+  program.option("-v, --verbose", "Enable verbose logging");
+  program.hook("preSubcommand", (thisCommand, actionCommand) => {
+    setVerbose(thisCommand.opts().verbose);
+    console.log("preSubcommand hook", thisCommand.opts().verbose);
+    if (thisCommand.opts().verbose) {
+      log("Using verbose mode");
+    }
+  });
+  program.hook("preAction", (thisCommand) => {
+    setVerbose(thisCommand.opts().verbose);
+  });
+  platform(program);
+  build(program);
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    error(err);
+    exitCode = 1;
+  }
+  return exitCode;
+};
+var handleRejection = async (err) => {
+  if (err) {
+    if (err instanceof Error) {
+      await handleUnexpected(err);
+    } else {
+      console.error(`An unexpected rejection occurred
+  ${err}`);
+    }
+  } else {
+    console.error("An unexpected empty rejection occurred");
+  }
+  process.exit(1);
+};
+var handleUnexpected = (error2) => {
+  const { message } = error2;
+  console.error(`An unexpected error occurred
+  ${message}`);
+  process.exit(1);
+};
+process.on("unhandledRejection", handleRejection);
+process.on("uncaughtException", handleUnexpected);
+process.on("exit", () => {
+  const terminal = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : void 0;
+  terminal?.write("\x1B[?25h");
+});
+main().then(async (exitCode) => {
+  process.exitCode = exitCode;
+}).catch(handleUnexpected);
+//# sourceMappingURL=index.cjs.map