@testdino/playwright 1.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,751 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, existsSync, statSync, writeFileSync, unlinkSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import jiti from 'jiti';
+import { randomUUID } from 'crypto';
+import { tmpdir } from 'os';
+import { execa } from 'execa';
+
+var CONFIG_FILENAMES = ["testdino.config.ts", "testdino.config.js"];
+var ConfigLoader = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Load config file from current directory or parent directories
+   */
+  async load() {
+    const configPath = this.findConfigFile();
+    if (!configPath) {
+      return { config: {} };
+    }
+    try {
+      const config = this.loadConfigFile(configPath);
+      return { config, configPath };
+    } catch (error) {
+      throw new Error(
+        `Failed to load config file: ${configPath}
+${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Find config file by searching up directory tree
+   * Stops at .git directory
+   */
+  findConfigFile() {
+    let currentDir = this.cwd;
+    while (true) {
+      for (const filename of CONFIG_FILENAMES) {
+        const configPath = join(currentDir, filename);
+        if (existsSync(configPath)) {
+          return configPath;
+        }
+      }
+      const gitDir = join(currentDir, ".git");
+      if (existsSync(gitDir) && statSync(gitDir).isDirectory()) {
+        for (const filename of CONFIG_FILENAMES) {
+          const configPath = join(currentDir, filename);
+          if (existsSync(configPath)) {
+            return configPath;
+          }
+        }
+        break;
+      }
+      const parentDir = dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+    return void 0;
+  }
+  /**
+   * Load and parse config file using jiti
+   */
+  loadConfigFile(configPath) {
+    const jitiLoader = jiti(dirname(configPath), {
+      interopDefault: true,
+      cache: false,
+      extensions: [".ts", ".js"]
+    });
+    let loaded;
+    try {
+      const resolved = jitiLoader.esmResolve(configPath, { try: true });
+      if (!resolved) {
+        throw new Error(`Could not resolve config file: ${configPath}`);
+      }
+      const resolvedPath = typeof resolved === "string" ? resolved : fileURLToPath(resolved);
+      loaded = jitiLoader(resolvedPath);
+    } catch (error) {
+      throw new Error(`Syntax error in config file:
+${error instanceof Error ? error.message : String(error)}`);
+    }
+    let config;
+    if (loaded && typeof loaded === "object" && "__esModule" in loaded) {
+      config = loaded.default;
+    } else if (loaded && typeof loaded === "object" && "default" in loaded) {
+      config = loaded.default;
+    } else {
+      config = loaded;
+    }
+    if (config === null || config === void 0) {
+      return {};
+    }
+    if (typeof config === "function") {
+      try {
+        config = config();
+      } catch (error) {
+        throw new Error(`Error executing config function:
+${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (config instanceof Promise) {
+        throw new Error("Async config functions are not supported");
+      }
+      if (config === null || config === void 0) {
+        return {};
+      }
+    }
+    if (config && typeof config !== "object") {
+      throw new Error("Config must be an object");
+    }
+    return config ?? {};
+  }
+};
+var PLAYWRIGHT_CONFIG_FILENAMES = ["playwright.config.ts", "playwright.config.js"];
+var TESTDINO_REPORTER_NAMES = ["@testdino/playwright", "testdino-playwright", "TestdinoReporter"];
+var ConfigDetector = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * Detect TestdinoReporter in Playwright config
+   */
+  async detect() {
+    const configPath = this.findPlaywrightConfig();
+    if (!configPath) {
+      return { hasReporter: false };
+    }
+    try {
+      const config = this.loadPlaywrightConfig(configPath);
+      const result = this.extractTestdinoReporter(config);
+      return {
+        ...result,
+        configPath
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to load Playwright config: ${configPath}
+${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Find playwright.config.[ts|js] in current directory
+   */
+  findPlaywrightConfig() {
+    for (const filename of PLAYWRIGHT_CONFIG_FILENAMES) {
+      const configPath = join(this.cwd, filename);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Load and parse Playwright config using jiti
+   */
+  loadPlaywrightConfig(configPath) {
+    const jitiLoader = jiti(dirname(configPath), {
+      interopDefault: true,
+      cache: false,
+      extensions: [".ts", ".js"]
+    });
+    let loaded;
+    try {
+      const resolved = jitiLoader.esmResolve(configPath, { try: true });
+      if (!resolved) {
+        throw new Error(`Could not resolve Playwright config: ${configPath}`);
+      }
+      const resolvedPath = typeof resolved === "string" ? resolved : fileURLToPath(resolved);
+      loaded = jitiLoader(resolvedPath);
+    } catch (error) {
+      throw new Error(`Syntax error in Playwright config:
+${error instanceof Error ? error.message : String(error)}`);
+    }
+    let config;
+    if (loaded && typeof loaded === "object" && "__esModule" in loaded) {
+      config = loaded.default;
+    } else if (loaded && typeof loaded === "object" && "default" in loaded) {
+      config = loaded.default;
+    } else {
+      config = loaded;
+    }
+    if (typeof config === "function") {
+      try {
+        config = config();
+      } catch (error) {
+        throw new Error(
+          `Error executing Playwright config function:
+${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (!config || typeof config !== "object") {
+      throw new Error("Playwright config must be an object");
+    }
+    return config;
+  }
+  /**
+   * Extract TestdinoReporter configuration from Playwright config
+   */
+  extractTestdinoReporter(config) {
+    const { reporter } = config;
+    if (!reporter) {
+      return { hasReporter: false };
+    }
+    if (typeof reporter === "string") {
+      if (this.isTestdinoReporter(reporter)) {
+        return { hasReporter: true, options: {} };
+      }
+      return { hasReporter: false };
+    }
+    if (Array.isArray(reporter) && reporter.length > 0) {
+      if (typeof reporter[0] === "string") {
+        const [name, options] = reporter;
+        if (this.isTestdinoReporter(name)) {
+          return {
+            hasReporter: true,
+            options: this.extractOptions(options)
+          };
+        }
+      }
+      for (const item of reporter) {
+        if (typeof item === "string") {
+          if (this.isTestdinoReporter(item)) {
+            return { hasReporter: true, options: {} };
+          }
+        } else if (Array.isArray(item) && item.length > 0) {
+          const [name, options] = item;
+          if (this.isTestdinoReporter(name)) {
+            return {
+              hasReporter: true,
+              options: this.extractOptions(options)
+            };
+          }
+        }
+      }
+    }
+    return { hasReporter: false };
+  }
+  /**
+   * Check if reporter name matches TestdinoReporter
+   */
+  isTestdinoReporter(name) {
+    return TESTDINO_REPORTER_NAMES.some((testdinoName) => name === testdinoName || name.includes(testdinoName));
+  }
+  /**
+   * Extract and validate TestdinoConfig options
+   */
+  extractOptions(options) {
+    if (!options || typeof options !== "object") {
+      return {};
+    }
+    const config = {};
+    if ("token" in options && typeof options.token === "string") {
+      config.token = options.token;
+    }
+    if ("serverUrl" in options && typeof options.serverUrl === "string") {
+      config.serverUrl = options.serverUrl;
+    }
+    if ("ciBuildId" in options && typeof options.ciBuildId === "string") {
+      config.ciBuildId = options.ciBuildId;
+    }
+    if ("debug" in options && typeof options.debug === "boolean") {
+      config.debug = options.debug;
+    }
+    return config;
+  }
+};
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigValidationError";
+  }
+};
+var ConfigMerger = class _ConfigMerger {
+  static DEFAULT_SERVER_URL = "https://api.testdino.com";
+  /**
+   * Merge configurations from all sources
+   * Priority (highest to lowest):
+   * 1. CLI flags
+   * 2. testdino.config.[ts|js]
+   * 3. playwright.config reporter options
+   * 4. Environment variables
+   */
+  merge(sources) {
+    const { env = {}, playwrightConfig = {}, testdinoConfig = {}, cliOptions = {} } = sources;
+    const token = this.selectValue(cliOptions.token, testdinoConfig.token, playwrightConfig.token, env.token);
+    const serverUrl = this.selectValue(cliOptions.serverUrl, testdinoConfig.serverUrl, playwrightConfig.serverUrl, env.serverUrl) || _ConfigMerger.DEFAULT_SERVER_URL;
+    const ciRunId = this.selectValue(cliOptions.ciRunId, testdinoConfig.ciRunId, playwrightConfig.ciBuildId) || this.generateCiRunId();
+    const debug = this.selectValue(cliOptions.debug, testdinoConfig.debug, playwrightConfig.debug, env.debug) ?? false;
+    const artifacts = cliOptions.noArtifacts === true ? false : this.selectValue(testdinoConfig.artifacts, playwrightConfig.artifacts) ?? true;
+    const mergedConfig = {
+      token,
+      serverUrl,
+      ciRunId,
+      debug,
+      artifacts
+    };
+    this.validate(mergedConfig);
+    return mergedConfig;
+  }
+  /**
+   * Select first non-undefined value from arguments
+   */
+  selectValue(...values) {
+    return values.find((value) => value !== void 0 && value !== null);
+  }
+  /**
+   * Generate a unique CI run ID
+   */
+  generateCiRunId() {
+    return `run-${randomUUID()}`;
+  }
+  /**
+   * Validate merged configuration
+   */
+  validate(config) {
+    const errors = [];
+    if (!config.token || typeof config.token !== "string" || config.token.trim().length === 0) {
+      errors.push("Token is required and must be a non-empty string");
+    }
+    if (config.serverUrl) {
+      if (typeof config.serverUrl !== "string") {
+        errors.push("Server URL must be a string");
+      } else if (!this.isValidUrl(config.serverUrl)) {
+        errors.push("Server URL must be a valid HTTP/HTTPS URL");
+      }
+    }
+    if (config.ciRunId && typeof config.ciRunId !== "string") {
+      errors.push("CI run ID must be a string");
+    }
+    if (config.debug !== void 0 && typeof config.debug !== "boolean") {
+      errors.push("Debug flag must be a boolean");
+    }
+    if (errors.length > 0) {
+      throw new ConfigValidationError(`Configuration validation failed:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+    }
+  }
+  /**
+   * Check if string is a valid URL
+   */
+  isValidUrl(urlString) {
+    try {
+      const url = new URL(urlString);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get environment variables as config
+   */
+  static getEnvConfig() {
+    const config = {};
+    if (process.env.TESTDINO_TOKEN) {
+      config.token = process.env.TESTDINO_TOKEN;
+    }
+    if (process.env.TESTDINO_SERVER_URL) {
+      config.serverUrl = process.env.TESTDINO_SERVER_URL;
+    }
+    if (process.env.TESTDINO_DEBUG) {
+      config.debug = process.env.TESTDINO_DEBUG === "true" || process.env.TESTDINO_DEBUG === "1";
+    }
+    return config;
+  }
+};
+
+// src/cli/arg-filter.ts
+var TESTDINO_FLAGS = ["--token", "-t", "--ci-run-id", "--server-url", "--debug", "--no-artifacts"];
+var FLAGS_WITH_VALUES = ["--token", "-t", "--ci-run-id", "--server-url"];
+var ArgFilter = class {
+  /**
+   * Filter TestDino-specific arguments from the argument list
+   * Removes both flags and their values
+   *
+   * @param args - Raw command line arguments
+   * @returns Filtered arguments safe to pass to Playwright
+   */
+  filter(args) {
+    const result = [];
+    let skipNext = false;
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
+      if (this.isTestdinoFlag(arg)) {
+        if (this.isFlagWithValue(arg) && !arg.includes("=")) {
+          skipNext = true;
+        }
+        continue;
+      }
+      if (this.isTestdinoFlagWithEquals(arg)) {
+        continue;
+      }
+      result.push(arg);
+    }
+    return result;
+  }
+  /**
+   * Check if argument is a TestDino flag
+   */
+  isTestdinoFlag(arg) {
+    const flagName = arg.split("=")[0];
+    return TESTDINO_FLAGS.includes(flagName);
+  }
+  /**
+   * Check if argument is a TestDino flag with = syntax
+   */
+  isTestdinoFlagWithEquals(arg) {
+    if (!arg.includes("=")) {
+      return false;
+    }
+    const flagName = arg.split("=")[0];
+    return TESTDINO_FLAGS.includes(flagName);
+  }
+  /**
+   * Check if flag takes a value
+   */
+  isFlagWithValue(arg) {
+    const flagName = arg.split("=")[0];
+    return FLAGS_WITH_VALUES.includes(flagName);
+  }
+  /**
+   * Get list of TestDino flags (for reference/testing)
+   */
+  static getTestdinoFlags() {
+    return [...TESTDINO_FLAGS];
+  }
+};
+var TempConfigManager = class {
+  tempFiles = /* @__PURE__ */ new Set();
+  cleanupHandlersRegistered = false;
+  exitHandler;
+  sigintHandler;
+  sigtermHandler;
+  uncaughtExceptionHandler;
+  unhandledRejectionHandler;
+  /**
+   * Create a temporary config file with the merged configuration
+   * @param config - Merged configuration to write
+   * @returns Temp config info with path and config
+   */
+  create(config) {
+    const tempPath = this.generateTempPath();
+    try {
+      const configJson = JSON.stringify(config, null, 2);
+      writeFileSync(tempPath, configJson, "utf-8");
+      this.tempFiles.add(tempPath);
+      if (!this.cleanupHandlersRegistered) {
+        this.registerCleanupHandlers();
+        this.cleanupHandlersRegistered = true;
+      }
+      return {
+        path: tempPath,
+        config
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to create temp config file: ${tempPath}
+${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Clean up a specific temp config file
+   * @param tempPath - Path to temp file to clean up
+   */
+  cleanup(tempPath) {
+    try {
+      if (existsSync(tempPath)) {
+        unlinkSync(tempPath);
+      }
+      this.tempFiles.delete(tempPath);
+    } catch {
+      console.warn(`\u26A0\uFE0F  TestDino: Failed to cleanup temp file: ${tempPath}`);
+    }
+  }
+  /**
+   * Clean up all tracked temp files
+   */
+  cleanupAll() {
+    for (const tempPath of this.tempFiles) {
+      this.cleanup(tempPath);
+    }
+    this.tempFiles.clear();
+  }
+  /**
+   * Remove all event handlers (for testing)
+   */
+  removeHandlers() {
+    if (this.exitHandler) {
+      process.removeListener("exit", this.exitHandler);
+    }
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+    }
+    if (this.sigtermHandler) {
+      process.removeListener("SIGTERM", this.sigtermHandler);
+    }
+    if (this.uncaughtExceptionHandler) {
+      process.removeListener("uncaughtException", this.uncaughtExceptionHandler);
+    }
+    if (this.unhandledRejectionHandler) {
+      process.removeListener("unhandledRejection", this.unhandledRejectionHandler);
+    }
+    this.cleanupHandlersRegistered = false;
+  }
+  /**
+   * Generate unique temp file path
+   */
+  generateTempPath() {
+    const filename = `testdino-config-${randomUUID()}.json`;
+    return join(tmpdir(), filename);
+  }
+  /**
+   * Register cleanup handlers for process exit and signals
+   */
+  registerCleanupHandlers() {
+    this.exitHandler = () => {
+      this.cleanupAll();
+    };
+    process.on("exit", this.exitHandler);
+    this.sigintHandler = () => {
+      this.cleanupAll();
+      process.exit(130);
+    };
+    process.on("SIGINT", this.sigintHandler);
+    this.sigtermHandler = () => {
+      this.cleanupAll();
+      process.exit(143);
+    };
+    process.on("SIGTERM", this.sigtermHandler);
+    this.uncaughtExceptionHandler = (error) => {
+      console.error("Uncaught exception:", error);
+      this.cleanupAll();
+      process.exit(1);
+    };
+    process.on("uncaughtException", this.uncaughtExceptionHandler);
+    this.unhandledRejectionHandler = (reason) => {
+      console.error("Unhandled rejection:", reason);
+      this.cleanupAll();
+      process.exit(1);
+    };
+    process.on("unhandledRejection", this.unhandledRejectionHandler);
+  }
+  /**
+   * Get list of tracked temp files (for testing)
+   */
+  getTempFiles() {
+    return Array.from(this.tempFiles);
+  }
+};
+var PlaywrightSpawner = class {
+  /**
+   * Spawn Playwright test process
+   * @param options - Spawn options
+   * @returns Spawn result with exit code
+   */
+  async spawn(options) {
+    const { args, tempConfigPath, config, cwd = process.cwd() } = options;
+    try {
+      const env = {
+        ...process.env,
+        TESTDINO_CLI_CONFIG_PATH: tempConfigPath,
+        TESTDINO_TOKEN: config.token,
+        TESTDINO_SERVER_URL: config.serverUrl,
+        TESTDINO_CI_RUN_ID: config.ciRunId,
+        TESTDINO_DEBUG: config.debug ? "true" : "false"
+      };
+      const playwrightArgs = ["playwright", "test", "--reporter", "@testdino/playwright", ...args];
+      const result = await execa("npx", playwrightArgs, {
+        stdio: "inherit",
+        // Forward stdout/stderr in real-time
+        cwd,
+        env,
+        reject: false
+        // Don't throw on non-zero exit codes
+      });
+      const exitCode = result.exitCode ?? 0;
+      return {
+        exitCode,
+        success: exitCode === 0
+      };
+    } catch (error) {
+      return this.handleSpawnError(error);
+    }
+  }
+  /**
+   * Handle spawn errors
+   */
+  handleSpawnError(error) {
+    const execaError = error;
+    if (execaError.code === "ENOENT") {
+      console.error("\u274C TestDino: Failed to spawn Playwright");
+      console.error("");
+      console.error("Playwright is not installed or npx is not available.");
+      console.error("");
+      console.error("To install Playwright:");
+      console.error("  npm install -D @playwright/test");
+      console.error("  npx playwright install");
+      console.error("");
+      return {
+        exitCode: 1,
+        success: false
+      };
+    }
+    if (execaError.code === "EACCES") {
+      console.error("\u274C TestDino: Permission denied when trying to spawn Playwright");
+      console.error("");
+      console.error("Please check file permissions and try again.");
+      console.error("");
+      return {
+        exitCode: 1,
+        success: false
+      };
+    }
+    console.error("\u274C TestDino: Failed to spawn Playwright");
+    console.error("");
+    console.error("Error:", execaError.message || String(error));
+    console.error("");
+    return {
+      exitCode: 1,
+      success: false
+    };
+  }
+};
+
+// src/cli/commands/test.ts
+var TestCommand = class {
+  configLoader;
+  configDetector;
+  configMerger;
+  argFilter;
+  tempConfigManager;
+  playwrightSpawner;
+  constructor(configLoader, configDetector, configMerger, argFilter, tempConfigManager, playwrightSpawner) {
+    this.configLoader = configLoader || new ConfigLoader();
+    this.configDetector = configDetector || new ConfigDetector();
+    this.configMerger = configMerger || new ConfigMerger();
+    this.argFilter = argFilter || new ArgFilter();
+    this.tempConfigManager = tempConfigManager || new TempConfigManager();
+    this.playwrightSpawner = playwrightSpawner || new PlaywrightSpawner();
+  }
+  /**
+   * Execute the test command
+   * @param options - CLI options from commander
+   * @param args - Remaining arguments to pass to Playwright
+   * @returns Spawn result with exit code
+   */
+  async execute(options, args) {
+    let tempConfigPath;
+    try {
+      const testdinoConfigResult = await this.configLoader.load();
+      const playwrightConfigResult = await this.configDetector.detect();
+      const envConfig = ConfigMerger.getEnvConfig();
+      const mergedConfig = this.configMerger.merge({
+        env: envConfig,
+        playwrightConfig: playwrightConfigResult.options,
+        testdinoConfig: testdinoConfigResult.config,
+        cliOptions: options
+      });
+      const tempConfigInfo = this.tempConfigManager.create(mergedConfig);
+      tempConfigPath = tempConfigInfo.path;
+      const filteredArgs = this.argFilter.filter(args);
+      const result = await this.playwrightSpawner.spawn({
+        args: filteredArgs,
+        tempConfigPath,
+        config: mergedConfig
+      });
+      return result;
+    } finally {
+      if (tempConfigPath) {
+        this.tempConfigManager.cleanup(tempConfigPath);
+      }
+    }
+  }
+};
+
+// src/cli/index.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+function getVersion() {
+  try {
+    const packagePath = join(__dirname$1, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function printBanner() {
+  const version = getVersion();
+  console.log(
+    chalk.cyan(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                           \u2551
+\u2551   ${chalk.bold("TestDino Playwright")} v${version.padEnd(36)}\u2551
+\u2551   ${chalk.dim("https://testdino.com")}                                  \u2551
+\u2551                                                           \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+}
+function buildProgram() {
+  const program = new Command().name("tdpw").description("Run Playwright tests with TestDino reporting").version(getVersion(), "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command");
+  program.command("test").description("Run Playwright tests with TestDino reporter").option("-t, --token <token>", "TestDino authentication token").option("--ci-run-id <id>", "CI run ID for grouping test runs").option("--server-url <url>", "TestDino server URL").option("--debug", "Enable debug logging").option("--no-artifacts", "Disable artifact uploads (screenshots, videos, traces)").allowUnknownOption().allowExcessArguments().action(async (options, command) => {
+    try {
+      const args = command.args || [];
+      const testCommand = new TestCommand();
+      const result = await testCommand.execute(options, args);
+      process.exit(result.exitCode);
+    } catch (error) {
+      console.error(chalk.red("\n\u2716 Unexpected error:"), error instanceof Error ? error.message : String(error));
+      if (options.debug) {
+        console.error(chalk.dim("\nStack trace:"));
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+  return program;
+}
+async function main() {
+  try {
+    printBanner();
+    const program = buildProgram();
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    console.error(chalk.red("\n\u2716 Error:"), error instanceof Error ? error.message : String(error));
+    if (process.env.DEBUG || process.env.TESTDINO_DEBUG) {
+      console.error(chalk.dim("\nStack trace:"));
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error(chalk.red("Unexpected error:"), error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map