devflare 1.0.0-next.1 → 1.0.0-next.11

package/dist/index-ws68xvq2.js

@@ -0,0 +1,311 @@
+import {
+  discoverRoutes
+} from "./index-1p814k7s.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/worker-entry/composed-worker.ts
+import { defu } from "defu";
+import { dirname, relative, resolve } from "pathe";
+var DEFAULT_FETCH_ENTRY_FILES = [
+  "src/fetch.ts",
+  "src/fetch.js",
+  "src/fetch.mts",
+  "src/fetch.mjs"
+];
+var DEFAULT_QUEUE_ENTRY_FILES = [
+  "src/queue.ts",
+  "src/queue.js",
+  "src/queue.mts",
+  "src/queue.mjs"
+];
+var DEFAULT_SCHEDULED_ENTRY_FILES = [
+  "src/scheduled.ts",
+  "src/scheduled.js",
+  "src/scheduled.mts",
+  "src/scheduled.mjs"
+];
+var DEFAULT_EMAIL_ENTRY_FILES = [
+  "src/email.ts",
+  "src/email.js",
+  "src/email.mts",
+  "src/email.mjs"
+];
+function resolveConfigForEnvironment(config, environment) {
+  if (environment && config.env?.[environment]) {
+    return defu(config.env[environment], config);
+  }
+  return config;
+}
+async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
+  if (configuredPath === false) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  const candidates = new Set;
+  if (typeof configuredPath === "string" && configuredPath) {
+    candidates.add(configuredPath);
+  }
+  for (const defaultEntry of defaultEntries) {
+    candidates.add(defaultEntry);
+  }
+  for (const candidate of candidates) {
+    const absolutePath = resolve(cwd, candidate);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function resolveWorkerSurfacePaths(cwd, config) {
+  return {
+    fetch: await resolveWorkerHandlerPath(cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES),
+    queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES),
+    scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES),
+    email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES)
+  };
+}
+function toImportSpecifier(fromFilePath, toFilePath) {
+  const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
+  if (!routeDiscovery) {
+    return [];
+  }
+  return routeDiscovery.routes.map((route, index) => ({
+    identifier: `__devflareRouteModule${index}`,
+    importPath: toImportSpecifier(entryPath, route.absolutePath),
+    filePath: route.filePath,
+    routePath: route.routePath,
+    segmentsJson: JSON.stringify(route.segments)
+  }));
+}
+function needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery) {
+  return Boolean(surfacePaths.fetch || surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || routeDiscovery?.routes.length);
+}
+function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, routeImports = [], options = {}) {
+  const importLines = [`import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`];
+  const moduleFallbackLines = [];
+  const localSendEmailBindings = JSON.stringify(configuredLocalSendEmailBindings);
+  const routeManifestEntries = routeImports.map(({ identifier, filePath, routePath, segmentsJson }) => {
+    return `	{ filePath: ${JSON.stringify(filePath)}, routePath: ${JSON.stringify(routePath)}, segments: ${segmentsJson}, module: ${identifier} }`;
+  });
+  const registerSurfaceModule = (identifier, importPath) => {
+    if (importPath) {
+      importLines.push(`import * as ${identifier} from '${importPath}'`);
+      return;
+    }
+    moduleFallbackLines.push(`const ${identifier} = {}`);
+  };
+  registerSurfaceModule("__devflareFetchModule", surfaceImportPaths.fetch);
+  registerSurfaceModule("__devflareQueueModule", surfaceImportPaths.queue);
+  registerSurfaceModule("__devflareScheduledModule", surfaceImportPaths.scheduled);
+  registerSurfaceModule("__devflareEmailModule", surfaceImportPaths.email);
+  for (const routeImport of routeImports) {
+    importLines.push(`import * as ${routeImport.identifier} from '${routeImport.importPath}'`);
+  }
+  const includeDevInternalEmail = options.devInternalEmail === true;
+  const devInternalEmailHelpers = includeDevInternalEmail ? `
+function __devflareCreateEmailHeaders(rawBody) {
+	const headers = new Headers()
+	const lines = rawBody.split(/\\r?\\n/)
+
+	for (const line of lines) {
+		if (line.trim() === '') {
+			break
+		}
+
+		const colonIndex = line.indexOf(':')
+		if (colonIndex <= 0) {
+			continue
+		}
+
+		headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim())
+	}
+
+	return headers
+}
+
+function __devflareCreateEmailRawStream(rawBody) {
+	return new ReadableStream({
+		start(controller) {
+			controller.enqueue(new TextEncoder().encode(rawBody))
+			controller.close()
+		}
+	})
+}
+
+async function __devflareHandleInternalEmail(request, env, ctx) {
+	if (!__devflareEmailHandler) {
+		return new Response('Email handler not configured', { status: 501 })
+	}
+
+	const from = request.headers.get('x-devflare-email-from') || 'unknown@example.com'
+	const to = request.headers.get('x-devflare-email-to') || 'worker@example.com'
+	const rawBody = await request.text()
+	const emailMessage = {
+		from,
+		to,
+		headers: __devflareCreateEmailHeaders(rawBody),
+		raw: __devflareCreateEmailRawStream(rawBody),
+		rawSize: rawBody.length,
+		setReject(reason) {
+			console.warn('[Devflare email rejected]', reason)
+		},
+		async forward(rcptTo) {
+			console.log('[Devflare email forwarded]', rcptTo)
+			return Promise.resolve()
+		},
+		async reply(message) {
+			console.log('[Devflare email reply sent]', message?.from)
+			return Promise.resolve()
+		}
+	}
+
+	const __devflareEvent = createEmailEvent(emailMessage, env, ctx)
+
+	await runWithEventContext(
+		__devflareEvent,
+		() => __devflareEmailHandler(__devflareEvent, env, ctx)
+	)
+
+	return new Response(JSON.stringify({ ok: true, from, to }), {
+		headers: { 'Content-Type': 'application/json' }
+	})
+}
+` : "";
+  return `
+${importLines.join(`
+`)}
+${moduleFallbackLines.join(`
+`)}
+
+setLocalSendEmailBindings(${localSendEmailBindings})
+
+const __devflareHasFetchModule = ${surfaceImportPaths.fetch ? "true" : "false"}
+const __devflareRoutes = [
+${routeManifestEntries.join(`,
+`)}
+]
+const __devflareHasRoutes = __devflareRoutes.length > 0
+
+const __devflareResolveHandler = (module, namedExport) => {
+	const defaultExport = module.default
+
+	if (typeof defaultExport === 'function') {
+		return defaultExport
+	}
+
+	if (defaultExport && typeof defaultExport[namedExport] === 'function') {
+		return defaultExport[namedExport].bind(defaultExport)
+	}
+
+	if (typeof module[namedExport] === 'function') {
+		return module[namedExport]
+	}
+
+	return null
+}
+
+const __devflareQueueHandler = __devflareResolveHandler(__devflareQueueModule, 'queue')
+const __devflareScheduledHandler = __devflareResolveHandler(__devflareScheduledModule, 'scheduled')
+const __devflareEmailHandler = __devflareResolveHandler(__devflareEmailModule, 'email')
+${devInternalEmailHelpers}
+
+export default {
+	...(${surfaceImportPaths.fetch || routeImports.length > 0 || includeDevInternalEmail ? "true" : "false"}
+		? {
+			async fetch(request, env, ctx) {
+				${includeDevInternalEmail ? `const url = new URL(request.url)
+
+				if (
+					request.headers.get('x-devflare-event') === 'email'
+					&& url.pathname === '/_devflare/internal/email'
+				) {
+					return __devflareHandleInternalEmail(request, env, ctx)
+				}
+
+				` : ""}const __devflareInitialRouteMatch = __devflareHasRoutes ? matchFetchRoute(__devflareRoutes, request) : null
+				const __devflareEvent = createFetchEvent(request, env, ctx, {
+					params: __devflareInitialRouteMatch?.params ?? {}
+				})
+				return runWithEventContext(
+					__devflareEvent,
+					() => invokeFetchModule(
+						__devflareFetchModule,
+						__devflareEvent,
+						__devflareHasRoutes
+							? createRouteResolve(__devflareRoutes, __devflareEvent)
+							: undefined
+					)
+				)
+			}
+		}
+		: {}),
+	...(__devflareQueueHandler
+		? {
+			async queue(batch, env, ctx) {
+				const __devflareEvent = createQueueEvent(batch, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareQueueHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareScheduledHandler
+		? {
+			async scheduled(controller, env, ctx) {
+				const __devflareEvent = createScheduledEvent(controller, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareScheduledHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareEmailHandler
+		? {
+			async email(message, env, ctx) {
+				const __devflareEvent = createEmailEvent(message, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareEmailHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {})
+}
+`.trimStart();
+}
+async function prepareComposedWorkerEntrypoint(cwd, config, environment, options = {}) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  if (resolvedConfig.wrangler?.passthrough && Object.prototype.hasOwnProperty.call(resolvedConfig.wrangler.passthrough, "main")) {
+    return null;
+  }
+  const surfacePaths = await resolveWorkerSurfacePaths(cwd, resolvedConfig);
+  const routeDiscovery = await discoverRoutes(cwd, resolvedConfig);
+  if (!needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery)) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  const entryDir = resolve(cwd, ".devflare", "worker-entrypoints");
+  const entryPath = resolve(entryDir, "main.ts");
+  await fs.mkdir(entryDir, { recursive: true });
+  const surfaceImportPaths = {
+    fetch: surfacePaths.fetch ? toImportSpecifier(entryPath, surfacePaths.fetch) : null,
+    queue: surfacePaths.queue ? toImportSpecifier(entryPath, surfacePaths.queue) : null,
+    scheduled: surfacePaths.scheduled ? toImportSpecifier(entryPath, surfacePaths.scheduled) : null,
+    email: surfacePaths.email ? toImportSpecifier(entryPath, surfacePaths.email) : null
+  };
+  const routeImports = createGeneratedRouteModuleImports(entryPath, routeDiscovery);
+  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, routeImports, options));
+  return ".devflare/worker-entrypoints/main.ts";
+}
+
+export { prepareComposedWorkerEntrypoint };

package/dist/{index-hcex3rgh.js → index-wyf3s77s.js}

@@ -17,7 +17,7 @@ var filesSchema = z.object({
   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.string().optional()
+  transport: z.union([z.string(), z.null()]).optional()
 }).optional();
 var durableObjectBindingSchema = z.custom((val) => {
   if (typeof val === "string")
@@ -70,7 +70,14 @@ var analyticsBindingSchema = z.object({
   dataset: z.string()
 });
 var sendEmailBindingSchema = z.object({
-  destinationAddress: z.string().optional()
+  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 bindingsSchema = z.object({
   kv: z.record(z.string(), z.string()).optional(),
@@ -115,12 +122,43 @@ var observabilitySchema = z.object({
 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: z.record(z.string(), z.unknown()).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(),
@@ -134,7 +172,7 @@ var migrationSchema = z.object({
 var wranglerConfigSchema = z.object({
   passthrough: z.record(z.string(), z.unknown()).optional()
 }).optional();
-var envConfigSchemaInner = z.object({
+var envConfigSchema = z.object({
   name: z.string().optional(),
   compatibilityDate: compatibilityDateSchema.optional(),
   compatibilityFlags: z.array(z.string()).optional(),
@@ -148,15 +186,35 @@ var envConfigSchemaInner = z.object({
   limits: limitsSchema,
   observability: observabilitySchema,
   migrations: z.array(migrationSchema).optional(),
-  build: buildConfigSchema,
+  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 configSchema = z.object({
+var canonicalConfigSchema = z.object({
   name: z.string({
     required_error: "Worker name is required"
   }),
@@ -177,11 +235,30 @@ var configSchema = z.object({
   limits: limitsSchema,
   observability: observabilitySchema,
   migrations: z.array(migrationSchema).optional(),
-  build: buildConfigSchema,
-  plugins: z.array(z.unknown()).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 };

package/dist/index-xqfbd9fx.js

@@ -0,0 +1,195 @@
+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", "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
+	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, and doctor
+	--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
+
+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 "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-9mq7zhww.js");
+  return runDevCommand(parsed, logger, options);
+}
+async function runBuild(parsed, logger, options) {
+  const { runBuildCommand } = await import("./build-ezksv2dd.js");
+  return runBuildCommand(parsed, logger, options);
+}
+async function runDeploy(parsed, logger, options) {
+  const { runDeployCommand } = await import("./deploy-jdpy21t6.js");
+  return runDeployCommand(parsed, logger, options);
+}
+async function runTypes(parsed, logger, options) {
+  const { runTypesCommand } = await import("./types-nq5acrwh.js");
+  return runTypesCommand(parsed, logger, options);
+}
+async function runDoctor(parsed, logger, options) {
+  const { runDoctorCommand } = await import("./doctor-z4ffybce.js");
+  return runDoctorCommand(parsed, logger, options);
+}
+async function runAccount(parsed, logger, options) {
+  const { runAccountCommand } = await import("./account-8psavtg6.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 };