devflare 1.0.0-next.0 → 1.0.0-next.10

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-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 };
 }