devflare 1.0.0-next.15 → 1.0.0-next.16

package/dist/index-tksw7gpy.js

@@ -1,503 +0,0 @@
-import {
-  getEffectiveAccountId,
-  getPrimaryAccount,
-  listD1Databases
-} from "./index-xdq9ery1.js";
-
-// src/config/schema.ts
-import { z } from "zod";
-var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-var compatibilityDateSchema = z.string().regex(dateRegex, {
-  message: "Compatibility date must be in YYYY-MM-DD format"
-});
-var routesConfigSchema = z.object({
-  dir: z.string(),
-  prefix: z.string().optional()
-});
-var filesSchema = z.object({
-  fetch: z.union([z.string(), z.literal(false)]).optional(),
-  queue: z.union([z.string(), z.literal(false)]).optional(),
-  scheduled: z.union([z.string(), z.literal(false)]).optional(),
-  email: z.union([z.string(), z.literal(false)]).optional(),
-  durableObjects: z.union([z.string(), z.literal(false)]).optional(),
-  entrypoints: z.union([z.string(), z.literal(false)]).optional(),
-  workflows: z.union([z.string(), z.literal(false)]).optional(),
-  routes: z.union([routesConfigSchema, z.literal(false)]).optional(),
-  transport: z.union([z.string(), z.null()]).optional()
-}).optional();
-var durableObjectBindingSchema = z.custom((val) => {
-  if (typeof val === "string")
-    return true;
-  if (val && typeof val === "object" && "className" in val) {
-    const obj = val;
-    return typeof obj.className === "string";
-  }
-  return false;
-}, {
-  message: "Expected string or { className: string, scriptName?: string }"
-});
-var queueConsumerSchema = z.object({
-  queue: z.string(),
-  maxBatchSize: z.number().optional(),
-  maxBatchTimeout: z.number().optional(),
-  maxRetries: z.number().optional(),
-  deadLetterQueue: z.string().optional(),
-  maxConcurrency: z.number().optional(),
-  retryDelay: z.number().optional()
-});
-var queuesConfigSchema = z.object({
-  producers: z.record(z.string(), z.string()).optional(),
-  consumers: z.array(queueConsumerSchema).optional()
-});
-var serviceBindingSchema = z.custom((val) => {
-  if (typeof val !== "object" && typeof val !== "function")
-    return false;
-  const obj = val;
-  const service = obj.service;
-  if (typeof service !== "string")
-    return false;
-  return true;
-}, {
-  message: "Expected service binding object with { service: string } or ref().worker"
-});
-var aiBindingSchema = z.object({
-  binding: z.string()
-});
-var vectorizeBindingSchema = z.object({
-  indexName: z.string()
-});
-var hyperdriveBindingSchema = z.object({
-  id: z.string()
-});
-var browserBindingSchema = z.object({
-  binding: z.string()
-});
-var analyticsBindingSchema = z.object({
-  dataset: z.string()
-});
-var sendEmailBindingSchema = z.object({
-  destinationAddress: z.string().optional(),
-  allowedDestinationAddresses: z.array(z.string()).optional(),
-  allowedSenderAddresses: z.array(z.string()).optional()
-}).refine((binding) => {
-  return !(binding.destinationAddress && binding.allowedDestinationAddresses);
-}, {
-  message: "sendEmail bindings must use either destinationAddress or allowedDestinationAddresses, not both",
-  path: ["allowedDestinationAddresses"]
-});
-var d1BindingByIdSchema = z.object({
-  id: z.string()
-}).strict();
-var d1BindingByNameSchema = z.object({
-  name: z.string()
-}).strict();
-var d1BindingSchema = z.union([
-  z.string(),
-  d1BindingByIdSchema,
-  d1BindingByNameSchema
-]);
-var bindingsSchema = z.object({
-  kv: z.record(z.string(), z.string()).optional(),
-  d1: z.record(z.string(), d1BindingSchema).optional(),
-  r2: z.record(z.string(), z.string()).optional(),
-  durableObjects: z.record(z.string(), durableObjectBindingSchema).optional(),
-  queues: queuesConfigSchema.optional(),
-  services: z.record(z.string(), serviceBindingSchema).optional(),
-  ai: aiBindingSchema.optional(),
-  vectorize: z.record(z.string(), vectorizeBindingSchema).optional(),
-  hyperdrive: z.record(z.string(), hyperdriveBindingSchema).optional(),
-  browser: browserBindingSchema.optional(),
-  analyticsEngine: z.record(z.string(), analyticsBindingSchema).optional(),
-  sendEmail: z.record(z.string(), sendEmailBindingSchema).optional()
-}).optional();
-var triggersSchema = z.object({
-  crons: z.array(z.string()).optional()
-}).optional();
-var secretConfigSchema = z.object({
-  required: z.boolean().optional().default(true)
-});
-var routeConfigSchema = z.object({
-  pattern: z.string(),
-  zone_name: z.string().optional(),
-  zone_id: z.string().optional(),
-  custom_domain: z.boolean().optional()
-});
-var wsRouteConfigSchema = z.object({
-  pattern: z.string(),
-  doNamespace: z.string(),
-  idParam: z.string().default("id"),
-  forwardPath: z.string().default("/websocket")
-});
-var assetsConfigSchema = z.object({
-  directory: z.string(),
-  binding: z.string().optional()
-}).optional();
-var observabilitySchema = z.object({
-  enabled: z.boolean().optional(),
-  head_sampling_rate: z.number().min(0).max(1).optional()
-}).optional();
-var limitsSchema = z.object({
-  cpu_ms: z.number().optional()
-}).optional();
-var rolldownOptionsSchema = z.custom((value) => {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}, {
-  message: "Expected Rolldown options object"
-});
-var rolldownConfigSchema = z.object({
-  target: z.string().optional(),
-  minify: z.boolean().optional(),
-  sourcemap: z.boolean().optional(),
-  options: rolldownOptionsSchema.optional()
-}).optional();
-var viteConfigSchema = z.object({
-  plugins: z.array(z.unknown()).optional()
-}).catchall(z.unknown()).optional();
-var buildConfigSchema = z.object({
-  target: z.string().optional(),
-  minify: z.boolean().optional(),
-  sourcemap: z.boolean().optional(),
-  rolldownOptions: rolldownOptionsSchema.optional()
-}).optional();
-function normalizeViteConfig(vite, plugins) {
-  const normalizedVite = {
-    ...plugins !== undefined ? { plugins } : {},
-    ...vite ?? {}
-  };
-  return Object.keys(normalizedVite).length > 0 ? normalizedVite : undefined;
-}
-function normalizeRolldownConfig(rolldown, build) {
-  const normalizedRolldown = {
-    ...build?.target !== undefined ? { target: build.target } : {},
-    ...build?.minify !== undefined ? { minify: build.minify } : {},
-    ...build?.sourcemap !== undefined ? { sourcemap: build.sourcemap } : {},
-    ...build?.rolldownOptions !== undefined ? { options: build.rolldownOptions } : {},
-    ...rolldown ?? {}
-  };
-  return Object.keys(normalizedRolldown).length > 0 ? normalizedRolldown : undefined;
-}
-var migrationSchema = z.object({
-  tag: z.string(),
-  new_classes: z.array(z.string()).optional(),
-  renamed_classes: z.array(z.object({
-    from: z.string(),
-    to: z.string()
-  })).optional(),
-  deleted_classes: z.array(z.string()).optional(),
-  new_sqlite_classes: z.array(z.string()).optional()
-});
-var wranglerConfigSchema = z.object({
-  passthrough: z.record(z.string(), z.unknown()).optional()
-}).optional();
-var envConfigSchema = z.object({
-  name: z.string().optional(),
-  compatibilityDate: compatibilityDateSchema.optional(),
-  compatibilityFlags: z.array(z.string()).optional(),
-  files: filesSchema,
-  bindings: bindingsSchema,
-  triggers: triggersSchema,
-  vars: z.record(z.string(), z.string()).optional(),
-  secrets: z.record(z.string(), secretConfigSchema).optional(),
-  routes: z.array(routeConfigSchema).optional(),
-  assets: assetsConfigSchema,
-  limits: limitsSchema,
-  observability: observabilitySchema,
-  migrations: z.array(migrationSchema).optional(),
-  rolldown: rolldownConfigSchema,
-  vite: viteConfigSchema,
-  wrangler: wranglerConfigSchema
-}).partial();
-var envConfigSchemaInner = envConfigSchema.extend({
-  build: buildConfigSchema,
-  plugins: z.array(z.unknown()).optional()
-}).transform((config) => {
-  const normalizedVite = normalizeViteConfig(config.vite, config.plugins);
-  const normalizedRolldown = normalizeRolldownConfig(config.rolldown, config.build);
-  const {
-    build: _legacyBuild,
-    plugins: _legacyPlugins,
-    vite: _vite,
-    rolldown: _rolldown,
-    ...rest
-  } = config;
-  return {
-    ...rest,
-    ...normalizedVite ? { vite: normalizedVite } : {},
-    ...normalizedRolldown ? { rolldown: normalizedRolldown } : {}
-  };
-});
-function getCurrentDate() {
-  const now = new Date;
-  return now.toISOString().split("T")[0];
-}
-var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
-var canonicalConfigSchema = z.object({
-  name: z.string({
-    required_error: "Worker name is required"
-  }),
-  accountId: z.string().optional(),
-  compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
-  compatibilityFlags: z.array(z.string()).optional().transform((flags = []) => {
-    const merged = new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags]);
-    return [...merged];
-  }),
-  files: filesSchema,
-  bindings: bindingsSchema,
-  triggers: triggersSchema,
-  vars: z.record(z.string(), z.string()).optional(),
-  secrets: z.record(z.string(), secretConfigSchema).optional(),
-  routes: z.array(routeConfigSchema).optional(),
-  wsRoutes: z.array(wsRouteConfigSchema).optional(),
-  assets: assetsConfigSchema,
-  limits: limitsSchema,
-  observability: observabilitySchema,
-  migrations: z.array(migrationSchema).optional(),
-  rolldown: rolldownConfigSchema,
-  vite: viteConfigSchema,
-  env: z.record(z.string(), envConfigSchemaInner).optional(),
-  wrangler: wranglerConfigSchema
-});
-var configSchema = canonicalConfigSchema.extend({
-  build: buildConfigSchema,
-  plugins: z.array(z.unknown()).optional()
-}).transform((config) => {
-  const normalizedVite = normalizeViteConfig(config.vite, config.plugins);
-  const normalizedRolldown = normalizeRolldownConfig(config.rolldown, config.build);
-  const {
-    build: _legacyBuild,
-    plugins: _legacyPlugins,
-    vite: _vite,
-    rolldown: _rolldown,
-    ...rest
-  } = config;
-  return {
-    ...rest,
-    ...normalizedVite ? { vite: normalizedVite } : {},
-    ...normalizedRolldown ? { rolldown: normalizedRolldown } : {}
-  };
-});
-function normalizeDOBinding(config) {
-  if (typeof config === "string") {
-    return { className: config };
-  }
-  return {
-    className: config.className,
-    scriptName: config.scriptName,
-    __ref: config.__ref
-  };
-}
-function normalizeD1Binding(config) {
-  if (typeof config === "string") {
-    return { databaseId: config };
-  }
-  if ("id" in config) {
-    return { databaseId: config.id };
-  }
-  return { name: config.name };
-}
-function getLocalD1DatabaseIdentifier(config) {
-  const normalized = normalizeD1Binding(config);
-  return normalized.databaseId ?? normalized.name ?? "";
-}
-
-// src/config/loader.ts
-import { loadConfig as c12LoadConfig } from "c12";
-import { existsSync } from "node:fs";
-import { join } from "pathe";
-var CONFIG_FILES = [
-  "devflare.config.ts",
-  "devflare.config.mts",
-  "devflare.config.js",
-  "devflare.config.mjs"
-];
-async function resolveConfigPath(cwd) {
-  for (const file of CONFIG_FILES) {
-    const path = join(cwd, file);
-    if (existsSync(path)) {
-      return path;
-    }
-  }
-  return;
-}
-async function loadConfig(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const configFile = options.configFile ?? "devflare.config";
-  const { config, configFile: loadedFile } = await c12LoadConfig({
-    name: "devflare",
-    cwd,
-    configFile,
-    defaultConfig: undefined,
-    rcFile: false,
-    globalRc: false,
-    dotenv: false
-  });
-  if (!config || !loadedFile) {
-    throw new ConfigNotFoundError(cwd, configFile);
-  }
-  const result = configSchema.safeParse(config);
-  if (!result.success) {
-    throw new ConfigValidationError(result.error.issues, loadedFile);
-  }
-  return result.data;
-}
-
-class ConfigNotFoundError extends Error {
-  cwd;
-  configFile;
-  code = "CONFIG_NOT_FOUND";
-  constructor(cwd, configFile) {
-    super(`Config file not found in ${cwd}.
-` + `Expected one of: ${CONFIG_FILES.join(", ")}
-` + `Run 'devflare init' to create a new config.`);
-    this.cwd = cwd;
-    this.configFile = configFile;
-    this.name = "ConfigNotFoundError";
-  }
-}
-
-class ConfigValidationError extends Error {
-  issues;
-  configFile;
-  code = "CONFIG_VALIDATION_ERROR";
-  constructor(issues, configFile) {
-    const issueMessages = issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join(`
-`);
-    super(`Invalid config in ${configFile}:
-${issueMessages}`);
-    this.issues = issues;
-    this.configFile = configFile;
-    this.name = "ConfigValidationError";
-  }
-}
-
-// src/config/resolve.ts
-import { defu } from "defu";
-function resolveConfigForEnvironment(config, environment) {
-  if (environment && config.env?.[environment]) {
-    return defu(config.env[environment], config);
-  }
-  return config;
-}
-
-// src/config/resource-resolution.ts
-var defaultCloudflareApi = {
-  getPrimaryAccount,
-  getEffectiveAccountId,
-  listD1Databases
-};
-
-class ConfigResourceResolutionError extends Error {
-  code = "CONFIG_RESOURCE_RESOLUTION_ERROR";
-  constructor(message, cause) {
-    super(message);
-    this.name = "ConfigResourceResolutionError";
-    if (cause !== undefined) {
-      this.cause = cause;
-    }
-  }
-}
-function resolveCloudflareApi(overrides) {
-  return {
-    ...defaultCloudflareApi,
-    ...overrides ?? {}
-  };
-}
-function materializeLocalD1Bindings(bindings) {
-  return Object.fromEntries(Object.entries(bindings).map(([bindingName, bindingConfig]) => {
-    return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
-  }));
-}
-async function resolveLookupAccountId(config, options, cloudflareApi) {
-  const explicitAccountId = options.accountId ?? config.accountId;
-  if (explicitAccountId) {
-    return explicitAccountId;
-  }
-  let primaryAccount;
-  try {
-    primaryAccount = await cloudflareApi.getPrimaryAccount();
-  } catch (error) {
-    throw new ConfigResourceResolutionError("Could not resolve D1 database names because Devflare could not read your Cloudflare accounts. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.", error);
-  }
-  if (!primaryAccount) {
-    throw new ConfigResourceResolutionError("Could not resolve D1 database names because no Cloudflare account is available. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.");
-  }
-  try {
-    const { accountId } = await cloudflareApi.getEffectiveAccountId(primaryAccount.id);
-    return accountId;
-  } catch (error) {
-    throw new ConfigResourceResolutionError(`Could not determine the effective Cloudflare account for D1 name resolution after selecting primary account ${primaryAccount.id}.`, error);
-  }
-}
-function formatMissingD1Bindings(missing) {
-  return missing.map(({ bindingName, databaseName }) => `${bindingName} → ${databaseName}`).join(", ");
-}
-function resolveConfigForLocalRuntime(config, environment) {
-  const resolvedConfig = resolveConfigForEnvironment(config, environment);
-  if (!resolvedConfig.bindings?.d1) {
-    return resolvedConfig;
-  }
-  return {
-    ...resolvedConfig,
-    bindings: {
-      ...resolvedConfig.bindings,
-      d1: materializeLocalD1Bindings(resolvedConfig.bindings.d1)
-    }
-  };
-}
-async function resolveConfigResources(config, options = {}) {
-  const resolvedConfig = resolveConfigForEnvironment(config, options.environment);
-  const d1Bindings = resolvedConfig.bindings?.d1;
-  if (!d1Bindings) {
-    return resolvedConfig;
-  }
-  const pendingNameBindings = Object.entries(d1Bindings).map(([bindingName, bindingConfig]) => {
-    const normalized = normalizeD1Binding(bindingConfig);
-    return normalized.databaseId ? null : {
-      bindingName,
-      databaseName: normalized.name ?? ""
-    };
-  }).filter((binding) => binding !== null);
-  if (pendingNameBindings.length === 0) {
-    return {
-      ...resolvedConfig,
-      bindings: {
-        ...resolvedConfig.bindings,
-        d1: materializeLocalD1Bindings(d1Bindings)
-      }
-    };
-  }
-  const cloudflareApi = resolveCloudflareApi(options.cloudflare);
-  const accountId = await resolveLookupAccountId(resolvedConfig, options, cloudflareApi);
-  let databases;
-  try {
-    databases = await cloudflareApi.listD1Databases(accountId);
-  } catch (error) {
-    throw new ConfigResourceResolutionError(`Could not list D1 databases for Cloudflare account ${accountId} while resolving name-based D1 bindings.`, error);
-  }
-  const databaseIdsByName = new Map(databases.map((database) => [database.name, database.id]));
-  const missingBindings = pendingNameBindings.filter(({ databaseName }) => {
-    return !databaseIdsByName.has(databaseName);
-  });
-  if (missingBindings.length > 0) {
-    throw new ConfigResourceResolutionError(`Could not find D1 database(s) for ${formatMissingD1Bindings(missingBindings)} in Cloudflare account ${accountId}.`);
-  }
-  return {
-    ...resolvedConfig,
-    bindings: {
-      ...resolvedConfig.bindings,
-      d1: Object.fromEntries(Object.entries(d1Bindings).map(([bindingName, bindingConfig]) => {
-        const normalized = normalizeD1Binding(bindingConfig);
-        return [
-          bindingName,
-          normalized.databaseId ?? databaseIdsByName.get(normalized.name ?? "") ?? ""
-        ];
-      }))
-    }
-  };
-}
-async function loadResolvedConfig(options = {}) {
-  const config = await loadConfig(options);
-  return resolveConfigResources(config, options);
-}
-
-export { configSchema, normalizeDOBinding, normalizeD1Binding, getLocalD1DatabaseIdentifier, resolveConfigForEnvironment, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };

package/dist/index-v43z02tr.js

@@ -1,205 +0,0 @@
-import {
-  getPackageVersion
-} from "./index-6h8xbs75.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/index.ts
-import { createConsola } from "consola";
-var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "config", "account", "ai", "remote", "help", "version"];
-function parseArgs(argv) {
-  const args = [];
-  const options = {};
-  let command = "help";
-  let unknownCommand;
-  let i = 0;
-  while (i < argv.length) {
-    const arg = argv[i];
-    if (arg === "--help" || arg === "-h") {
-      return { command: "help", args: [], options: {} };
-    }
-    if (arg === "--version" || arg === "-v") {
-      return { command: "version", args: [], options: {} };
-    }
-    if (arg.startsWith("-") && !/^-\d/.test(arg)) {
-      const isLongFlag = arg.startsWith("--");
-      const key = isLongFlag ? arg.slice(2) : arg.slice(1);
-      const nextArg = argv[i + 1];
-      if (nextArg && !nextArg.startsWith("-")) {
-        options[key] = nextArg;
-        i += 2;
-      } else {
-        options[key] = true;
-        i++;
-      }
-    } else if (!command || command === "help") {
-      if (COMMANDS.includes(arg)) {
-        command = arg;
-      } else {
-        command = "help";
-        unknownCommand = arg;
-      }
-      i++;
-    } else {
-      args.push(arg);
-      i++;
-    }
-  }
-  return { command, args, options, unknownCommand };
-}
-function getHelpText() {
-  return `
-devflare - Config compiler + CLI orchestrator for Cloudflare Workers
-
-Usage:
-  devflare <command> [options]
-
-Commands:
-	init [name]         Create a new devflare project
-	dev                 Start the development server
-	build               Build for production
-	deploy              Deploy to Cloudflare
-	types               Generate TypeScript types
-	doctor              Check project configuration
-	config              Print resolved Devflare/Wrangler config
-	account             View Cloudflare account info
-	ai                  View AI models and pricing
-	remote              Manage remote test mode (AI, Vectorize)
-	help                Show command overview
-	version             Show the installed devflare version
-
-Common Options:
-	--config <path>     Used by dev, build, deploy, types, doctor, and config
-	--env <name>        Used by build, deploy, and config to select config.env[name]
-	--debug             Enable debug output for supported commands
-	-h, --help          Show help
-	-v, --version       Show version
-
-Dev Options:
-	--port <port>       Preferred Vite dev server port (default: 5173)
-	--persist           Persist Miniflare storage data
-	--verbose           Enable verbose logging
-	--log               Log all output to a timestamped .log-* file and the terminal
-	--log-temp          Log all output to .log (overwritten) and the terminal
-
-Build / Deploy:
-	build --env <name>          Use config.env[name]
-	deploy --env <name>         Use config.env[name]
-	deploy --dry-run            Print the generated Wrangler config without deploying
-
-Types / Doctor:
-	types --output <path>       Write generated types to a custom path
-	doctor --config <path>      Check a specific devflare config file
-	config print --json         Print resolved config as JSON
-	config print --format wrangler  Print resolved Wrangler config JSON
-
-Account / Remote:
-	account --account <id>      Use a specific Cloudflare account
-	remote status               Show current remote-mode status
-	remote enable [minutes]     Enable remote mode (default: 30 minutes)
-	remote disable              Disable remote mode
-
-Notes:
-	• Worker-only mode is the default when the current package has no local vite.config.*
-	• Vite is started only when the current package provides a local vite.config.*
-	• Higher-level build flows currently synthesize a composed worker entry when worker surfaces are discovered
-
-Examples:
-  devflare init my-app
-	devflare dev                  # Start worker-only or unified dev server
-	devflare dev --port 3000      # Custom Vite port when Vite is enabled
-  devflare dev --persist        # Persist storage between restarts
-  devflare dev --log-temp       # Log output to .log file
-  devflare build
-  devflare deploy --env production
-`.trim();
-}
-async function runCli(argv, options = {}) {
-  const logger = createConsola({
-    level: options.silent ? -999 : 3,
-    formatOptions: {
-      date: false
-    }
-  });
-  const parsed = parseArgs(argv);
-  if (parsed.unknownCommand) {
-    logger.error(`Unknown command: ${parsed.unknownCommand}`);
-    logger.info("Run `devflare --help` for available commands");
-    return { exitCode: 1 };
-  }
-  switch (parsed.command) {
-    case "help":
-      logger.info(getHelpText());
-      return { exitCode: 0, output: getHelpText() };
-    case "version":
-      const version = await getPackageVersion();
-      logger.info(`devflare v${version}`);
-      return { exitCode: 0, output: version };
-    case "init":
-      return runInit(parsed, logger, options);
-    case "dev":
-      return runDev(parsed, logger, options);
-    case "build":
-      return runBuild(parsed, logger, options);
-    case "deploy":
-      return runDeploy(parsed, logger, options);
-    case "types":
-      return runTypes(parsed, logger, options);
-    case "doctor":
-      return runDoctor(parsed, logger, options);
-    case "config":
-      return runConfig(parsed, logger, options);
-    case "account":
-      return runAccount(parsed, logger, options);
-    case "ai":
-      return runAI();
-    case "remote":
-      return runRemote(parsed, logger, options);
-    default:
-      logger.error(`Unknown command: ${parsed.command}`);
-      return { exitCode: 1 };
-  }
-}
-async function runInit(parsed, logger, options) {
-  const { runInitCommand } = await import("./init-na2atvz2.js");
-  return runInitCommand(parsed, logger, options);
-}
-async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-ymtphbkg.js");
-  return runDevCommand(parsed, logger, options);
-}
-async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-zv25ke4s.js");
-  return runBuildCommand(parsed, logger, options);
-}
-async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-6xmqvv06.js");
-  return runDeployCommand(parsed, logger, options);
-}
-async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-158m16vd.js");
-  return runTypesCommand(parsed, logger, options);
-}
-async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-xv4gm1h4.js");
-  return runDoctorCommand(parsed, logger, options);
-}
-async function runConfig(parsed, logger, options) {
-  const { runConfigCommand } = await import("./config-v9tr4rts.js");
-  return runConfigCommand(parsed, logger, options);
-}
-async function runAccount(parsed, logger, options) {
-  const { runAccountCommand } = await import("./account-spa7gzsn.js");
-  return runAccountCommand(parsed, logger, options);
-}
-async function runAI() {
-  const { runAICommand } = await import("./ai-dx4fr9jh.js");
-  return runAICommand();
-}
-async function runRemote(parsed, logger, options) {
-  const { runRemoteCommand } = await import("./remote-q59qk463.js");
-  return runRemoteCommand(parsed, logger, options);
-}
-
-export { parseArgs, runCli };