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

package/dist/index-xxwbb2nt.js

@@ -0,0 +1,322 @@
+import {
+  normalizeDOBinding
+} from "./index-wyf3s77s.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/bridge/miniflare.ts
+function generateGatewayScript() {
+  return `
+// Gateway Worker — Provides RPC access to all bindings
+export default {
+	async fetch(request, env, ctx) {
+		const url = new URL(request.url)
+		
+		// Health check
+		if (url.pathname === '/_devflare/health') {
+			return new Response(JSON.stringify({ status: 'ok', bindings: Object.keys(env) }), {
+				headers: { 'Content-Type': 'application/json' }
+			})
+		}
+		
+		// RPC endpoint
+		if (url.pathname === '/_devflare/rpc' && request.method === 'POST') {
+			try {
+				const { method, params } = await request.json()
+				const result = await executeRpc(env, method, params)
+				return new Response(JSON.stringify({ ok: true, result }), {
+					headers: { 'Content-Type': 'application/json' }
+				})
+			} catch (error) {
+				return new Response(JSON.stringify({
+					ok: false,
+					error: { code: 'RPC_ERROR', message: error.message }
+				}), {
+					status: 500,
+					headers: { 'Content-Type': 'application/json' }
+				})
+			}
+		}
+		
+		return new Response('Devflare Gateway', { status: 200 })
+	}
+}
+
+async function executeRpc(env, method, params) {
+	const [bindingName, ...methodPath] = method.split('.')
+	const binding = env[bindingName]
+	const RAW_EMAIL = 'EmailMessage::raw'
+	
+	if (!binding) {
+		throw new Error(\`Binding "\${bindingName}" not found\`)
+	}
+	
+	const methodName = methodPath.join('.')
+	
+	// KV operations
+	if (methodName === 'get') return binding.get(params[0], params[1])
+	if (methodName === 'put') return binding.put(params[0], params[1], params[2])
+	if (methodName === 'delete') return binding.delete(params[0])
+	if (methodName === 'list') return binding.list(params[0])
+	if (methodName === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+	
+	// R2 operations
+	if (methodName === 'head') return binding.head(params[0])
+	if (methodName === 'r2.get') return serializeR2Object(await binding.get(params[0], params[1]))
+	if (methodName === 'r2.put') return serializeR2Object(await binding.put(params[0], params[1], params[2]))
+	if (methodName === 'r2.delete') return binding.delete(params[0])
+	if (methodName === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
+	
+	// D1 operations
+	if (methodName === 'exec') return binding.exec(params[0])
+	if (methodName === 'batch') {
+		const statements = params[0].map(s => binding.prepare(s.sql).bind(...(s.bindings || [])))
+		return binding.batch(statements)
+	}
+	if (methodName.startsWith('stmt.')) {
+		const [, stmtMethod] = methodName.split('.')
+		const [sql, ...bindings] = params
+		const stmt = binding.prepare(sql).bind(...bindings.slice(0, -1))
+		
+		if (stmtMethod === 'first') return stmt.first(bindings[bindings.length - 1])
+		if (stmtMethod === 'all') return stmt.all()
+		if (stmtMethod === 'run') return stmt.run()
+		if (stmtMethod === 'raw') return stmt.raw(bindings[bindings.length - 1])
+	}
+	
+	// DO operations
+	if (methodName === 'idFromName') {
+		const id = binding.idFromName(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'idFromString') {
+		const id = binding.idFromString(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'newUniqueId') {
+		const id = binding.newUniqueId(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'stub.fetch') {
+		const [, doId, serializedReq] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request(serializedReq.url, {
+			method: serializedReq.method,
+			headers: serializedReq.headers,
+			body: serializedReq.body?.type === 'bytes' ? atob(serializedReq.body.data) : undefined
+		}))
+		return serializeResponse(response)
+	}
+	if (methodName === 'stub.rpc') {
+		// DO RPC: Call a method on the DO instance
+		const [, doId, rpcMethod, rpcParams] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		
+		// Use fetch to call the RPC endpoint
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: rpcMethod, params: rpcParams })
+		}))
+		
+		const result = await response.json()
+		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
+		return result.result
+	}
+	
+	// Queue operations
+	if (methodName === 'send') return binding.send(params[0], params[1])
+	if (methodName === 'sendBatch') return binding.sendBatch(params[0], params[1])
+
+	// Send Email operations
+	if (methodName === 'email.send') {
+		const message = params[0]
+		if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
+			return binding.send({
+				from: message.from,
+				to: message.to,
+				[RAW_EMAIL]: createEmailMessageRaw(message.raw)
+			})
+		}
+		return binding.send(message)
+	}
+	
+	// Generic fallback
+	if (typeof binding[methodName] === 'function') {
+		return binding[methodName](...params)
+	}
+	
+	throw new Error(\`Unknown method: \${method}\`)
+}
+
+function createEmailMessageRaw(raw) {
+	if (typeof raw === 'string' || raw instanceof ReadableStream) {
+		return raw
+	}
+	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
+		return new Response(raw).body
+	}
+	throw new Error('Unsupported EmailMessage raw payload')
+}
+
+function serializeResponse(response) {
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: [...response.headers.entries()],
+		body: null // Will be streamed separately for large bodies
+	}
+}
+
+function serializeR2Object(obj) {
+	if (!obj) return null
+	return {
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata
+	}
+}
+
+function serializeR2Objects(result) {
+	if (!result) return null
+	return {
+		objects: result.objects.map(serializeR2Object),
+		truncated: result.truncated,
+		cursor: result.cursor,
+		delimitedPrefixes: result.delimitedPrefixes
+	}
+}
+`;
+}
+async function startMiniflare(options = {}) {
+  const { Miniflare, Log, LogLevel } = await import("miniflare");
+  const port = options.port ?? 8787;
+  const persistPath = options.persistPath ?? ".devflare/data";
+  const mfConfig = {
+    modules: true,
+    script: generateGatewayScript(),
+    port,
+    host: "127.0.0.1",
+    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(LogLevel.WARN),
+    compatibilityDate: options.compatibilityDate ?? "2024-01-01",
+    compatibilityFlags: options.compatibilityFlags ?? []
+  };
+  const hasBindings = (val) => {
+    if (!val)
+      return false;
+    if (Array.isArray(val))
+      return val.length > 0;
+    return Object.keys(val).length > 0;
+  };
+  if (hasBindings(options.kvNamespaces)) {
+    mfConfig.kvNamespaces = options.kvNamespaces;
+    if (options.persist) {
+      mfConfig.kvPersist = `${persistPath}/kv`;
+    }
+  }
+  if (hasBindings(options.r2Buckets)) {
+    mfConfig.r2Buckets = options.r2Buckets;
+    if (options.persist) {
+      mfConfig.r2Persist = `${persistPath}/r2`;
+    }
+  }
+  if (hasBindings(options.d1Databases)) {
+    mfConfig.d1Databases = options.d1Databases;
+    if (options.persist) {
+      mfConfig.d1Persist = `${persistPath}/d1`;
+    }
+  }
+  if (options.durableObjects) {
+    mfConfig.durableObjects = options.durableObjects;
+    if (options.persist) {
+      mfConfig.durableObjectsPersist = `${persistPath}/do`;
+    }
+  }
+  if (options.sendEmail) {
+    mfConfig.email = {
+      send_email: Object.entries(options.sendEmail).map(([name, config]) => ({
+        name,
+        ...config.destinationAddress && {
+          destination_address: config.destinationAddress
+        },
+        ...config.allowedDestinationAddresses && {
+          allowed_destination_addresses: config.allowedDestinationAddresses
+        },
+        ...config.allowedSenderAddresses && {
+          allowed_sender_addresses: config.allowedSenderAddresses
+        }
+      }))
+    };
+  }
+  if (options.bindings && Object.keys(options.bindings).length > 0) {
+    mfConfig.bindings = options.bindings;
+  }
+  if (options.queues?.length) {
+    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
+  }
+  const mf = new Miniflare(mfConfig);
+  await mf.ready;
+  return {
+    ready: Promise.resolve(),
+    async dispose() {
+      await mf.dispose();
+    },
+    async getBindings() {
+      return mf.getBindings();
+    },
+    getKVNamespace: mf.getKVNamespace.bind(mf),
+    getR2Bucket: mf.getR2Bucket.bind(mf),
+    getD1Database: mf.getD1Database.bind(mf),
+    getDurableObjectNamespace: mf.getDurableObjectNamespace.bind(mf),
+    dispatchFetch: mf.dispatchFetch.bind(mf),
+    _mf: mf
+  };
+}
+async function startMiniflareFromConfig(config, options = {}) {
+  const bindings = config.bindings ?? {};
+  const mfOptions = {
+    ...options,
+    compatibilityDate: config.compatibilityDate,
+    compatibilityFlags: config.compatibilityFlags,
+    kvNamespaces: bindings.kv ? bindings.kv : undefined,
+    r2Buckets: bindings.r2 ? bindings.r2 : undefined,
+    d1Databases: bindings.d1 ? bindings.d1 : undefined,
+    queues: bindings.queues?.consumers?.map((c) => c.queue),
+    sendEmail: bindings.sendEmail ? bindings.sendEmail : undefined,
+    bindings: config.vars,
+    durableObjects: bindings.durableObjects ? Object.fromEntries(Object.entries(bindings.durableObjects).map(([bindingName, doConfig]) => {
+      const normalized = normalizeDOBinding(doConfig);
+      return [
+        bindingName,
+        {
+          className: normalized.className,
+          scriptPath: normalized.scriptName
+        }
+      ];
+    })) : undefined
+  };
+  return startMiniflare(mfOptions);
+}
+var globalMiniflare = null;
+async function getMiniflare(options) {
+  if (!globalMiniflare) {
+    globalMiniflare = await startMiniflare(options);
+  }
+  return globalMiniflare;
+}
+async function stopMiniflare() {
+  if (globalMiniflare) {
+    await globalMiniflare.dispose();
+    globalMiniflare = null;
+  }
+}
+
+export { startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare };

package/dist/index-y1d8za14.js

@@ -0,0 +1,196 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/dev-server/vite-utils.ts
+import { resolve } from "pathe";
+import { spawn } from "node:child_process";
+var VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "vite.config.mjs",
+  "vite.config.cts",
+  "vite.config.cjs"
+];
+var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+var LOCAL_VITE_URL_REGEX = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\/?/i;
+async function getNodeFs() {
+  return await import("node:fs/promises");
+}
+function safeParsePackageJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function readDependencyFlag(pkg, name) {
+  const dependencies = pkg.dependencies;
+  const devDependencies = pkg.devDependencies;
+  return Boolean(dependencies?.[name] ?? devDependencies?.[name]);
+}
+async function detectViteProject(cwd, fs) {
+  const fileSystem = fs ?? await getNodeFs();
+  let viteConfigPath = null;
+  for (const configName of VITE_CONFIG_FILES) {
+    const absolutePath = resolve(cwd, configName);
+    try {
+      await fileSystem.access(absolutePath);
+      viteConfigPath = absolutePath;
+      break;
+    } catch {
+      continue;
+    }
+  }
+  let pkg = {};
+  try {
+    const packageJson = await fileSystem.readFile(resolve(cwd, "package.json"), "utf-8");
+    pkg = safeParsePackageJson(packageJson);
+  } catch {
+    pkg = {};
+  }
+  const hasLocalViteDependency = readDependencyFlag(pkg, "vite");
+  const hasLocalCloudflareVitePluginDependency = readDependencyFlag(pkg, "@cloudflare/vite-plugin");
+  const wantsViteIntegration = Boolean(viteConfigPath || hasLocalViteDependency || hasLocalCloudflareVitePluginDependency);
+  return {
+    viteConfigPath,
+    hasLocalViteDependency,
+    hasLocalCloudflareVitePluginDependency,
+    shouldStartVite: Boolean(viteConfigPath),
+    wantsViteIntegration
+  };
+}
+function stripAnsi(value) {
+  return value.replace(ANSI_REGEX, "");
+}
+function extractViteReadyUrl(output) {
+  const cleaned = stripAnsi(output);
+  const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (const line of lines) {
+    if (!line.toLowerCase().includes("local:")) {
+      continue;
+    }
+    const match = line.match(LOCAL_VITE_URL_REGEX);
+    if (match) {
+      return match[0];
+    }
+  }
+  const fallbackMatch = cleaned.match(LOCAL_VITE_URL_REGEX);
+  return fallbackMatch?.[0] ?? null;
+}
+async function waitForViteReady(process, options = {}) {
+  const {
+    timeoutMs = 15000,
+    onStdout,
+    onStderr
+  } = options;
+  let combinedOutput = "";
+  return await new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    let timeout;
+    const settle = (resolver) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      resolver();
+    };
+    const inspectChunk = (chunk) => {
+      combinedOutput += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      const readyUrl = extractViteReadyUrl(combinedOutput);
+      if (readyUrl) {
+        settle(() => resolvePromise(readyUrl));
+      }
+    };
+    process.stdout?.on("data", (chunk) => {
+      onStdout?.(chunk);
+      inspectChunk(chunk);
+    });
+    process.stderr?.on("data", (chunk) => {
+      onStderr?.(chunk);
+      inspectChunk(chunk);
+    });
+    process.on("error", (error) => {
+      settle(() => rejectPromise(error));
+    });
+    process.on("exit", (code, signal) => {
+      settle(() => {
+        const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+        rejectPromise(new Error(`Vite exited before reporting a ready URL (${reason})`));
+      });
+    });
+    timeout = setTimeout(() => {
+      settle(() => resolvePromise(null));
+    }, timeoutMs);
+  });
+}
+async function defaultRunCommand(command, args) {
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.on("error", rejectPromise);
+    child.on("exit", () => resolvePromise());
+  });
+}
+function waitForProcessExit(process, timeoutMs) {
+  if (process.killed) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    let timeout;
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      resolvePromise(value);
+    };
+    process.on("exit", () => settle(true));
+    timeout = setTimeout(() => {
+      settle(false);
+    }, timeoutMs);
+  });
+}
+async function stopSpawnedProcessTree(process, options = {}) {
+  const {
+    platform = globalThis.process?.platform ?? "linux",
+    timeoutMs = 3000,
+    runCommand = defaultRunCommand
+  } = options;
+  if (platform === "win32" && process.pid) {
+    try {
+      await runCommand("taskkill", ["/pid", String(process.pid), "/t", "/f"]);
+    } catch {
+      try {
+        process.kill("SIGTERM");
+      } catch {
+        return;
+      }
+    }
+    await waitForProcessExit(process, timeoutMs);
+    return;
+  }
+  try {
+    process.kill("SIGTERM");
+  } catch {
+    return;
+  }
+  const exited = await waitForProcessExit(process, timeoutMs);
+  if (exited) {
+    return;
+  }
+  try {
+    process.kill("SIGKILL");
+  } catch {
+    return;
+  }
+  await waitForProcessExit(process, timeoutMs);
+}
+
+export { detectViteProject, waitForViteReady, stopSpawnedProcessTree };

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

@@ -1,6 +1,9 @@
 import {
   getDependencies
 } from "./index-1xpj0m4r.js";
+import {
+  getInitDependencyVersions
+} from "./index-6h8xbs75.js";
 import"./index-37x76zdn.js";
 
 // src/cli/commands/init.ts
@@ -14,14 +17,20 @@ var MINIMAL_TEMPLATE = {
 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({ request }: FetchEvent): Promise<Response> {
+	const url = new URL(request.url)
+	return new Response(
+		url.pathname === '/'
+			? 'Hello from Devflare'
+			: \`Hello from Devflare: \${url.pathname}\`
+	)
 }
 `,
     "package.json": `{
@@ -36,8 +45,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 +61,65 @@ 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'
 
 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
+    "src/app.ts": `import type { FetchEvent } from 'devflare/runtime'
 
+export async function appFetch({ request }: FetchEvent): Promise<Response> {
 	const url = new URL(request.url)
 
 	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"],
@@ -157,6 +142,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,7 +154,7 @@ 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}`);
   }
@@ -178,6 +164,7 @@ Project created successfully!`);
 Next steps:`);
   logger.info(`  cd ${projectName}`);
   logger.info(`  bun install`);
+  logger.info(`  bun run types`);
   logger.info(`  bun run dev`);
   return { exitCode: 0 };
 }