devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index.js

@@ -1,298 +1,63 @@
 import {
-  createBridgeTestContext,
-  createMockD1,
-  createMockEnv,
-  createMockKV,
-  createMockQueue,
-  createMockR2,
-  createMockTestContext,
-  createTestContext,
-  env,
-  getBridgeTestContext,
-  stopBridgeTestContext,
-  testEnv,
-  withTestContext
-} from "./index-ep3445yc.js";
-import {
-  findExportedFunctions,
-  generateRpcInterface,
-  shouldTransformWorker,
-  transformWorkerEntrypoint
-} from "./index-z14anrqp.js";
-import"./index-tk6ej9dj.js";
-import"./index-d8bdkx2h.js";
-import"./index-rbht7m9r.js";
+  workerName
+} from "./index-62b3gt2g.js";
 import {
-  findDurableObjectClasses,
-  findDurableObjectClassesDetailed,
-  generateWrapper,
-  transformDurableObject
-} from "./index-gz1gndna.js";
-import {
-  server_default
-} from "./index-m2q41jwa.js";
+  parseArgs,
+  runCli
+} from "./index-ptwem1nt.js";
+import"./index-627srx16.js";
+import"./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
 import {
-  BridgeClient,
-  createEnvProxy,
-  getClient,
-  getMiniflare,
-  initEnv,
-  setBindingHints,
-  startMiniflare,
-  startMiniflareFromConfig,
-  stopMiniflare
-} from "./index-pf5s73n9.js";
+  env,
+  vars
+} from "./index-qz6nbwpw.js";
 import {
-  defineConfig,
-  ref,
-  resolveRef,
-  serviceBinding
-} from "./index-07q6yxyc.js";
+  durableObject,
+  getDurableObjectOptions
+} from "./index-a855bdsx.js";
+import"./index-6sj0v0dk.js";
+import"./index-hpwa6vsw.js";
 import {
   compileConfig,
   stringifyConfig
-} from "./index-67qcae0f.js";
+} from "./index-hjjfxv02.js";
 import {
   ConfigNotFoundError,
+  ConfigResourceResolutionError,
   ConfigValidationError,
   configSchema,
-  loadConfig
-} from "./index-hcex3rgh.js";
-import"./index-tfyxa77h.js";
+  loadConfig,
+  loadResolvedConfig
+} from "./index-dfcp9hsd.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
 import {
-  durableObject,
-  getDurableObjectOptions
-} from "./index-a855bdsx.js";
+  preview
+} from "./index-c8p4njqy.js";
 import {
-  __require
-} from "./index-37x76zdn.js";
-// src/workerName.ts
-var workerName = (() => {
-  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
-    return __DEVFLARE_WORKER_NAME__;
-  }
-  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
-    return process.env.DEVFLARE_WORKER_NAME;
-  }
-  return "unknown";
-})();
-// src/cli/index.ts
-import { createConsola } from "consola";
-var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "account", "ai", "remote", "help", "version"];
-var VERSION = "0.1.0";
-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 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)
-
-Global Options:
-  -h, --help      Show help
-  -v, --version   Show version
-  --config <path> Path to config file
-  --debug         Enable debug mode
-
-Dev Command Options:
-	--port <port>   Preferred Vite dev server port (default: 5173)
-  --persist       Persist Miniflare storage data
-  --verbose       Enable verbose logging
-  --log           Log all output to .log-{datetime} file AND terminal
-  --log-temp      Log all output to .log file (overwritten) AND terminal
-
-Dev Server Features:
-  • Miniflare for ALL Cloudflare bindings (KV, D1, R2, DOs, Queues, AI)
-	• Optional Vite HMR when a local vite.config.* is present
-  • Rolldown for fast DO bundling with watch mode
-  • DO hot reload when files change (no restart needed)
-  • WebSocket bridge for seamless Node.js ↔ Miniflare communication
-
-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":
-      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-f9mgmew3.js");
-  return runInitCommand(parsed, logger, options);
-}
-async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-pa8dhm20.js");
-  return runDevCommand(parsed, logger, options);
-}
-async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-mnf6v8gd.js");
-  return runBuildCommand(parsed, logger, options);
-}
-async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-nhceck39.js");
-  return runDeployCommand(parsed, logger, options);
-}
-async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-5nyrz1sz.js");
-  return runTypesCommand(parsed, logger, options);
-}
-async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-fmgb3d28.js");
-  return runDoctorCommand(parsed, logger, options);
-}
-async function runAccount(parsed, logger, options) {
-  const { runAccountCommand } = await import("./account-rvrj687w.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);
-}
+  defineConfig,
+  ref
+} from "./index-q8f4kawk.js";
+import"./index-37x76zdn.js";
 export {
   workerName,
-  withTestContext,
-  transformWorkerEntrypoint,
-  transformDurableObject,
-  testEnv,
+  vars,
   stringifyConfig,
-  stopMiniflare,
-  stopBridgeTestContext,
-  startMiniflareFromConfig,
-  startMiniflare,
-  shouldTransformWorker,
-  setBindingHints,
-  serviceBinding,
   runCli,
-  resolveRef,
   ref,
+  preview,
   parseArgs,
+  loadResolvedConfig,
   loadConfig,
-  initEnv,
-  getMiniflare,
   getDurableObjectOptions,
-  getClient,
-  getBridgeTestContext,
-  generateWrapper,
-  generateRpcInterface,
-  server_default as gateway,
-  findExportedFunctions,
-  findDurableObjectClassesDetailed,
-  findDurableObjectClasses,
   env,
   durableObject,
   defineConfig,
   defineConfig as default,
-  createTestContext,
-  createMockTestContext,
-  createMockR2,
-  createMockQueue,
-  createMockKV,
-  createMockEnv,
-  createMockD1,
-  createEnvProxy,
-  createBridgeTestContext,
   configSchema,
   compileConfig,
   ConfigValidationError,
-  ConfigNotFoundError,
-  BridgeClient
+  ConfigResourceResolutionError,
+  ConfigNotFoundError
 };

package/dist/{init-f9mgmew3.js → init-cwpergap.js}

@@ -1,6 +1,17 @@
 import {
   getDependencies
-} from "./index-1xpj0m4r.js";
+} from "./index-z9gy8w6b.js";
+import {
+  getInitDependencyVersions
+} from "./index-627srx16.js";
+import {
+  createCliTheme,
+  cyanBold,
+  dim,
+  green,
+  logLine
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
 import"./index-37x76zdn.js";
 
 // src/cli/commands/init.ts
@@ -9,19 +20,24 @@ var MINIMAL_TEMPLATE = {
   name: "minimal",
   description: "Minimal starter with single handler",
   files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
+    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
 
 export default defineConfig({
 	name: '{{PROJECT_NAME}}',
 	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
+	files: {
+		fetch: 'src/fetch.ts'
+	}
 })
 `,
-    "src/index.ts": `import { env, ctx, event, locals } from 'devflare/runtime'
+    "src/fetch.ts": `import type { FetchEvent } from 'devflare/runtime'
 
-export default {
-	async fetch(request: Request): Promise<Response> {
-		return new Response('Hello from devflare!')
-	}
+export async function fetch({ url }: FetchEvent): Promise<Response> {
+	return new Response(
+		url.pathname === '/'
+			? 'Hello from Devflare'
+			: \`Hello from Devflare: \${url.pathname}\`
+	)
 }
 `,
     "package.json": `{
@@ -36,8 +52,10 @@ export default {
 		"types": "devflare types"
 	},
 	"devDependencies": {
-		"devflare": "^0.1.0",
-		"typescript": "^5.7.0"
+		"@cloudflare/workers-types": "{{WORKERS_TYPES_VERSION}}",
+		"devflare": "{{DEVFLARE_VERSION}}",
+		"typescript": "{{TYPESCRIPT_VERSION}}",
+		"wrangler": "{{WRANGLER_VERSION}}"
 	}
 }
 `,
@@ -50,91 +68,63 @@ export default {
 		"skipLibCheck": true,
 		"types": ["@cloudflare/workers-types"]
 	},
-	"include": ["src/**/*", "devflare.config.ts"]
+	"include": ["src/**/*", "env.d.ts", "devflare.config.ts"]
 }
 `
   }
 };
 var API_TEMPLATE = {
   name: "api",
-  description: "API starter with middleware and routing",
+  description: "API starter with request-wide middleware",
   files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
+    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
 
 export default defineConfig({
 	name: '{{PROJECT_NAME}}',
 	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-	bindings: {
-		// Add your bindings here
-		// kv: [{ binding: 'CACHE' }],
-		// d1: [{ binding: 'DB', database_name: 'my-db' }],
+	files: {
+		fetch: 'src/fetch.ts'
 	}
 })
 `,
-    "src/index.ts": `import { sequence, resolve } from 'devflare/runtime'
-import { corsMiddleware } from './middleware/cors'
-import { apiRouter } from './routes/api'
-
-const handler = sequence(
-	corsMiddleware
-)(
-	resolve(
-		apiRouter,
-		async () => new Response('Not Found', { status: 404 })
-	)
-)
+    "src/fetch.ts": `import { sequence } from 'devflare/runtime'
+import { corsHandle } from './middleware/cors'
+import { appFetch } from './app'
 
-export default {
-	async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
-		return handler()
-	}
-}
+export const handle = sequence(corsHandle, appFetch)
 `,
-    "src/middleware/cors.ts": `import type { Middleware } from 'devflare/runtime'
-import { event } from 'devflare/runtime'
+    "src/middleware/cors.ts": `import type { FetchEvent, ResolveFetch } from 'devflare/runtime'
 
-export const corsMiddleware: Middleware = async (next) => {
+export async function corsHandle(event: FetchEvent, resolve: ResolveFetch): Promise<Response> {
 	// Handle preflight
-	if (event.request?.method === 'OPTIONS') {
+	if (event.request.method === 'OPTIONS') {
 		return new Response(null, {
 			headers: {
 				'Access-Control-Allow-Origin': '*',
 				'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-				'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+				'Access-Control-Allow-Headers': 'Content-Type, Authorization'
 			}
 		})
 	}
 
-	const response = await next()
-	const newResponse = new Response(response.body, response)
-	newResponse.headers.set('Access-Control-Allow-Origin', '*')
-	return newResponse
+	const response = await resolve(event)
+	const next = new Response(response.body, response)
+	next.headers.set('Access-Control-Allow-Origin', '*')
+	return next
 }
 `,
-    "src/routes/api.ts": `import type { Handler } from 'devflare/runtime'
-import { event, env, locals } from 'devflare/runtime'
-
-export const apiRouter: Handler = async () => {
-	const request = event.request
-	if (!request) return null
-
-	const url = new URL(request.url)
+    "src/app.ts": `import type { FetchEvent } from 'devflare/runtime'
 
+export async function appFetch({ url }: FetchEvent): Promise<Response> {
 	if (url.pathname === '/api/health') {
-		return new Response(JSON.stringify({ status: 'ok' }), {
-			headers: { 'Content-Type': 'application/json' }
-		})
+		return Response.json({ status: 'ok' })
 	}
 
 	if (url.pathname.startsWith('/api/')) {
-		return new Response(JSON.stringify({ error: 'Not found' }), {
-			status: 404,
-			headers: { 'Content-Type': 'application/json' }
-		})
+		return Response.json({ error: 'Not found' }, { status: 404 })
 	}
 
-	// Not an API route, pass through
-	return null
+	return new Response('Not Found', { status: 404 })
 }
 `,
     "package.json": MINIMAL_TEMPLATE.files["package.json"],
@@ -149,7 +139,10 @@ async function runInitCommand(parsed, logger, options) {
   const projectName = parsed.args[0] || "my-devflare-app";
   const templateName = parsed.options.template || "minimal";
   const cwd = options.cwd || process.cwd();
-  logger.info(`Creating new devflare project: ${projectName}`);
+  const theme = createCliTheme(parsed.options);
+  logLine(logger);
+  logLine(logger, `${cyanBold("init", theme)} ${dim("Creating a new Devflare project", theme)}`);
+  logLine(logger, `${dim("project", theme)} ${green(projectName, theme)}`);
   const template = TEMPLATES[templateName];
   if (!template) {
     logger.error(`Unknown template: ${templateName}`);
@@ -157,6 +150,7 @@ async function runInitCommand(parsed, logger, options) {
     return { exitCode: 1 };
   }
   const projectDir = resolve(cwd, projectName);
+  const dependencyVersions = await getInitDependencyVersions();
   const { fs } = await getDependencies();
   try {
     await fs.access(projectDir);
@@ -168,17 +162,17 @@ async function runInitCommand(parsed, logger, options) {
     const fullPath = join(projectDir, filePath);
     const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
     await fs.mkdir(dir, { recursive: true }).catch(() => {});
-    const processedContent = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+    const processedContent = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName).replace(/\{\{DEVFLARE_VERSION\}\}/g, dependencyVersions.devflare).replace(/\{\{TYPESCRIPT_VERSION\}\}/g, dependencyVersions.typescript).replace(/\{\{WRANGLER_VERSION\}\}/g, dependencyVersions.wrangler).replace(/\{\{WORKERS_TYPES_VERSION\}\}/g, dependencyVersions.workersTypes);
     await fs.writeFile(fullPath, processedContent, "utf-8");
-    logger.info(`  Created: ${filePath}`);
+    logLine(logger, `  ${dim("created", theme)} ${filePath}`);
   }
-  logger.success(`
-Project created successfully!`);
-  logger.info(`
-Next steps:`);
-  logger.info(`  cd ${projectName}`);
-  logger.info(`  bun install`);
-  logger.info(`  bun run dev`);
+  logger.success("Project created successfully!");
+  logLine(logger);
+  logLine(logger, dim("next steps", theme));
+  logLine(logger, `  cd ${projectName}`);
+  logLine(logger, "  bun install");
+  logLine(logger, "  bun run types");
+  logLine(logger, "  bun run dev");
   return { exitCode: 0 };
 }
 export {

package/dist/login-r5ve73kf.js

@@ -0,0 +1,77 @@
+import {
+  getConfiguredAccountId
+} from "./index-7qd7nmdd.js";
+import {
+  account
+} from "./index-qmmqww7h.js";
+import"./index-11p28kxx.js";
+import"./index-3jme4hgw.js";
+import {
+  getDependencies
+} from "./index-z9gy8w6b.js";
+import {
+  createCliTheme,
+  dim,
+  green,
+  logLine,
+  whiteDim,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-15fpa5tx.js";
+import"./index-dfcp9hsd.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
+import"./index-37x76zdn.js";
+
+// src/cli/commands/login.ts
+async function logResolvedAccount(cwd, logger, theme) {
+  try {
+    const primaryAccount = await account.getPrimaryAccount();
+    if (primaryAccount) {
+      logLine(logger, `${dim("Primary account:", theme)} ${green(primaryAccount.name, theme)} ${whiteDim(`(${primaryAccount.id})`, theme)}`);
+      return;
+    }
+  } catch {}
+  const configuredAccountId = await getConfiguredAccountId(cwd);
+  if (!configuredAccountId) {
+    logLine(logger, dim("Run `devflare account` to inspect available accounts.", theme));
+    return;
+  }
+  const configuredAccount = await account.getAccountById(configuredAccountId);
+  if (configuredAccount) {
+    logLine(logger, `${dim("Configured account:", theme)} ${green(configuredAccount.name, theme)} ${whiteDim(`(${configuredAccount.id})`, theme)}`);
+    return;
+  }
+  logLine(logger, `${dim("Configured account ID:", theme)} ${whiteDim(configuredAccountId, theme)}`);
+  logLine(logger, dim("Run `devflare account --account <id>` to inspect the configured account.", theme));
+}
+async function runLoginCommand(parsed, logger, options) {
+  const force = parsed.options.force === true;
+  const cwd = options.cwd ?? process.cwd();
+  const theme = createCliTheme(parsed.options);
+  if (!force && await account.isAuthenticated()) {
+    logger.success("Already authenticated with Cloudflare");
+    await logResolvedAccount(cwd, logger, theme);
+    logLine(logger, dim("Use `devflare login --force` to open Wrangler login again.", theme));
+    return { exitCode: 0 };
+  }
+  logLine(logger);
+  logLine(logger, `${yellow("login", theme)} ${dim("Opening Wrangler login…", theme)}`);
+  const deps = await getDependencies();
+  const result = await deps.exec.exec("bunx", ["wrangler", "login"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.exitCode !== 0) {
+    logger.error("Wrangler login failed");
+    return { exitCode: 1 };
+  }
+  logger.success("Authenticated with Cloudflare");
+  await logResolvedAccount(cwd, logger, theme);
+  return { exitCode: 0 };
+}
+export {
+  runLoginCommand
+};