wexts 3.0.1 → 4.0.0

package/dist/cli/index.mjs

@@ -1,333 +1,334 @@
 #!/usr/bin/env node
 import {
   logger
-} from "../chunk-VNNVLQLJ.mjs";
+} from "../chunk-JHOVXH3X.mjs";
 import {
   __dirname,
+  __filename,
   __name
-} from "../chunk-FCEZDH42.mjs";
+} from "../chunk-7WULUGLH.mjs";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import * as pc from "picocolors";
-import inquirer from "inquirer";
 import * as fs from "fs";
 import * as path from "path";
-import { execSync } from "child_process";
-var program = new Command();
-program.name("wexts").description("Wexts Framework - Next.js 16 + NestJS 11").version("2.0.0");
-program.action(async () => {
-  console.log(pc.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\u2557
-\u2551                                          \u2551
-\u2551      ${pc.bold("\u{1F680} Wexts Framework v2.0")}          \u2551
-\u2551                                          \u2551
-\u2551  Next.js 16 + NestJS 11 Full-Stack      \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\u255D
-        `));
-  const { action } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "action",
-      message: "What would you like to do?",
-      choices: [
-        {
-          name: "\u{1F4E6} Create a new project",
-          value: "create"
-        },
-        {
-          name: "\u{1F680} Start development server",
-          value: "dev"
-        },
-        {
-          name: "\u{1F528} Build for production",
-          value: "build"
-        },
-        {
-          name: "\u26A1 Generate code",
-          value: "generate"
-        },
-        {
-          name: "\u{1F916} Generate API client",
-          value: "codegen"
-        },
-        {
-          name: "\u274C Exit",
-          value: "exit"
-        }
-      ]
-    }
-  ]);
-  if (action === "exit") {
-    logger.info("Goodbye! \u{1F44B}");
-    process.exit(0);
-  }
-  if (action === "create") {
-    const { projectName, template } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "projectName",
-        message: "Project name:",
-        default: "my-wexts-app"
-      },
-      {
-        type: "list",
-        name: "template",
-        message: "Select template:",
-        choices: [
-          {
-            name: "\u{1F4E6} Monorepo (Next.js + NestJS)",
-            value: "monorepo"
-          },
-          {
-            name: "\u{1F3AF} API only (NestJS)",
-            value: "api"
-          },
-          {
-            name: "\u{1F310} Web only (Next.js)",
-            value: "web"
-          }
-        ]
-      }
-    ]);
-    await createProject(projectName, template);
-  } else if (action === "dev") {
-    logger.info(pc.green("\u{1F680} Starting development servers...\n"));
-    logger.warn("Dev server not yet implemented");
-  } else if (action === "build") {
-    logger.info(pc.blue("\u{1F528} Building project...\n"));
-    logger.warn("Build not yet implemented");
-  } else if (action === "generate") {
-    const { type, name } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "type",
-        message: "What to generate?",
-        choices: [
-          "controller",
-          "module",
-          "service",
-          "page"
-        ]
-      },
-      {
-        type: "input",
-        name: "name",
-        message: "Name:"
-      }
-    ]);
-    logger.info(pc.magenta(`
-\u26A1 Generating ${type}: ${name}
-`));
-    logger.warn("Code generation not yet implemented");
-  } else if (action === "codegen") {
-    logger.info(pc.cyan("\n\u{1F916} Generating API client...\n"));
-    logger.warn("Codegen not yet implemented");
-  }
-});
-program.command("create <project-name>").description("Create a new wexts project").option("-t, --template <template>", "Template to use (monorepo|api|web)", "monorepo").action(async (projectName, options) => {
-  await createProject(projectName, options.template);
-});
-program.command("dev").description("Start development servers").option("-a, --api <path>", "Path to API project", "./apps/api").option("-w, --web <path>", "Path to Web project", "./apps/web").option("-p, --port <port>", "Port for web server", "3000").option("--api-port <port>", "Port for API server", "5050").option("--no-proxy", "Disable proxy server").action(async (options) => {
-  logger.info(pc.green("\u{1F680} Starting Wexts development servers...\n"));
-  const { FusionDevServer } = await import("../dev-server/index.mjs");
-  const server = new FusionDevServer();
-  try {
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+function createCliProgram() {
+  const program = new Command();
+  program.name("wexts").description("Wexts - production-focused single-runtime Next.js + NestJS toolkit").version("3.0.3");
+  program.command("create <project-name>").description("Create a compatibility project from bundled legacy templates").option("-t, --template <template>", "Legacy template to use (monorepo|api|web)", "monorepo").option("--skip-install", "Skip dependency installation", false).action(async (projectName, options) => {
+    await createProject(projectName, options.template, {
+      skipInstall: options.skipInstall
+    });
+  });
+  program.command("dev").description("Start local development processes").option("-a, --api <path>", "Path to API project", "./apps/api").option("-w, --web <path>", "Path to Web project", "./apps/web").option("-p, --port <port>", "Port for web server", "3000").option("--api-port <port>", "Port for API server", "5050").option("--proxy", "Enable development proxy on a separate proxy port", false).action(async (options) => {
+    const { FusionDevServer } = await import("../dev-server/index.mjs");
+    const server = new FusionDevServer();
     await server.start({
       apiPath: options.api,
       webPath: options.web,
-      webPort: parseInt(options.port),
-      apiPort: parseInt(options.apiPort),
+      webPort: Number(options.port),
+      apiPort: Number(options.apiPort),
       useProxy: options.proxy
     });
-  } catch (error) {
-    logger.error("Failed to start dev server:", error.message);
-    process.exit(1);
-  }
-});
-program.command("build").description("Build for production").action(async () => {
-  logger.info(pc.blue("Building Wexts project..."));
-  logger.warn("Build not yet implemented");
-});
-program.command("generate <type> <name>").alias("g").description("Generate code (controller|module|page)").action(async (type, name) => {
-  logger.info(pc.magenta(`Generating ${type}: ${name}`));
-  logger.warn("Code generation not yet implemented");
-});
-program.command("codegen").description("Generate API client from NestJS controllers").option("-w, --watch", "Watch mode - regenerate on changes").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output path for generated client", "./packages/api-client/src").action(async (options) => {
-  const { NestJSParser, ClientGenerator, CodegenWatcher } = await import("../codegen/index.mjs");
-  if (options.watch) {
-    logger.info(pc.cyan("Starting codegen in watch mode..."));
-    const watcher = new CodegenWatcher();
-    await watcher.watch({
-      projectPath: options.project,
-      outputPath: options.output
+  });
+  program.command("generate [type] [name]").alias("g").description("Generate RPC manifest/client, or scaffold a minimal RPC service").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").action(async (type, name, options) => {
+    if (!type || type === "rpc") {
+      const { generateRpcClient } = await import("../codegen/index.mjs");
+      const manifest = await generateRpcClient({
+        projectPath: path.resolve(options.project),
+        outputPath: path.resolve(options.output)
+      });
+      logger.success(`Generated Wexts RPC client for ${manifest.services.length} service(s).`);
+      return;
+    }
+    if (type === "service") {
+      if (!name) throw new Error("Service name is required: wexts generate service hello");
+      await scaffoldRpcService(path.resolve(options.project), name);
+      logger.success(`Created RPC service ${name}. Run wexts generate to update the client.`);
+      return;
+    }
+    throw new Error(`Unknown generator "${type}". Supported generators: rpc, service.`);
+  });
+  program.command("codegen").description("Alias for wexts generate rpc").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").action(async (options) => {
+    const { generateRpcClient } = await import("../codegen/index.mjs");
+    const manifest = await generateRpcClient({
+      projectPath: path.resolve(options.project),
+      outputPath: path.resolve(options.output)
     });
-  } else {
-    logger.info(pc.cyan("Generating API client..."));
-    const parser = new NestJSParser(options.project);
-    const controllers = parser.findFusionControllers();
-    const generator = new ClientGenerator();
-    await generator.generate({
-      controllers,
-      outputPath: options.output
+    logger.success(`Generated Wexts RPC client for ${manifest.services.length} service(s).`);
+  });
+  program.command("build").description("Build a Wexts project for production").option("--skip-generate", "Skip RPC generation before build", false).option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").action(async (options) => {
+    if (!options.skipGenerate && fs.existsSync(options.project)) {
+      const { generateRpcClient } = await import("../codegen/index.mjs");
+      await generateRpcClient({
+        projectPath: path.resolve(options.project),
+        outputPath: path.resolve(options.output)
+      });
+    }
+    runScript("build", {
+      cwd: process.cwd()
+    });
+  });
+  program.command("start").description("Start the production Wexts runtime").option("-c, --config <path>", "Runtime config module path", "./wexts.runtime.js").option("-p, --port <port>", "Port to listen on", process.env.PORT ?? "3000").action(async (options) => {
+    const { startWextsRuntime } = await import("../runtime/index.mjs");
+    const configPath = path.resolve(options.config);
+    const runtimeConfig = fs.existsSync(configPath) ? await loadRuntimeConfig(configPath) : {};
+    await startWextsRuntime({
+      ...runtimeConfig,
+      port: Number(options.port),
+      dev: false
     });
+  });
+  program.command("vercel-build").description("Build for Vercel using Build Output API v3").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output dir for RPC client", "./apps/web/lib/wexts").option("-c, --config <path>", "Runtime config module path", "./wexts.runtime.js").option("--skip-codegen", "Skip RPC generation", false).option("--skip-build", "Skip project build step", false).option("--node-version <version>", "Node.js version for Vercel function", "20").option("--max-duration <seconds>", "Max duration for serverless function", "30").action(async (options) => {
+    const { buildVercelOutput } = await import("../vercel-builder/index.mjs");
+    const result = await buildVercelOutput({
+      rootDir: process.cwd(),
+      apiProjectPath: options.project,
+      rpcOutputPath: options.output,
+      runtimeConfigPath: options.config,
+      skipCodegen: options.skipCodegen,
+      skipBuild: options.skipBuild,
+      nodeVersion: options.nodeVersion,
+      maxDuration: Number(options.maxDuration)
+    });
+    if (result.warnings.length > 0) {
+      for (const warning of result.warnings) logger.warn(warning);
+    }
+    if (result.errors.length > 0) {
+      for (const error of result.errors) logger.error(error);
+      process.exit(1);
+    }
+    logger.success("Vercel build output ready at .vercel/output");
+  });
+  program.command("doctor").description("Validate Wexts project configuration").option("--security", "Run security-specific checks", false).action(async (options) => {
+    const result = runDoctor(process.cwd(), options.security);
+    for (const warning of result.warnings) logger.warn(warning);
+    for (const error of result.errors) logger.error(error);
+    if (result.errors.length > 0) process.exit(1);
+    logger.success(options.security ? "Security doctor passed." : "Doctor passed.");
+  });
+  return program;
+}
+__name(createCliProgram, "createCliProgram");
+function runDoctor(cwd, security = false) {
+  const result = {
+    errors: [],
+    warnings: []
+  };
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    result.errors.push("package.json not found.");
+    return result;
   }
-});
-async function createProject(projectName, template) {
-  logger.info(pc.cyan(`Creating wexts project: ${pc.bold(projectName)}`));
-  logger.info(`Template: ${template}`);
-  const projectPath = path.join(process.cwd(), projectName);
-  if (fs.existsSync(projectPath)) {
-    logger.error(`Directory ${projectName} already exists!`);
-    process.exit(1);
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  if (!pkg.packageManager?.startsWith("pnpm@")) {
+    result.warnings.push("packageManager should pin pnpm.");
   }
-  function getTemplatePath() {
-    const possiblePaths = [
-      path.join(__dirname, "../../templates"),
-      path.join(__dirname, "../templates"),
-      path.join(process.cwd(), "templates"),
-      path.resolve(__dirname, "..", "..", "templates")
-      // Absolute resolve
-    ];
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        return p;
-      }
+  for (const dir of [
+    "apps/api",
+    "apps/web"
+  ]) {
+    if (!fs.existsSync(path.join(cwd, dir))) {
+      result.warnings.push(`${dir} not found; some Wexts commands may need explicit paths.`);
     }
-    return "";
   }
-  __name(getTemplatePath, "getTemplatePath");
-  const templatePath = getTemplatePath();
+  if (fs.existsSync(path.join(cwd, "apps/api")) && fs.existsSync(path.join(cwd, "apps/web"))) {
+    result.warnings.push("Development mode starts separate web/API processes. Single-port serving is the production `wexts start` runtime path.");
+  }
+  if (security) {
+    const source = readAllText(cwd, [
+      "apps/api/src",
+      "packages/templates/nestjs-api/src"
+    ]);
+    if (source.includes("default-secret")) {
+      result.errors.push('JWT fallback "default-secret" found. Production apps must fail without a strong JWT_SECRET.');
+    }
+    if (/origin:\s*['"]\*['"]/.test(source)) {
+      result.errors.push("Wildcard CORS origin found. Use an explicit origin allowlist.");
+    }
+  }
+  return result;
+}
+__name(runDoctor, "runDoctor");
+async function createProject(projectName, template, options) {
+  const projectPath = path.join(process.cwd(), projectName);
+  if (fs.existsSync(projectPath)) {
+    throw new Error(`Directory already exists: ${projectName}`);
+  }
+  const templatePath = findTemplatePath();
   if (!templatePath) {
-    logger.error(`\u274C Template directory not found!`);
-    logger.info(`Searched in:`);
-    logger.info(`  - ${path.join(__dirname, "../../templates")}`);
-    logger.info(`  - ${path.join(__dirname, "../templates")}`);
-    logger.info(`  - ${path.join(process.cwd(), "templates")}`);
-    logger.warn("\u26A0\uFE0F Using fallback scaffolding (empty structure)");
-    fs.mkdirSync(projectPath, {
-      recursive: true
-    });
+    throw new Error("Template directory not found in package.");
+  }
+  fs.mkdirSync(projectPath, {
+    recursive: true
+  });
+  if (template === "monorepo") {
     fs.mkdirSync(path.join(projectPath, "apps"), {
       recursive: true
     });
-    fs.mkdirSync(path.join(projectPath, "packages"), {
+    fs.cpSync(path.join(templatePath, "nestjs-api"), path.join(projectPath, "apps/api"), {
       recursive: true
     });
-  } else {
-    logger.info(`\u{1F4E6} Copying templates from: ${templatePath}`);
-    fs.mkdirSync(projectPath, {
+    fs.cpSync(path.join(templatePath, "nextjs-web"), path.join(projectPath, "apps/web"), {
       recursive: true
     });
-    fs.mkdirSync(path.join(projectPath, "apps"), {
+    fs.writeFileSync(path.join(projectPath, "pnpm-workspace.yaml"), "packages:\n  - 'apps/*'\n");
+    fs.writeFileSync(path.join(projectPath, "package.json"), JSON.stringify({
+      name: projectName,
+      private: true,
+      packageManager: "pnpm@10.22.0",
+      scripts: {
+        dev: "wexts dev",
+        generate: "wexts generate",
+        build: "wexts build",
+        start: "wexts start",
+        doctor: "wexts doctor"
+      },
+      devDependencies: {
+        wexts: "latest"
+      }
+    }, null, 2));
+  } else if (template === "api") {
+    fs.cpSync(path.join(templatePath, "nestjs-api"), projectPath, {
       recursive: true
     });
-    fs.mkdirSync(path.join(projectPath, "packages"), {
+  } else if (template === "web") {
+    fs.cpSync(path.join(templatePath, "nextjs-web"), projectPath, {
       recursive: true
     });
-    const apiTemplatePath = path.join(templatePath, "nestjs-api");
-    const apiDestPath = path.join(projectPath, "apps/api");
-    if (fs.existsSync(apiTemplatePath)) {
-      fs.cpSync(apiTemplatePath, apiDestPath, {
-        recursive: true
-      });
-      logger.success("  - Copied API template");
-      const envExamplePath = path.join(apiDestPath, ".env.example");
-      const envPath = path.join(apiDestPath, ".env");
-      if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-        fs.copyFileSync(envExamplePath, envPath);
-        logger.success("  - Created .env from .env.example");
-      }
-    } else {
-      logger.warn(`  \u26A0\uFE0F API template not found at ${apiTemplatePath}`);
-    }
-    const webTemplatePath = path.join(templatePath, "nextjs-web");
-    const webDestPath = path.join(projectPath, "apps/web");
-    if (fs.existsSync(webTemplatePath)) {
-      fs.cpSync(webTemplatePath, webDestPath, {
-        recursive: true
-      });
-      logger.success("  - Copied Web template");
-    } else {
-      logger.warn(`  \u26A0\uFE0F Web template not found at ${webTemplatePath}`);
-    }
+  } else {
+    throw new Error(`Unknown template "${template}".`);
   }
-  const packageJson = {
-    name: projectName,
-    version: "0.0.0",
-    private: true,
-    scripts: {
-      "build": "pnpm exec turbo build",
-      "dev": "pnpm exec turbo dev",
-      "lint": "pnpm exec turbo lint",
-      "format": 'prettier --write "**/*.{ts,tsx,md}"'
-    },
-    devDependencies: {
-      "turbo": "^2.6.1",
-      "prettier": "latest",
-      "typescript": "^5.9.3",
-      "wexts": "latest"
-    },
-    packageManager: "pnpm@10.0.0"
-  };
-  fs.writeFileSync(path.join(projectPath, "package.json"), JSON.stringify(packageJson, null, 2));
-  const turboJson = {
-    "$schema": "https://turbo.build/schema.json",
-    "tasks": {
-      "build": {
-        "dependsOn": [
-          "^build"
-        ],
-        "outputs": [
-          ".next/**",
-          "!.next/cache/**",
-          "dist/**"
-        ]
-      },
-      "lint": {},
-      "dev": {
-        "cache": false,
-        "persistent": true
+  if (!options.skipInstall) {
+    runCommand(detectPackageManager(projectPath), [
+      "install"
+    ], projectPath);
+  }
+}
+__name(createProject, "createProject");
+async function scaffoldRpcService(apiProjectPath, rawName) {
+  const serviceName = toKebabCase(rawName);
+  const className = `${toPascalCase(serviceName)}Service`;
+  const dir = path.join(apiProjectPath, "src", serviceName);
+  fs.mkdirSync(dir, {
+    recursive: true
+  });
+  fs.writeFileSync(path.join(dir, `${serviceName}.service.ts`), `import { Injectable } from '@nestjs/common';
+import { RpcMethod, RpcService } from 'wexts/nest';
+
+@Injectable()
+@RpcService({ name: '${toCamelCase(serviceName)}', requireAuth: false })
+export class ${className} {
+  @RpcMethod()
+  async sayHello(name: string): Promise<string> {
+    return \`Hello, \${name}!\`;
+  }
+}
+`);
+}
+__name(scaffoldRpcService, "scaffoldRpcService");
+function runScript(script, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const packageManager = detectPackageManager(cwd);
+  const args = packageManager === "npm" ? [
+    "run",
+    script
+  ] : [
+    "run",
+    script
+  ];
+  runCommand(packageManager, args, cwd);
+}
+__name(runScript, "runScript");
+function runCommand(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} failed with exit code ${result.status}`);
+  }
+}
+__name(runCommand, "runCommand");
+function detectPackageManager(cwd) {
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+function findTemplatePath() {
+  const candidates = [
+    path.resolve(__dirname, "../../templates"),
+    path.resolve(__dirname, "../templates"),
+    path.resolve(process.cwd(), "packages/templates")
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+__name(findTemplatePath, "findTemplatePath");
+function readAllText(cwd, dirs) {
+  let text = "";
+  for (const dir of dirs) {
+    const absolute = path.join(cwd, dir);
+    if (!fs.existsSync(absolute)) continue;
+    for (const file of walk(absolute)) {
+      if (file.endsWith(".ts") || file.endsWith(".tsx") || file.endsWith(".js")) {
+        text += fs.readFileSync(file, "utf8");
       }
     }
-  };
-  fs.writeFileSync(path.join(projectPath, "turbo.json"), JSON.stringify(turboJson, null, 2));
-  const pnpmWorkspace = `packages:
-  - 'apps/*'
-  - 'packages/*'
-`;
-  fs.writeFileSync(path.join(projectPath, "pnpm-workspace.yaml"), pnpmWorkspace);
-  logger.success("\u2705 Project structure created");
-  logger.info("\u{1F4E6} Installing dependencies...");
-  try {
-    try {
-      execSync("pnpm --version", {
-        stdio: "ignore"
-      });
-    } catch {
-      logger.info("Installing pnpm...");
-      execSync("npm install -g pnpm", {
-        stdio: "ignore"
-      });
-    }
-    execSync("pnpm install", {
-      cwd: projectPath,
-      stdio: "inherit"
-    });
-    logger.success("\u2705 Dependencies installed");
-    logger.info(pc.green(`
-\u{1F389} Project ${projectName} created successfully!`));
-    logger.info(`
-To get started:
-`);
-    logger.info(pc.cyan(`  cd ${projectName}`));
-    logger.info(pc.cyan(`  pnpm dev
-`));
-  } catch (error) {
-    logger.error("Failed to install dependencies");
   }
+  return text;
 }
-__name(createProject, "createProject");
-program.parse();
+__name(readAllText, "readAllText");
+function walk(dir) {
+  return fs.readdirSync(dir, {
+    withFileTypes: true
+  }).flatMap((entry) => {
+    const absolute = path.join(dir, entry.name);
+    if (entry.isDirectory()) return walk(absolute);
+    return [
+      absolute
+    ];
+  });
+}
+__name(walk, "walk");
+function toKebabCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+__name(toKebabCase, "toKebabCase");
+function toPascalCase(value) {
+  return toKebabCase(value).split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+__name(toCamelCase, "toCamelCase");
+function pathToFileUrl(filePath) {
+  return `file://${filePath}`;
+}
+__name(pathToFileUrl, "pathToFileUrl");
+async function loadRuntimeConfig(configPath) {
+  if (configPath.endsWith(".mjs")) {
+    const mod2 = await import(pathToFileUrl(configPath));
+    return mod2.default ?? mod2;
+  }
+  const require2 = createRequire(__filename);
+  const mod = require2(configPath);
+  return mod.default ?? mod;
+}
+__name(loadRuntimeConfig, "loadRuntimeConfig");
+var invokedAsCli = process.argv[1] && (path.basename(process.argv[1]) === "wexts" || path.basename(process.argv[1]) === "wexts.cjs" || path.resolve(process.argv[1]).includes(`${path.sep}dist${path.sep}cli${path.sep}index`));
+if (invokedAsCli && !process.env.VITEST) {
+  createCliProgram().parseAsync(process.argv).catch((error) => {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  createCliProgram,
+  runDoctor
+};
 //# sourceMappingURL=index.mjs.map