@getjack/jack 0.1.6 → 0.1.8

package/src/lib/project-operations.ts

@@ -23,8 +23,22 @@ import {
 	runAgentOneShot,
 	validateAgentPaths,
 } from "./agents.ts";
-import { ensureR2Buckets, needsOpenNextBuild, needsViteBuild, runOpenNextBuild, runViteBuild } from "./build-helper.ts";
+import {
+	checkWranglerVersion,
+	getWranglerVersion,
+	needsOpenNextBuild,
+	needsViteBuild,
+	parseWranglerConfig,
+	runOpenNextBuild,
+	runViteBuild,
+} from "./build-helper.ts";
 import { checkWorkerExists, getAccountId, listD1Databases } from "./cloudflare-api.ts";
+import {
+	generateWranglerConfig,
+	getDefaultProjectName,
+	slugify,
+	writeWranglerConfig,
+} from "./config-generator.ts";
 import { getSyncConfig } from "./config.ts";
 import { deleteManagedProject } from "./control-plane.ts";
 import { debug, isDebug } from "./debug.ts";
@@ -40,6 +54,7 @@ import {
 } from "./managed-deploy.ts";
 import { generateProjectName } from "./names.ts";
 import { getAllPaths, registerPath, unregisterPath } from "./paths-index.ts";
+import { detectProjectType, validateProject } from "./project-detection.ts";
 import {
 	type DeployMode,
 	type TemplateMetadata as TemplateOrigin,
@@ -83,6 +98,7 @@ export interface DeployOptions {
 	includeSync?: boolean;
 	managed?: boolean; // Force managed deploy mode
 	byo?: boolean; // Force BYO deploy mode
+	dryRun?: boolean; // Stop before actual deployment
 }
 
 export interface DeployResult {
@@ -293,6 +309,213 @@ async function preflightD1Capacity(
 	}
 }
 
+// ============================================================================
+// Auto-detect Flow for Ship Command
+// ============================================================================
+
+interface AutoDetectResult {
+	projectName: string;
+	projectId: string | null; // null when dry run (no cloud project created)
+	deployMode: DeployMode;
+}
+
+/**
+ * Run the auto-detect flow when no wrangler config exists.
+ * Detects project type, prompts user for confirmation, generates config,
+ * and creates managed project on jack cloud.
+ *
+ * @param dryRun - If true, skip cloud project creation and linking
+ */
+async function runAutoDetectFlow(
+	projectPath: string,
+	reporter: OperationReporter,
+	interactive: boolean,
+	dryRun = false,
+): Promise<AutoDetectResult> {
+	// Step 1: Validate project (file count, size limits)
+	const validation = await validateProject(projectPath);
+	if (!validation.valid) {
+		track(Events.AUTO_DETECT_REJECTED, { reason: "validation_failed" });
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			validation.error || "Project validation failed",
+		);
+	}
+
+	// Step 2: Detect project type
+	const detection = detectProjectType(projectPath);
+
+	// Step 3: Handle unsupported frameworks
+	if (detection.unsupportedFramework) {
+		track(Events.AUTO_DETECT_FAILED, {
+			reason: "unsupported_framework",
+			framework: detection.unsupportedFramework,
+		});
+
+		// Use the detailed error message from detection (includes setup instructions)
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			detection.error || `${detection.unsupportedFramework} is not yet supported`,
+		);
+	}
+
+	// Step 4: Handle unknown project type
+	if (detection.type === "unknown") {
+		track(Events.AUTO_DETECT_FAILED, { reason: "unknown_type" });
+
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			"Could not detect project type\n\nSupported types:\n  - Vite (React, Vue, etc.)\n  - Hono API\n  - SvelteKit (with @sveltejs/adapter-cloudflare)\n\nTo deploy manually, create a wrangler.jsonc file.\nDocs: https://docs.getjack.org/guides/manual-setup",
+		);
+	}
+
+	// Step 5: Handle detection errors (e.g., missing adapter)
+	if (detection.error) {
+		track(Events.AUTO_DETECT_FAILED, {
+			reason: "detection_error",
+			type: detection.type,
+		});
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, detection.error);
+	}
+
+	// Step 6: Detection succeeded - show what was detected
+	const typeLabels: Record<string, string> = {
+		vite: "Vite",
+		hono: "Hono API",
+		sveltekit: "SvelteKit",
+	};
+	const typeLabel = typeLabels[detection.type] || detection.type;
+	const configInfo = detection.configFile || detection.entryPoint || "";
+	reporter.info(`Detected: ${typeLabel} project${configInfo ? ` (${configInfo})` : ""}`);
+
+	// Step 7: Fetch username for URL preview (skip for dry run)
+	let ownerUsername: string | null = null;
+	if (!dryRun) {
+		const { getCurrentUserProfile } = await import("./control-plane.ts");
+		const profile = await getCurrentUserProfile();
+		ownerUsername = profile?.username ?? null;
+	}
+
+	// Step 8: Get default project name and prompt user
+	const defaultName = getDefaultProjectName(projectPath);
+
+	if (!interactive) {
+		// Non-interactive mode - use defaults
+		const projectName = defaultName;
+		const runjackUrl = ownerUsername
+			? `https://${ownerUsername}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
+
+		reporter.info(`Project name: ${projectName}`);
+		reporter.info(`Will deploy to: ${runjackUrl}`);
+
+		// Generate and write wrangler config
+		const wranglerConfig = generateWranglerConfig(
+			detection.type,
+			projectName,
+			detection.entryPoint,
+		);
+		writeWranglerConfig(projectPath, wranglerConfig);
+		reporter.success("Created wrangler.jsonc");
+
+		// Skip cloud creation and linking for dry run
+		if (dryRun) {
+			track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+			return {
+				projectName,
+				projectId: null,
+				deployMode: "managed",
+			};
+		}
+
+		// Create managed project on jack cloud
+		const remoteResult = await createManagedProjectRemote(projectName, reporter, {
+			usePrebuilt: false,
+		});
+
+		// Link project locally (include username for correct URL display)
+		await linkProject(projectPath, remoteResult.projectId, "managed", ownerUsername ?? undefined);
+		await registerPath(remoteResult.projectId, projectPath);
+
+		track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+
+		return {
+			projectName,
+			projectId: remoteResult.projectId,
+			deployMode: "managed",
+		};
+	}
+
+	// Interactive mode - prompt for project name
+	const { input } = await import("@inquirer/prompts");
+
+	console.error("");
+	const projectName = await input({
+		message: "Project name:",
+		default: defaultName,
+	});
+
+	const slugifiedName = slugify(projectName.trim());
+	const runjackUrl = ownerUsername
+		? `https://${ownerUsername}-${slugifiedName}.runjack.xyz`
+		: `https://${slugifiedName}.runjack.xyz`;
+
+	// Confirmation prompt
+	console.error("");
+	console.error("  This will:");
+	console.error("    - Create wrangler.jsonc");
+	console.error("    - Create project on jack cloud");
+	console.error(`    - Deploy to ${runjackUrl}`);
+	console.error("");
+
+	const { promptSelect } = await import("./hooks.ts");
+	const choice = await promptSelect(["Continue", "Cancel"]);
+
+	if (choice !== 0) {
+		track(Events.AUTO_DETECT_REJECTED, { reason: "user_cancelled" });
+		throw new JackError(JackErrorCode.VALIDATION_ERROR, "Deployment cancelled", undefined, {
+			exitCode: 0,
+			reported: true,
+		});
+	}
+
+	// Generate and write wrangler config
+	const wranglerConfig = generateWranglerConfig(
+		detection.type,
+		slugifiedName,
+		detection.entryPoint,
+	);
+	writeWranglerConfig(projectPath, wranglerConfig);
+	reporter.success("Created wrangler.jsonc");
+
+	// Skip cloud creation and linking for dry run
+	if (dryRun) {
+		track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+		return {
+			projectName: slugifiedName,
+			projectId: null,
+			deployMode: "managed",
+		};
+	}
+
+	// Create managed project on jack cloud
+	const remoteResult = await createManagedProjectRemote(slugifiedName, reporter, {
+		usePrebuilt: false,
+	});
+
+	// Link project locally (include username for correct URL display)
+	await linkProject(projectPath, remoteResult.projectId, "managed", ownerUsername ?? undefined);
+	await registerPath(remoteResult.projectId, projectPath);
+
+	track(Events.AUTO_DETECT_SUCCESS, { type: detection.type });
+
+	return {
+		projectName: slugifiedName,
+		projectId: remoteResult.projectId,
+		deployMode: "managed",
+	};
+}
+
 // ============================================================================
 // Create Project Operation
 // ============================================================================
@@ -674,7 +897,7 @@ export async function createProject(
 		try {
 			const result = await runParallelSetup(targetDir, projectName, {
 				template: resolvedTemplate || "hello",
-				usePrebuilt: true,
+				usePrebuilt: templateOrigin.type === "builtin", // Only builtin templates have prebuilt bundles
 			});
 			remoteResult = result.remoteResult;
 			reporter.stop();
@@ -787,9 +1010,14 @@ export async function createProject(
 			);
 		}
 
+		// Fetch username for link storage
+		const { getCurrentUserProfile } = await import("./control-plane.ts");
+		const profile = await getCurrentUserProfile();
+		const ownerUsername = profile?.username ?? undefined;
+
 		// Link project locally and register path
 		try {
-			await linkProject(targetDir, remoteResult.projectId, "managed");
+			await linkProject(targetDir, remoteResult.projectId, "managed", ownerUsername);
 			await writeTemplateMetadata(targetDir, templateOrigin);
 			await registerPath(remoteResult.projectId, targetDir);
 		} catch (err) {
@@ -819,22 +1047,22 @@ export async function createProject(
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runOpenNextBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(targetDir)) {
-			reporter.start("Building...");
+			reporter.start("Building assets...");
 			try {
 				await runViteBuild(targetDir);
 				reporter.stop();
-				reporter.success("Built");
+				reporter.success("Built assets");
 			} catch (err) {
 				reporter.stop();
 				reporter.error("Build failed");
@@ -957,6 +1185,7 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		interactive: interactiveOption,
 		includeSecrets = false,
 		includeSync = false,
+		dryRun = false,
 	} = options;
 	const reporter = providedReporter ?? noopReporter;
 	const hasReporter = Boolean(providedReporter);
@@ -974,7 +1203,14 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		existsSync(join(projectPath, "wrangler.jsonc")) ||
 		existsSync(join(projectPath, "wrangler.json"));
 
-	if (!hasWranglerConfig) {
+	// Check for existing project link
+	const hasProjectLink = existsSync(join(projectPath, ".jack", "project.json"));
+
+	// Auto-detect flow: no wrangler config and no project link
+	let autoDetectResult: AutoDetectResult | null = null;
+	if (!hasWranglerConfig && !hasProjectLink) {
+		autoDetectResult = await runAutoDetectFlow(projectPath, reporter, interactive, dryRun);
+	} else if (!hasWranglerConfig) {
 		throw new JackError(
 			JackErrorCode.PROJECT_NOT_FOUND,
 			"No wrangler config found in current directory",
@@ -982,26 +1218,30 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		);
 	}
 
-	// Get project name from directory
-	const projectName = await getProjectNameFromDir(projectPath);
+	// Get project name from directory (or auto-detect result)
+	const projectName = autoDetectResult?.projectName ?? (await getProjectNameFromDir(projectPath));
 
 	// Read local project link for stored mode and project ID
 	const link = await readProjectLink(projectPath);
 
-	// Determine effective mode: explicit flag > stored mode > default BYO
+	// Determine effective mode: explicit flag > auto-detect > stored mode > default BYO
 	let deployMode: DeployMode;
 	if (options.managed) {
 		deployMode = "managed";
 	} else if (options.byo) {
 		deployMode = "byo";
+	} else if (autoDetectResult) {
+		deployMode = autoDetectResult.deployMode;
 	} else {
 		deployMode = link?.deploy_mode ?? "byo";
 	}
 
 	// Validate mode availability
-	const modeError = await validateModeAvailability(deployMode);
-	if (modeError) {
-		throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+	if (!dryRun) {
+		const modeError = await validateModeAvailability(deployMode);
+		if (modeError) {
+			throw new JackError(JackErrorCode.VALIDATION_ERROR, modeError);
+		}
 	}
 
 	let workerUrl: string | null = null;
@@ -1010,7 +1250,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 	// Deploy based on mode
 	if (deployMode === "managed") {
 		// Managed mode: deploy via jack cloud
-		if (!link?.project_id || link.deploy_mode !== "managed") {
+		// Use autoDetectResult.projectId if available, otherwise require existing link
+		const managedProjectId = autoDetectResult?.projectId ?? link?.project_id;
+
+		// For dry run, skip the project ID check since we didn't create a cloud project
+		if (!dryRun && (!managedProjectId || (!autoDetectResult && link?.deploy_mode !== "managed"))) {
 			throw new JackError(
 				JackErrorCode.VALIDATION_ERROR,
 				"Project not linked to jack cloud",
@@ -1018,44 +1262,93 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 			);
 		}
 
+		// Dry run: build for validation then stop before actual deployment
+		// (deployToManagedProject handles its own build, so only build here for dry-run)
+		if (dryRun) {
+			if (await needsOpenNextBuild(projectPath)) {
+				const buildSpin = reporter.spinner("Building assets...");
+				try {
+					await runOpenNextBuild(projectPath);
+					buildSpin.success("Built assets");
+				} catch (err) {
+					buildSpin.error("Build failed");
+					throw err;
+				}
+			} else if (await needsViteBuild(projectPath)) {
+				const buildSpin = reporter.spinner("Building assets...");
+				try {
+					await runViteBuild(projectPath);
+					buildSpin.success("Built assets");
+				} catch (err) {
+					buildSpin.error("Build failed");
+					throw err;
+				}
+			}
+			reporter.success("Dry run complete - config generated, build verified");
+			return {
+				workerUrl: null,
+				projectName,
+				deployMode,
+			};
+		}
+
 		// deployToManagedProject now handles both template and code deploy
-		await deployToManagedProject(link.project_id, projectPath, reporter);
+		await deployToManagedProject(managedProjectId as string, projectPath, reporter);
 
-		// Get the URL from the resolver or construct it
-		workerUrl = `https://${projectName}.runjack.xyz`;
+		// Construct URL with username if available
+		workerUrl = link?.owner_username
+			? `https://${link.owner_username}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
 	} else {
 		// BYO mode: deploy via wrangler
 
 		// Build first if needed (wrangler needs built assets)
 		if (await needsOpenNextBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runOpenNextBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
 			}
 		} else if (await needsViteBuild(projectPath)) {
-			const buildSpin = reporter.spinner("Building...");
+			const buildSpin = reporter.spinner("Building assets...");
 			try {
 				await runViteBuild(projectPath);
-				buildSpin.success("Built");
+				buildSpin.success("Built assets");
 			} catch (err) {
 				buildSpin.error("Build failed");
 				throw err;
 			}
 		}
 
-		// Ensure R2 buckets exist before deploying (omakase - auto-provision)
-		try {
-			const buckets = await ensureR2Buckets(projectPath);
-			if (buckets.length > 0) {
-				reporter.info(`R2 buckets ready: ${buckets.join(", ")}`);
+		// Dry run: stop before actual deployment
+		if (dryRun) {
+			reporter.success("Dry run complete - build verified");
+			return {
+				workerUrl: null,
+				projectName,
+				deployMode,
+			};
+		}
+
+		// Check wrangler version for auto-provisioning (KV/R2/D1 without IDs)
+		const config = await parseWranglerConfig(projectPath);
+		const needsAutoProvision =
+			config.kv_namespaces?.some((kv) => !kv.id) ||
+			config.r2_buckets?.some((r2) => r2.bucket_name?.startsWith("jack-template-")) ||
+			config.d1_databases?.some((d1) => !d1.database_id);
+
+		if (needsAutoProvision) {
+			try {
+				const wranglerVersion = await getWranglerVersion();
+				checkWranglerVersion(wranglerVersion);
+			} catch (err) {
+				if (err instanceof JackError) {
+					throw err;
+				}
 			}
-		} catch (err) {
-			// Non-fatal: let wrangler deploy fail with a clearer error if bucket is missing
-			debug("R2 preflight failed:", err);
 		}
 
 		const spin = reporter.spinner("Deploying...");
@@ -1105,16 +1398,16 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		}
 	}
 
-	if (includeSync) {
+	if (includeSync && deployMode !== "byo") {
 		const syncConfig = await getSyncConfig();
 		if (syncConfig.enabled && syncConfig.autoSync) {
-			const syncSpin = reporter.spinner("Syncing source to cloud...");
+			const syncSpin = reporter.spinner("Syncing source to jack storage...");
 			try {
 				const syncResult = await syncToCloud(projectPath);
 				if (syncResult.success) {
 					if (syncResult.filesUploaded > 0 || syncResult.filesDeleted > 0) {
 						syncSpin.success(
-							`Backed up ${syncResult.filesUploaded} files to jack-storage/${projectName}/`,
+							`Synced source to jack storage (${syncResult.filesUploaded} uploaded, ${syncResult.filesDeleted} removed)`,
 						);
 					} else {
 						syncSpin.success("Source already synced");
@@ -1134,7 +1427,11 @@ export async function deployProject(options: DeployOptions = {}): Promise<Deploy
 		if (!existingLink) {
 			// Not linked yet - create link
 			if (deployMode === "managed" && link?.project_id) {
-				await linkProject(projectPath, link.project_id, "managed");
+				// Fetch username for link storage
+				const { getCurrentUserProfile } = await import("./control-plane.ts");
+				const profile = await getCurrentUserProfile();
+				const ownerUsername = profile?.username ?? undefined;
+				await linkProject(projectPath, link.project_id, "managed", ownerUsername);
 				await registerPath(link.project_id, projectPath);
 			} else {
 				// BYO mode - generate new ID
@@ -1216,7 +1513,9 @@ export async function getProjectStatus(
 	// Determine URL based on mode
 	let workerUrl: string | null = null;
 	if (link?.deploy_mode === "managed") {
-		workerUrl = `https://${projectName}.runjack.xyz`;
+		workerUrl = link.owner_username
+			? `https://${link.owner_username}-${projectName}.runjack.xyz`
+			: `https://${projectName}.runjack.xyz`;
 	}
 
 	// Get database name on-demand

package/src/lib/project-resolver.ts

@@ -121,11 +121,15 @@ function fromManagedProject(managed: ManagedProject): ResolvedProject {
 		}
 	}
 
+	const url = managed.owner_username
+		? `https://${managed.owner_username}-${managed.slug}.runjack.xyz`
+		: `https://${managed.slug}.runjack.xyz`;
+
 	return {
 		name: managed.name,
 		slug: managed.slug,
 		status,
-		url: `https://${managed.slug}.runjack.xyz`,
+		url,
 		errorMessage: managed.status === "error" ? "deployment failed" : undefined,
 		sources: {
 			controlPlane: true,
@@ -175,6 +179,8 @@ export interface ResolveProjectOptions {
 	projectPath?: string;
 	/** Allow fallback lookup by managed project name when slug lookup fails */
 	matchByName?: boolean;
+	/** Prefer local .jack/project.json when resolving (default true) */
+	preferLocalLink?: boolean;
 }
 
 /**
@@ -221,9 +227,10 @@ export async function resolveProject(
 	let resolved: ResolvedProject | null = null;
 	const matchByName = options?.matchByName !== false;
 	const projectPath = options?.projectPath || process.cwd();
+	const preferLocalLink = options?.preferLocalLink ?? true;
 
 	// First, check if we're resolving from a local path with .jack/project.json
-	const link = await readProjectLink(projectPath);
+	const link = preferLocalLink ? await readProjectLink(projectPath) : null;
 
 	if (link) {
 		// We have a local link - start with that

package/src/lib/secrets.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { chmod, mkdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 export interface SecretEntry {
 	value: string;
@@ -14,7 +14,6 @@ export interface SecretsFile {
 	secrets: Record<string, SecretEntry>;
 }
 
-const CONFIG_DIR = join(homedir(), ".config", "jack");
 const SECRETS_PATH = join(CONFIG_DIR, "secrets.json");
 
 /**

package/src/lib/storage/file-filter.ts

@@ -25,6 +25,7 @@ export const DEFAULT_INCLUDES: string[] = [
 	"*.mjs",
 	"*.cjs",
 	"*.json",
+	"*.jsonc",
 	"*.toml",
 	"*.md",
 	"*.css",
@@ -48,6 +49,10 @@ export const DEFAULT_EXCLUDES: string[] = [
 	".DS_Store",
 	"dist/**",
 	"build/**",
+	".next/**",
+	".nuxt/**",
+	".output/**",
+	".svelte-kit/**",
 	"coverage/**",
 	".wrangler/**",
 	"*.lock",

package/src/lib/telemetry-config.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { CONFIG_DIR } from "./config.ts";
 
 /**
  * Telemetry configuration structure
@@ -12,8 +12,8 @@ export interface TelemetryConfig {
 	version: number; // config schema version (start at 1)
 }
 
-export const TELEMETRY_CONFIG_DIR = join(homedir(), ".config", "jack");
-export const TELEMETRY_CONFIG_PATH = join(TELEMETRY_CONFIG_DIR, "telemetry.json");
+export const TELEMETRY_CONFIG_DIR = CONFIG_DIR;
+export const TELEMETRY_CONFIG_PATH = join(CONFIG_DIR, "telemetry.json");
 
 /**
  * Cached telemetry config for memoization

package/src/lib/telemetry.ts

@@ -28,6 +28,10 @@ export const Events = {
 	MANAGED_DEPLOY_STARTED: "managed_deploy_started",
 	MANAGED_DEPLOY_COMPLETED: "managed_deploy_completed",
 	MANAGED_DEPLOY_FAILED: "managed_deploy_failed",
+	// Auto-detect events
+	AUTO_DETECT_SUCCESS: "auto_detect_success",
+	AUTO_DETECT_FAILED: "auto_detect_failed",
+	AUTO_DETECT_REJECTED: "auto_detect_rejected",
 } as const;
 
 type EventName = (typeof Events)[keyof typeof Events];

package/src/lib/zip-packager.ts

@@ -42,6 +42,7 @@ export interface ManifestData {
 		};
 		vars?: Record<string, string>;
 		r2?: Array<{ binding: string; bucket_name: string }>;
+		kv?: Array<{ binding: string }>;
 	};
 }
 
@@ -169,6 +170,13 @@ function extractBindingsFromConfig(config?: WranglerConfig): ManifestData["bindi
 		}));
 	}
 
+	// Extract KV namespace bindings
+	if (config.kv_namespaces && config.kv_namespaces.length > 0) {
+		bindings.kv = config.kv_namespaces.map((kv) => ({
+			binding: kv.binding,
+		}));
+	}
+
 	// Return undefined if no bindings were extracted
 	return Object.keys(bindings).length > 0 ? bindings : undefined;
 }