@kuckit/cli 1.0.4 → 2.0.1

package/dist/bin.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { i as generateModule, n as loadTryLoadKuckitConfig, r as addModule, t as discoverModules } from "./discover-module-B4oRIuSK.js";
+import { a as isLegacyConfig, c as loadTryLoadKuckitConfig, i as isGcpConfig, l as addModule, o as migrateLegacyConfig, s as discoverModules, u as generateModule } from "./provider-DbqTBb6C.js";
 import { program } from "commander";
 import { dirname, join } from "node:path";
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { execSync, spawn } from "child_process";
+import { spawn } from "child_process";
 import { access, constants as constants$1, mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { dirname as dirname$1, join as join$1 } from "path";
 import { homedir } from "node:os";
 import { confirm, input, select } from "@inquirer/prompts";
+import { accessSync as accessSync$1, constants as constants$2 } from "fs";
 
 //#region src/commands/doctor.ts
 const CONFIG_FILES = [
@@ -99,7 +100,7 @@ function checkModuleExports(packageName, cwd) {
 	].some((p) => existsSync(p));
 	return result;
 }
-async function loadConfig$9(configPath) {
+async function loadConfig$8(configPath) {
 	try {
 		if (configPath.endsWith(".ts")) {
 			const { createJiti } = await import("jiti");
@@ -139,7 +140,7 @@ async function doctor(options) {
 	});
 	let configModules = [];
 	if (configPath) {
-		const { success, config, error } = await loadConfig$9(configPath);
+		const { success, config, error } = await loadConfig$8(configPath);
 		if (success && config && typeof config === "object") {
 			const cfg = config;
 			if (Array.isArray(cfg.modules)) {
@@ -462,9 +463,9 @@ async function search(keyword, options) {
 
 //#endregion
 //#region src/commands/db.ts
-const KUCKIT_DIR$9 = ".kuckit";
+const KUCKIT_DIR$8 = ".kuckit";
 const TEMP_CONFIG_NAME = "drizzle.config.ts";
-async function fileExists$9(path) {
+async function fileExists$11(path) {
 	try {
 		await access(path, constants$1.F_OK);
 		return true;
@@ -472,10 +473,10 @@ async function fileExists$9(path) {
 		return false;
 	}
 }
-async function findProjectRoot$9(cwd) {
+async function findProjectRoot$11(cwd) {
 	let dir = cwd;
 	while (dir !== dirname$1(dir)) {
-		if (await fileExists$9(join$1(dir, "package.json"))) return dir;
+		if (await fileExists$11(join$1(dir, "package.json"))) return dir;
 		dir = dirname$1(dir);
 	}
 	return null;
@@ -488,7 +489,7 @@ async function getDatabaseUrl(cwd, options) {
 		join$1(cwd, "apps", "server", ".env"),
 		join$1(cwd, ".env.local")
 	];
-	for (const envPath of envPaths) if (await fileExists$9(envPath)) try {
+	for (const envPath of envPaths) if (await fileExists$11(envPath)) try {
 		const match = (await readFile(envPath, "utf-8")).match(/^DATABASE_URL=(.+)$/m);
 		if (match) return match[1].replace(/^["']|["']$/g, "");
 	} catch {}
@@ -504,10 +505,10 @@ async function discoverModuleSchemas(cwd) {
 		let moduleId = null;
 		if (moduleSpec.package) {
 			const workspacePath = join$1(cwd, "packages", moduleSpec.package.replace(/^@[^/]+\//, ""));
-			if (await fileExists$9(join$1(workspacePath, "package.json"))) packagePath = workspacePath;
+			if (await fileExists$11(join$1(workspacePath, "package.json"))) packagePath = workspacePath;
 			else {
 				const nodeModulesPath = join$1(cwd, "node_modules", moduleSpec.package);
-				if (await fileExists$9(join$1(nodeModulesPath, "package.json"))) packagePath = nodeModulesPath;
+				if (await fileExists$11(join$1(nodeModulesPath, "package.json"))) packagePath = nodeModulesPath;
 			}
 			if (packagePath) try {
 				moduleId = JSON.parse(await readFile(join$1(packagePath, "package.json"), "utf-8")).kuckit?.id || moduleSpec.package;
@@ -522,7 +523,7 @@ async function discoverModuleSchemas(cwd) {
 			join$1(packagePath, "src", "schema", "index.ts"),
 			join$1(packagePath, "src", "schema.ts")
 		];
-		for (const schemaPath of schemaLocations) if (await fileExists$9(schemaPath)) {
+		for (const schemaPath of schemaLocations) if (await fileExists$11(schemaPath)) {
 			schemas.push({
 				moduleId: moduleId || "unknown",
 				schemaPath
@@ -531,14 +532,14 @@ async function discoverModuleSchemas(cwd) {
 		}
 	}
 	const centralSchemaPath = join$1(cwd, "packages", "db", "src", "schema");
-	if (await fileExists$9(centralSchemaPath)) schemas.push({
+	if (await fileExists$11(centralSchemaPath)) schemas.push({
 		moduleId: "core",
 		schemaPath: centralSchemaPath
 	});
 	return schemas;
 }
 async function generateTempDrizzleConfig(cwd, databaseUrl, schemas) {
-	const kuckitDir = join$1(cwd, KUCKIT_DIR$9);
+	const kuckitDir = join$1(cwd, KUCKIT_DIR$8);
 	await mkdir(kuckitDir, { recursive: true });
 	const configPath = join$1(kuckitDir, TEMP_CONFIG_NAME);
 	const schemaPaths = schemas.map((s) => s.schemaPath);
@@ -590,7 +591,7 @@ function runDrizzleKit(command, configPath, cwd) {
 	});
 }
 async function runDbCommand(command, options) {
-	const projectRoot = await findProjectRoot$9(process.cwd());
+	const projectRoot = await findProjectRoot$11(process.cwd());
 	if (!projectRoot) {
 		console.error("Error: Could not find project root (no package.json found)");
 		process.exit(1);
@@ -638,7 +639,7 @@ async function dbStudio(options) {
 const DEFAULT_SERVER_URL = "https://dev-app-nyh7i73bea-uc.a.run.app/";
 const CONFIG_DIR = join(homedir(), ".kuckit");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
-function loadConfig$8() {
+function loadConfig$7() {
 	try {
 		if (!existsSync(CONFIG_PATH)) return null;
 		const content = readFileSync(CONFIG_PATH, "utf-8");
@@ -647,7 +648,7 @@ function loadConfig$8() {
 		return null;
 	}
 }
-function saveConfig$2(config) {
+function saveConfig(config) {
 	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, {
 		recursive: true,
 		mode: 448
@@ -691,7 +692,7 @@ function formatExpiryDate(expiresAt) {
 	});
 }
 async function authLogin(options) {
-	const config = loadConfig$8();
+	const config = loadConfig$7();
 	const serverUrl = getServerUrl(config, options.server);
 	const scopes = options.scopes?.split(",").map((s) => s.trim()) ?? ["cli"];
 	console.log("\nAuthenticating with Kuckit...\n");
@@ -756,7 +757,7 @@ async function authLogin(options) {
 						process.exit(1);
 					}
 					const expiresAt = new Date(Date.now() + pollResult.expiresIn * 1e3).toISOString();
-					saveConfig$2({
+					saveConfig({
 						...config,
 						cliToken: pollResult.token,
 						tokenExpiresAt: expiresAt,
@@ -789,7 +790,7 @@ async function authLogin(options) {
 	process.exit(1);
 }
 async function authWhoami(options) {
-	const config = loadConfig$8();
+	const config = loadConfig$7();
 	if (!config?.cliToken) {
 		if (options.json) console.log(JSON.stringify({ authenticated: false }));
 		else console.log("Not logged in. Run 'kuckit auth login' to authenticate.");
@@ -822,7 +823,7 @@ async function authWhoami(options) {
 	}
 }
 async function authLogout() {
-	if (!loadConfig$8()?.cliToken) {
+	if (!loadConfig$7()?.cliToken) {
 		console.log("Already logged out.");
 		return;
 	}
@@ -849,7 +850,7 @@ function registerAuthCommands(program$1) {
 * Exits the process with an error message if not authenticated.
 */
 function requireAuth() {
-	const config = loadConfig$8();
+	const config = loadConfig$7();
 	if (!config?.cliToken) {
 		console.error("\nError: Not logged in. Run 'kuckit auth login' first.\n");
 		process.exit(1);
@@ -861,293 +862,1008 @@ function requireAuth() {
 }
 
 //#endregion
-//#region src/commands/infra/runner.ts
+//#region src/lib/package-manager.ts
 /**
-* Run a Pulumi CLI command
+* Detect the package manager used in a project
+*
+* @param cwd - Directory to check for lock files
+* @returns The detected package manager, defaults to 'npm' if none found
 */
-function runPulumi(args, options) {
-	return new Promise((resolve) => {
-		const proc = spawn("pulumi", args, {
-			cwd: options.cwd,
-			stdio: options.stream ? [
-				"inherit",
-				"pipe",
-				"pipe"
-			] : [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			shell: true,
-			env: {
-				...process.env,
-				...options.env,
-				PULUMI_SKIP_UPDATE_CHECK: "true"
-			}
-		});
-		let stdout = "";
-		let stderr = "";
-		proc.stdout?.on("data", (data) => {
-			const str = data.toString();
-			stdout += str;
-			if (options.stream) process.stdout.write(data);
-		});
-		proc.stderr?.on("data", (data) => {
-			const str = data.toString();
-			stderr += str;
-			if (options.stream) process.stderr.write(data);
-		});
-		proc.on("close", (code) => {
-			resolve({
-				code: code ?? 1,
-				stdout,
-				stderr
-			});
-		});
-	});
+function detectPackageManager(cwd) {
+	for (const [file, pm] of Object.entries({
+		"bun.lock": "bun",
+		"bun.lockb": "bun",
+		"package-lock.json": "npm",
+		"yarn.lock": "yarn",
+		"pnpm-lock.yaml": "pnpm"
+	})) try {
+		accessSync$1(join$1(cwd, file), constants$2.F_OK);
+		return pm;
+	} catch {}
+	return "npm";
 }
 /**
-* Run pulumi stack output --json and parse the result
+* Get the install command for a package manager
+*
+* @param pm - Package manager
+* @param packageName - Package to install
+* @param options - Install options
+* @returns The full install command
 */
-async function getPulumiOutputs(options) {
-	const result = await runPulumi([
-		"stack",
-		"output",
-		"--json"
-	], options);
-	if (result.code !== 0) return null;
-	try {
-		return JSON.parse(result.stdout);
-	} catch {
-		return null;
+function getInstallCommand(pm, packageName, options = {}) {
+	const devFlag = options.dev ? " -D" : "";
+	switch (pm) {
+		case "bun": return `bun add${devFlag} ${packageName}`;
+		case "yarn": return `yarn add${options.dev ? " --dev" : ""} ${packageName}`;
+		case "pnpm": return `pnpm add${devFlag} ${packageName}`;
+		case "npm":
+		default: return `npm install${options.dev ? " --save-dev" : ""} ${packageName}`;
 	}
 }
+
+//#endregion
+//#region src/commands/infra/provider-loader.ts
+const KUCKIT_DIR$7 = ".kuckit";
+const CONFIG_FILE$7 = "infra.json";
 /**
-* Run pulumi stack --json and parse the result
+* Default provider packages by provider ID
 */
-async function getPulumiStackInfo(options) {
-	const result = await runPulumi(["stack", "--json"], options);
-	if (result.code !== 0) return null;
-	try {
-		const data = JSON.parse(result.stdout);
-		return {
-			name: data.name ?? "",
-			current: data.current ?? false,
-			updateInProgress: data.updateInProgress ?? false,
-			resourceCount: data.resourceCount ?? 0,
-			lastUpdate: data.lastUpdate,
-			url: data.url
-		};
-	} catch {
-		return null;
-	}
-}
+const DEFAULT_PROVIDER_PACKAGES = {
+	gcp: "@kuckit/infra-gcp",
+	aws: "@kuckit/infra-aws",
+	azure: "@kuckit/infra-azure"
+};
 /**
-* Run pulumi stack history --json and parse the result
+* Load the stored infrastructure config from .kuckit/infra.json
 */
-async function getPulumiStackHistory(options, limit = 5) {
-	const result = await runPulumi([
-		"stack",
-		"history",
-		"--json",
-		"--show-secrets=false"
-	], options);
-	if (result.code !== 0) return [];
+async function loadStoredConfig(projectRoot) {
+	const configPath = join$1(projectRoot, KUCKIT_DIR$7, CONFIG_FILE$7);
 	try {
-		const data = JSON.parse(result.stdout);
-		if (!Array.isArray(data)) return [];
-		return data.slice(0, limit).map((entry) => ({
-			version: entry.version ?? 0,
-			startTime: entry.startTime ?? "",
-			endTime: entry.endTime ?? "",
-			result: entry.result ?? "failed",
-			resourceChanges: entry.resourceChanges
-		}));
+		await access(configPath, constants$1.F_OK);
+		const content = await readFile(configPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (isLegacyConfig(parsed)) return migrateLegacyConfig(parsed);
+		return parsed;
 	} catch {
-		return [];
+		return null;
 	}
 }
 /**
-* Select or create a Pulumi stack
-*/
-async function selectOrCreateStack(stackName, options) {
-	if ((await runPulumi([
-		"stack",
-		"select",
-		stackName
-	], options)).code === 0) return true;
-	return (await runPulumi([
-		"stack",
-		"init",
-		stackName
-	], options)).code === 0;
-}
-/**
-* Set a Pulumi config value
-*/
-async function setPulumiConfig(key, value, options) {
-	return (await runPulumi([
-		"config",
-		"set",
-		key,
-		value
-	], options)).code === 0;
-}
-/**
-* Run pulumi up with optional preview mode
-*/
-async function pulumiUp(options) {
-	return runPulumi(options.preview ? ["preview"] : ["up", "--yes"], {
-		...options,
-		stream: true
-	});
-}
-/**
-* Run pulumi destroy
-*/
-async function pulumiDestroy(options) {
-	return runPulumi(options.force ? [
-		"destroy",
-		"--yes",
-		"-f"
-	] : ["destroy", "--yes"], {
-		...options,
-		stream: true
-	});
-}
-/**
-* Run pulumi cancel to cancel stuck operations
-*/
-async function pulumiCancel(options) {
-	return runPulumi(["cancel", "--yes"], options);
-}
-/**
-* Run pulumi refresh to sync state with cloud provider
+* Save infrastructure config to .kuckit/infra.json
 */
-async function pulumiRefresh(options) {
-	return runPulumi(["refresh", "--yes"], {
-		...options,
-		stream: true
-	});
+async function saveStoredConfig(projectRoot, config) {
+	const { mkdir: mkdir$1, writeFile: writeFile$1 } = await import("fs/promises");
+	const kuckitDir = join$1(projectRoot, KUCKIT_DIR$7);
+	await mkdir$1(kuckitDir, { recursive: true });
+	const configPath = join$1(kuckitDir, CONFIG_FILE$7);
+	config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeFile$1(configPath, JSON.stringify(config, null, 2), "utf-8");
 }
 /**
-* Export Pulumi stack state to a file
+* Error thrown when provider package is not installed
 */
-async function pulumiStackExport(filePath, options) {
-	return runPulumi([
-		"stack",
-		"export",
-		"--file",
-		filePath
-	], options);
-}
+var ProviderNotInstalledError = class extends Error {
+	constructor(packageName, installCommand) {
+		super(`Provider package '${packageName}' is not installed.`);
+		this.packageName = packageName;
+		this.installCommand = installCommand;
+		this.name = "ProviderNotInstalledError";
+	}
+};
 /**
-* Run a gcloud CLI command
+* Error thrown when provider package is invalid
 */
-function runGcloud(args, options = {}) {
-	return new Promise((resolve) => {
-		const proc = spawn("gcloud", args, {
-			cwd: options.cwd ?? process.cwd(),
-			stdio: options.stream ? [
-				"inherit",
-				"pipe",
-				"pipe"
-			] : [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			shell: true
-		});
-		let stdout = "";
-		let stderr = "";
-		proc.stdout?.on("data", (data) => {
-			const str = data.toString();
-			stdout += str;
-			if (options.stream) process.stdout.write(data);
-		});
-		proc.stderr?.on("data", (data) => {
-			const str = data.toString();
-			stderr += str;
-			if (options.stream) process.stderr.write(data);
-		});
-		proc.on("close", (code) => {
-			resolve({
-				code: code ?? 1,
-				stdout,
-				stderr
-			});
-		});
-	});
-}
+var InvalidProviderError = class extends Error {
+	constructor(packageName, reason) {
+		super(`Package '${packageName}' is not a valid Kuckit infrastructure provider: ${reason}`);
+		this.packageName = packageName;
+		this.name = "InvalidProviderError";
+	}
+};
 /**
-* Build and push Docker image using Cloud Build
-* No local Docker daemon required!
+* Load a provider from an npm package
+*
+* @param packageName - npm package name (e.g., '@kuckit/infra-gcp')
+* @param projectRoot - Optional project root for package manager detection
+* @returns The provider instance
+* @throws ProviderNotInstalledError if package not found
+* @throws InvalidProviderError if package doesn't export a valid provider
 */
-async function buildAndPushImage(options) {
-	const tag = options.tag ?? process.env.GIT_SHA ?? "latest";
-	const imageUrl = `${options.registryUrl}/kuckit:${tag}`;
-	console.log(`Building image: ${imageUrl}`);
-	const args = [
-		"builds",
-		"submit",
-		"--tag",
-		imageUrl,
-		"--project",
-		options.project
-	];
-	if (options.dockerfile && options.dockerfile !== "Dockerfile") args.push("--config", options.dockerfile);
-	return {
-		code: (await runGcloud(args, {
-			stream: true,
-			cwd: options.cwd
-		})).code,
-		imageUrl
-	};
+async function loadProviderFromPackage(packageName, projectRoot) {
+	try {
+		const module = await import(packageName);
+		if (!module.provider) throw new InvalidProviderError(packageName, "does not export a 'provider' object");
+		const provider = module.provider;
+		if (!provider.id || !provider.label || !provider.getInfraDir || !provider.init || !provider.deploy) throw new InvalidProviderError(packageName, "missing required methods (id, label, getInfraDir, init, deploy)");
+		return provider;
+	} catch (error) {
+		if (error instanceof ProviderNotInstalledError || error instanceof InvalidProviderError) throw error;
+		if (error instanceof Error && (error.message.includes("Cannot find module") || error.message.includes("Cannot find package"))) throw new ProviderNotInstalledError(packageName, getInstallCommand(detectPackageManager(projectRoot ?? process.cwd()), packageName, { dev: true }));
+		throw error;
+	}
 }
 /**
-* Get the path to the packages/infra directory
+* Get the provider package name for a given provider ID
 */
-function getInfraDir(projectRoot) {
-	return join$1(projectRoot, "packages", "infra");
+function getProviderPackage(providerId) {
+	return DEFAULT_PROVIDER_PACKAGES[providerId] ?? `@kuckit/infra-${providerId}`;
 }
 /**
-* Check if Pulumi CLI is installed
+* Check if a provider package is available
 */
-async function checkPulumiInstalled() {
+async function isProviderAvailable(providerId) {
+	const packageName = getProviderPackage(providerId);
 	try {
-		return (await runPulumi(["version"], { cwd: process.cwd() })).code === 0;
+		await import(packageName);
+		return true;
 	} catch {
 		return false;
 	}
 }
 /**
-* Check if gcloud CLI is installed
+* List available provider packages
 */
-async function checkGcloudInstalled() {
+async function listAvailableProviders() {
+	return await Promise.all(Object.entries(DEFAULT_PROVIDER_PACKAGES).map(async ([id, pkg]) => ({
+		id,
+		package: pkg,
+		available: await isProviderAvailable(id)
+	})));
+}
+
+//#endregion
+//#region src/commands/infra/init.ts
+async function fileExists$10(path) {
 	try {
-		return (await runGcloud(["version"])).code === 0;
+		await access(path, constants$1.F_OK);
+		return true;
 	} catch {
 		return false;
 	}
 }
+async function findProjectRoot$10(cwd) {
+	let dir = cwd;
+	while (dir !== dirname$1(dir)) {
+		if (await fileExists$10(join$1(dir, "package.json"))) return dir;
+		dir = dirname$1(dir);
+	}
+	return null;
+}
 /**
-* List Cloud Run service revisions
+* Check if legacy packages/infra directory exists
 */
-async function listCloudRunRevisions(serviceName, project, region) {
-	const revisionsResult = await runGcloud([
-		"run",
-		"revisions",
-		"list",
-		"--service",
-		serviceName,
-		"--project",
-		project,
-		"--region",
-		region,
-		"--format",
-		"json"
-	]);
+async function hasLegacyInfra(projectRoot) {
+	return fileExists$10(join$1(projectRoot, "packages", "infra", "package.json"));
+}
+async function infraInit(options) {
+	console.log("Initializing kuckit infrastructure...\n");
+	const projectRoot = await findProjectRoot$10(process.cwd());
+	if (!projectRoot) {
+		console.error("Error: Could not find project root (no package.json found)");
+		process.exit(1);
+	}
+	if (await hasLegacyInfra(projectRoot)) {
+		console.log("⚠️  Legacy infrastructure detected: packages/infra");
+		console.log("");
+		console.log("Kuckit now uses provider packages (@kuckit/infra-gcp) instead of");
+		console.log("local Pulumi code. Your existing Pulumi state will be preserved.");
+		console.log("");
+		console.log("After migration, you can remove packages/infra.");
+		console.log("See docs/MIGRATION.md for details.");
+		console.log("");
+	}
+	const existingConfig = await loadStoredConfig(projectRoot);
+	let providerId = options.provider ?? existingConfig?.provider ?? "gcp";
+	if (!options.provider && !existingConfig) {
+		const installedProviders = (await listAvailableProviders()).filter((p) => p.available);
+		if (installedProviders.length === 0) {
+			const installCmd = getInstallCommand(detectPackageManager(projectRoot), "@kuckit/infra-gcp", { dev: true });
+			console.error("Error: No infrastructure providers installed.");
+			console.error("");
+			console.error("Kuckit requires a cloud provider package to deploy infrastructure.");
+			console.error("Install a provider to get started:");
+			console.error("");
+			console.error(`  ${installCmd}`);
+			console.error("");
+			console.error("Available providers:");
+			console.error("  @kuckit/infra-gcp   - Google Cloud Platform (Cloud Run, Cloud SQL, Redis)");
+			console.error("  @kuckit/infra-aws   - Amazon Web Services (coming soon)");
+			console.error("  @kuckit/infra-azure - Microsoft Azure (coming soon)");
+			process.exit(1);
+		}
+		providerId = installedProviders[0].id;
+	}
+	const providerPackage = getProviderPackage(providerId);
+	let provider;
+	try {
+		provider = await loadProviderFromPackage(providerPackage, projectRoot);
+	} catch (error) {
+		if (error instanceof ProviderNotInstalledError) {
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("Install the provider package:");
+			console.error(`  ${error.installCommand}`);
+			process.exit(1);
+		}
+		if (error instanceof InvalidProviderError) {
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("This may be a corrupted or incompatible package version.");
+			console.error("Try reinstalling the provider package.");
+			process.exit(1);
+		}
+		console.error(`Error: ${error instanceof Error ? error.message : "Failed to load provider"}`);
+		process.exit(1);
+	}
+	console.log("Checking prerequisites...");
+	const prereqResult = await provider.checkPrerequisites();
+	if (!prereqResult.ok) {
+		console.error("\nError: Missing required tools:");
+		for (const missing of prereqResult.missing) {
+			console.error(`  - ${missing.name}`);
+			console.error(`    Install from: ${missing.installUrl}`);
+		}
+		process.exit(1);
+	}
+	if (provider.validateProject) {
+		const validation = await provider.validateProject(projectRoot);
+		if (!validation.valid) {
+			console.error("\nError: Project validation failed:");
+			for (const issue of validation.issues.filter((i) => i.severity === "error")) console.error(`  - ${issue.message}`);
+			process.exit(1);
+		}
+		for (const issue of validation.issues.filter((i) => i.severity === "warning")) console.warn(`Warning: ${issue.message}`);
+	}
+	const prompts = await provider.getInitPrompts(existingConfig ?? void 0);
+	const responses = {};
+	if (options.project && providerId === "gcp") responses.gcpProject = options.project;
+	for (const prompt of prompts) {
+		if (responses[prompt.name] !== void 0) continue;
+		if (prompt.type === "input") responses[prompt.name] = await input({
+			message: prompt.message,
+			default: prompt.default,
+			validate: prompt.validate
+		});
+		else if (prompt.type === "select" && prompt.choices) responses[prompt.name] = await select({
+			message: prompt.message,
+			choices: prompt.choices.map((c) => ({
+				value: c.value,
+				name: c.label
+			})),
+			default: prompt.default
+		});
+		else if (prompt.type === "confirm") responses[prompt.name] = await confirm({
+			message: prompt.message,
+			default: prompt.default
+		});
+	}
+	let region = options.region ?? existingConfig?.region ?? "us-central1";
+	if (!options.region && !existingConfig?.region) region = await input({
+		message: "Deployment region:",
+		default: "us-central1"
+	});
+	let env = options.env ?? existingConfig?.env ?? "dev";
+	if (!options.env && !existingConfig?.env) env = await select({
+		message: "Environment:",
+		choices: [
+			{
+				value: "dev",
+				name: "Development"
+			},
+			{
+				value: "staging",
+				name: "Staging"
+			},
+			{
+				value: "prod",
+				name: "Production"
+			}
+		],
+		default: "dev"
+	});
+	const packageJsonPath = join$1(projectRoot, "package.json");
+	let projectName = "kuckit-app";
+	try {
+		const { readFile: readFile$1 } = await import("fs/promises");
+		projectName = JSON.parse(await readFile$1(packageJsonPath, "utf-8")).name?.replace(/^@[^/]+\//, "") ?? "kuckit-app";
+	} catch {
+		projectName = projectRoot.split("/").pop() ?? "kuckit-app";
+	}
+	const stackName = `${responses.gcpProject ?? ""}-${env}`;
+	console.log("\nConfiguration:");
+	console.log(`  Provider: ${provider.label}`);
+	for (const [key, value] of Object.entries(responses)) console.log(`  ${key}: ${value}`);
+	console.log(`  Region: ${region}`);
+	console.log(`  Environment: ${env}`);
+	console.log(`  Stack: ${stackName}`);
+	console.log("");
+	if (!options.yes) {
+		if (!await confirm({
+			message: "Proceed with infrastructure initialization?",
+			default: true
+		})) {
+			console.log("Aborted.");
+			process.exit(0);
+		}
+	}
+	const dockerfilePath = join$1(projectRoot, "Dockerfile");
+	if (provider.generateDockerfile && !await fileExists$10(dockerfilePath)) {
+		console.log("\nGenerating Dockerfile...");
+		const dockerfileContent = await provider.generateDockerfile(projectRoot);
+		if (dockerfileContent) {
+			const { writeFile: writeFile$1 } = await import("fs/promises");
+			await writeFile$1(dockerfilePath, dockerfileContent, "utf-8");
+			console.log("Dockerfile created.");
+		}
+	}
+	console.log("\nInitializing infrastructure...");
+	console.log("This may take several minutes.\n");
+	const result = await provider.init({
+		env,
+		region,
+		projectRoot,
+		yes: options.yes,
+		providerOptions: responses
+	});
+	if (!result.success) {
+		console.error(`\nError: ${result.message}`);
+		if (result.error) console.error(`  ${result.error.code}: ${result.error.message}`);
+		process.exit(1);
+	}
+	const baseConfig = {
+		env,
+		region,
+		projectName,
+		stackName
+	};
+	await saveStoredConfig(projectRoot, {
+		...provider.buildConfig(responses, baseConfig),
+		providerPackage,
+		outputs: result.outputs,
+		createdAt: existingConfig?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	console.log("\nConfiguration saved to .kuckit/infra.json");
+	console.log("\n" + "=".repeat(60));
+	console.log("Infrastructure initialized successfully!");
+	console.log("=".repeat(60));
+	if (result.outputs) {
+		console.log("\nOutputs:");
+		const outputs = result.outputs;
+		if (outputs.registryUrl) console.log(`  Registry: ${outputs.registryUrl}`);
+		if (outputs.databaseConnectionName) console.log(`  Database: ${outputs.databaseConnectionName}`);
+		if (outputs.redisHost) console.log(`  Redis: ${outputs.redisHost}`);
+	}
+	console.log("\nNext steps:");
+	console.log("  1. Ensure you have a Dockerfile in your project root");
+	console.log(`  2. Run: kuckit infra deploy --env ${env}`);
+	console.log("");
+}
+
+//#endregion
+//#region src/commands/infra/deploy.ts
+async function fileExists$9(path) {
+	try {
+		await access(path, constants$1.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot$9(cwd) {
+	let dir = cwd;
+	while (dir !== dirname$1(dir)) {
+		if (await fileExists$9(join$1(dir, "package.json"))) return dir;
+		dir = dirname$1(dir);
+	}
+	return null;
+}
+async function infraDeploy(options) {
+	console.log("Deploying kuckit application...\n");
+	const projectRoot = await findProjectRoot$9(process.cwd());
+	if (!projectRoot) {
+		console.error("Error: Could not find project root (no package.json found)");
+		process.exit(1);
+	}
+	const config = await loadStoredConfig(projectRoot);
+	if (!config) {
+		console.error("Error: No infrastructure configuration found.");
+		console.error("Run: kuckit infra init");
+		process.exit(1);
+	}
+	const env = options.env ?? config.env;
+	if (env !== "dev" && env !== "staging" && env !== "prod") {
+		console.error(`Error: Invalid environment '${env}'. Must be 'dev', 'staging', or 'prod'.`);
+		process.exit(1);
+	}
+	const providerPackage = config.providerPackage ?? getProviderPackage(config.provider);
+	let provider;
+	try {
+		provider = await loadProviderFromPackage(providerPackage, projectRoot);
+	} catch (error) {
+		if (error instanceof ProviderNotInstalledError) {
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("Install the provider package:");
+			console.error(`  ${error.installCommand}`);
+			process.exit(1);
+		}
+		if (error instanceof InvalidProviderError) {
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("This may be a corrupted or incompatible package version.");
+			console.error("Try reinstalling the provider package.");
+			process.exit(1);
+		}
+		console.error(`Error: ${error instanceof Error ? error.message : "Failed to load provider"}`);
+		process.exit(1);
+	}
+	const prereqResult = await provider.checkPrerequisites();
+	if (!prereqResult.ok) {
+		console.error("\nError: Missing required tools:");
+		for (const missing of prereqResult.missing) {
+			console.error(`  - ${missing.name}`);
+			console.error(`    Install from: ${missing.installUrl}`);
+		}
+		process.exit(1);
+	}
+	const dockerfilePath = join$1(projectRoot, "Dockerfile");
+	if (!options.skipBuild && !options.image && !await fileExists$9(dockerfilePath)) if (provider.generateDockerfile) {
+		console.log("Generating Dockerfile...");
+		const dockerfileContent = await provider.generateDockerfile(projectRoot);
+		if (dockerfileContent) {
+			const { writeFile: writeFile$1 } = await import("fs/promises");
+			await writeFile$1(dockerfilePath, dockerfileContent, "utf-8");
+			console.log("Dockerfile created.\n");
+		} else {
+			console.error("Error: Dockerfile not found in project root.");
+			console.error("Create a Dockerfile or use --skip-build with an existing image.");
+			process.exit(1);
+		}
+	} else {
+		console.error("Error: Dockerfile not found in project root.");
+		console.error("Create a Dockerfile or use --skip-build with an existing image.");
+		process.exit(1);
+	}
+	if (!config.outputs?.registryUrl) {
+		console.error("Error: No registry URL found in configuration.");
+		console.error("Run: kuckit infra init");
+		process.exit(1);
+	}
+	let projectDisplay = config.projectName;
+	if (isGcpConfig(config)) projectDisplay = config.providerConfig.gcpProject;
+	console.log("Configuration:");
+	console.log(`  Provider: ${provider.label}`);
+	console.log(`  Project: ${projectDisplay}`);
+	console.log(`  Region: ${config.region}`);
+	console.log(`  Environment: ${env}`);
+	console.log(`  Registry: ${config.outputs.registryUrl}`);
+	if (options.preview) console.log("  Mode: Preview (no changes will be applied)");
+	console.log("");
+	if (!options.yes && !options.preview) {
+		if (!await confirm({
+			message: "Proceed with deployment?",
+			default: true
+		})) {
+			console.log("Aborted.");
+			process.exit(0);
+		}
+	}
+	const result = await provider.deploy({
+		env,
+		projectRoot,
+		preview: options.preview,
+		skipBuild: options.skipBuild,
+		image: options.image,
+		yes: options.yes
+	}, config);
+	if (!result.success) {
+		console.error(`\nError: ${result.message}`);
+		if (result.error) console.error(`  ${result.error.code}: ${result.error.message}`);
+		process.exit(1);
+	}
+	if (!options.preview && result.outputs) await saveStoredConfig(projectRoot, {
+		...config,
+		outputs: result.outputs,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	if (!options.preview) {
+		console.log("\n" + "=".repeat(60));
+		console.log("Deployment successful!");
+		console.log("=".repeat(60));
+		if (result.outputs) {
+			const outputs = result.outputs;
+			if (outputs.serviceUrl) console.log(`\nService URL: ${outputs.serviceUrl}`);
+			if (outputs.migrationJobName) console.log(`Migration Job: ${outputs.migrationJobName}`);
+			if (outputs.customDomain) {
+				console.log(`\nCustom Domain: ${outputs.customDomain}`);
+				console.log(`Status: ${outputs.customDomainStatus ?? "UNKNOWN"}`);
+				const records = outputs.customDomainRecords;
+				if (records && records.length > 0) {
+					console.log("\nRequired DNS Records:");
+					for (const record of records) console.log(`  ${record.type} ${record.name} → ${record.rrdata}`);
+					console.log("\nNote: If using Cloudflare:");
+					console.log("  1. Set DNS records to DNS-only (gray cloud) until status is READY");
+					console.log("  2. Certificate provisioning can take 15-60 minutes");
+					console.log("  3. Once READY, you can enable Cloudflare proxy (orange cloud)");
+					console.log("  4. Ensure Cloudflare SSL mode is set to \"Full (strict)\"");
+				}
+			}
+		}
+		console.log("\nUseful commands:");
+		console.log(`  View logs: kuckit infra logs --env ${env}`);
+		console.log(`  Check status: kuckit infra status --env ${env}`);
+		console.log(`  Run migrations: kuckit infra db:migrate --env ${env}`);
+		console.log("");
+	} else {
+		console.log("\nPreview complete. No changes were applied.");
+		console.log("Run without --preview to apply changes.");
+	}
+}
+
+//#endregion
+//#region src/commands/infra/up.ts
+async function fileExists$8(path) {
+	try {
+		await access(path, constants$1.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot$8(cwd) {
+	let dir = cwd;
+	while (dir !== dirname$1(dir)) {
+		if (await fileExists$8(join$1(dir, "package.json"))) return dir;
+		dir = dirname$1(dir);
+	}
+	return null;
+}
+async function infraUp(options) {
+	console.log("🚀 Kuckit Infrastructure Up\n");
+	const projectRoot = await findProjectRoot$8(process.cwd());
+	if (!projectRoot) {
+		console.error("Error: Could not find project root (no package.json found)");
+		process.exit(1);
+	}
+	const existingConfig = await loadStoredConfig(projectRoot);
+	if (!existingConfig) {
+		const providerPackage = getProviderPackage(options.provider ?? "gcp");
+		let providerLabel = "cloud";
+		try {
+			providerLabel = (await loadProviderFromPackage(providerPackage, projectRoot)).label;
+		} catch (error) {
+			if (error instanceof ProviderNotInstalledError) {
+				console.error(`Error: ${error.message}`);
+				console.error("");
+				console.error("Install the provider package first:");
+				console.error(`  ${error.installCommand}`);
+				console.error("");
+				console.error("Then run this command again.");
+				process.exit(1);
+			}
+		}
+		console.log("No infrastructure configuration found. Starting initialization...\n");
+		if (!options.yes) {
+			if (!await confirm({
+				message: `This will create ${providerLabel} infrastructure (VPC, Database, Redis, Registry). Continue?`,
+				default: true
+			})) {
+				console.log("Aborted.");
+				process.exit(0);
+			}
+		}
+		await infraInit({
+			provider: options.provider,
+			project: options.project,
+			region: options.region,
+			env: options.env,
+			yes: options.yes
+		});
+		if (!await loadStoredConfig(projectRoot)) {
+			console.error("Error: Initialization completed but no configuration found.");
+			process.exit(1);
+		}
+		console.log("\n" + "─".repeat(60) + "\n");
+		console.log("Infrastructure initialized! Proceeding to deployment...\n");
+	} else {
+		console.log(`Using existing configuration for ${existingConfig.env} environment.`);
+		console.log(`Provider: ${existingConfig.provider}`);
+		console.log(`Region: ${existingConfig.region}\n`);
+	}
+	await infraDeploy({
+		env: options.env ?? existingConfig?.env ?? "dev",
+		preview: options.preview,
+		yes: options.yes
+	});
+	console.log("\n" + "═".repeat(60));
+	console.log("✅ Infrastructure up and running!");
+	console.log("═".repeat(60));
+	console.log("\nUseful commands:");
+	console.log(`  kuckit infra status   - Check current status`);
+	console.log(`  kuckit infra logs     - View application logs`);
+	console.log(`  kuckit infra outputs  - Show service URLs and secrets`);
+	console.log("");
+}
+
+//#endregion
+//#region src/commands/infra/eject.ts
+async function fileExists$7(path) {
+	try {
+		await access(path, constants$1.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot$7(cwd) {
+	let dir = cwd;
+	while (dir !== dirname$1(dir)) {
+		if (await fileExists$7(join$1(dir, "package.json"))) return dir;
+		dir = dirname$1(dir);
+	}
+	return null;
+}
+async function infraEject(options) {
+	console.log("Ejecting infrastructure code...\n");
+	const projectRoot = await findProjectRoot$7(process.cwd());
+	if (!projectRoot) {
+		console.error("Error: Could not find project root (no package.json found)");
+		process.exit(1);
+	}
+	const config = await loadStoredConfig(projectRoot);
+	if (!config) {
+		console.error("Error: No infrastructure configuration found.");
+		console.error("Run: kuckit infra init");
+		process.exit(1);
+	}
+	if (config.localInfraDir) {
+		console.error(`Error: Infrastructure already ejected to ${config.localInfraDir}`);
+		console.error("Remove localInfraDir from .kuckit/infra.json to re-eject.");
+		process.exit(1);
+	}
+	const providerPackage = config.providerPackage ?? getProviderPackage(config.provider);
+	let provider;
+	try {
+		provider = await loadProviderFromPackage(providerPackage, projectRoot);
+	} catch (error) {
+		if (error instanceof ProviderNotInstalledError) {
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("Install the provider package:");
+			console.error(`  ${error.installCommand}`);
+			process.exit(1);
+		}
+		if (error instanceof InvalidProviderError) {
+			console.error(`Error: ${error.message}`);
+			process.exit(1);
+		}
+		console.error(`Error: ${error instanceof Error ? error.message : "Failed to load provider"}`);
+		process.exit(1);
+	}
+	if (!provider.eject) {
+		console.error(`Error: Provider '${provider.id}' does not support ejecting.`);
+		process.exit(1);
+	}
+	const targetDir = options.dir ?? "infra";
+	const absoluteTargetDir = join$1(projectRoot, targetDir);
+	if (await fileExists$7(absoluteTargetDir)) {
+		if (!options.force) {
+			console.error(`Error: Directory '${targetDir}' already exists.`);
+			console.error("Use --force to overwrite, or specify a different directory with --dir.");
+			process.exit(1);
+		}
+	}
+	console.log("Configuration:");
+	console.log(`  Provider: ${provider.label}`);
+	console.log(`  Target directory: ${targetDir}`);
+	console.log("");
+	if (!options.force) {
+		console.log("This will:");
+		console.log(`  1. Copy provider Pulumi code to ${targetDir}/`);
+		console.log("  2. Update .kuckit/infra.json to use local infrastructure");
+		console.log("  3. Future deployments will use your local copy");
+		console.log("");
+		if (!await confirm({
+			message: "Proceed with eject?",
+			default: true
+		})) {
+			console.log("Aborted.");
+			process.exit(0);
+		}
+	}
+	const result = await provider.eject({
+		targetDir: absoluteTargetDir,
+		projectRoot,
+		force: options.force
+	});
+	if (!result.success) {
+		console.error(`\nError: ${result.message}`);
+		if (result.error) console.error(`  ${result.error.code}: ${result.error.message}`);
+		process.exit(1);
+	}
+	await saveStoredConfig(projectRoot, {
+		...config,
+		localInfraDir: targetDir,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	console.log("\n" + "=".repeat(60));
+	console.log("Infrastructure ejected successfully!");
+	console.log("=".repeat(60));
+	console.log(`\nYour infrastructure code is now in: ${targetDir}/`);
+	console.log("");
+	console.log("Next steps:");
+	console.log(`  1. Review and customize the Pulumi code in ${targetDir}/`);
+	console.log("  2. Install Pulumi dependencies: cd " + targetDir + " && bun install");
+	console.log("  3. Deploy with: kuckit infra deploy");
+	console.log("");
+	console.log("The CLI will now use your local infrastructure instead of the provider package.");
+	console.log("");
+}
+
+//#endregion
+//#region src/commands/infra/runner.ts
+/**
+* Run a Pulumi CLI command
+*/
+function runPulumi(args, options) {
+	return new Promise((resolve) => {
+		const proc = spawn("pulumi", args, {
+			cwd: options.cwd,
+			stdio: options.stream ? [
+				"inherit",
+				"pipe",
+				"pipe"
+			] : [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			shell: true,
+			env: {
+				...process.env,
+				...options.env,
+				PULUMI_SKIP_UPDATE_CHECK: "true"
+			}
+		});
+		let stdout = "";
+		let stderr = "";
+		proc.stdout?.on("data", (data) => {
+			const str = data.toString();
+			stdout += str;
+			if (options.stream) process.stdout.write(data);
+		});
+		proc.stderr?.on("data", (data) => {
+			const str = data.toString();
+			stderr += str;
+			if (options.stream) process.stderr.write(data);
+		});
+		proc.on("close", (code) => {
+			resolve({
+				code: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+/**
+* Run pulumi stack output --json and parse the result
+*/
+async function getPulumiOutputs(options) {
+	const result = await runPulumi([
+		"stack",
+		"output",
+		"--json"
+	], options);
+	if (result.code !== 0) return null;
+	try {
+		return JSON.parse(result.stdout);
+	} catch {
+		return null;
+	}
+}
+/**
+* Run pulumi stack --json and parse the result
+*/
+async function getPulumiStackInfo(options) {
+	const result = await runPulumi(["stack", "--json"], options);
+	if (result.code !== 0) return null;
+	try {
+		const data = JSON.parse(result.stdout);
+		return {
+			name: data.name ?? "",
+			current: data.current ?? false,
+			updateInProgress: data.updateInProgress ?? false,
+			resourceCount: data.resourceCount ?? 0,
+			lastUpdate: data.lastUpdate,
+			url: data.url
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Run pulumi stack history --json and parse the result
+*/
+async function getPulumiStackHistory(options, limit = 5) {
+	const result = await runPulumi([
+		"stack",
+		"history",
+		"--json",
+		"--show-secrets=false"
+	], options);
+	if (result.code !== 0) return [];
+	try {
+		const data = JSON.parse(result.stdout);
+		if (!Array.isArray(data)) return [];
+		return data.slice(0, limit).map((entry) => ({
+			version: entry.version ?? 0,
+			startTime: entry.startTime ?? "",
+			endTime: entry.endTime ?? "",
+			result: entry.result ?? "failed",
+			resourceChanges: entry.resourceChanges
+		}));
+	} catch {
+		return [];
+	}
+}
+/**
+* Select or create a Pulumi stack
+*/
+async function selectOrCreateStack(stackName, options) {
+	if ((await runPulumi([
+		"stack",
+		"select",
+		stackName
+	], options)).code === 0) return true;
+	return (await runPulumi([
+		"stack",
+		"init",
+		stackName
+	], options)).code === 0;
+}
+/**
+* Set a Pulumi config value
+*/
+async function setPulumiConfig(key, value, options) {
+	return (await runPulumi([
+		"config",
+		"set",
+		key,
+		value
+	], options)).code === 0;
+}
+/**
+* Run pulumi up with optional preview mode
+*/
+async function pulumiUp(options) {
+	return runPulumi(options.preview ? ["preview"] : ["up", "--yes"], {
+		...options,
+		stream: true
+	});
+}
+/**
+* Run pulumi destroy
+*/
+async function pulumiDestroy(options) {
+	return runPulumi(options.force ? [
+		"destroy",
+		"--yes",
+		"-f"
+	] : ["destroy", "--yes"], {
+		...options,
+		stream: true
+	});
+}
+/**
+* Run pulumi cancel to cancel stuck operations
+*/
+async function pulumiCancel(options) {
+	return runPulumi(["cancel", "--yes"], options);
+}
+/**
+* Run pulumi refresh to sync state with cloud provider
+*/
+async function pulumiRefresh(options) {
+	return runPulumi(["refresh", "--yes"], {
+		...options,
+		stream: true
+	});
+}
+/**
+* Export Pulumi stack state to a file
+*/
+async function pulumiStackExport(filePath, options) {
+	return runPulumi([
+		"stack",
+		"export",
+		"--file",
+		filePath
+	], options);
+}
+/**
+* Run a gcloud CLI command
+*/
+function runGcloud(args, options = {}) {
+	return new Promise((resolve) => {
+		const proc = spawn("gcloud", args, {
+			cwd: options.cwd ?? process.cwd(),
+			stdio: options.stream ? [
+				"inherit",
+				"pipe",
+				"pipe"
+			] : [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			shell: true
+		});
+		let stdout = "";
+		let stderr = "";
+		proc.stdout?.on("data", (data) => {
+			const str = data.toString();
+			stdout += str;
+			if (options.stream) process.stdout.write(data);
+		});
+		proc.stderr?.on("data", (data) => {
+			const str = data.toString();
+			stderr += str;
+			if (options.stream) process.stderr.write(data);
+		});
+		proc.on("close", (code) => {
+			resolve({
+				code: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+/**
+* Get the path to the packages/infra directory
+*/
+function getInfraDir$1(projectRoot) {
+	return join$1(projectRoot, "packages", "infra");
+}
+/**
+* Check if Pulumi CLI is installed
+*/
+async function checkPulumiInstalled() {
+	try {
+		return (await runPulumi(["version"], { cwd: process.cwd() })).code === 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check if gcloud CLI is installed
+*/
+async function checkGcloudInstalled() {
+	try {
+		return (await runGcloud(["version"])).code === 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* List Cloud Run service revisions
+*/
+async function listCloudRunRevisions(serviceName, project, region) {
+	const revisionsResult = await runGcloud([
+		"run",
+		"revisions",
+		"list",
+		"--service",
+		serviceName,
+		"--project",
+		project,
+		"--region",
+		region,
+		"--format",
+		"json"
+	]);
 	if (revisionsResult.code !== 0) return [];
 	const trafficResult = await runGcloud([
 		"run",
@@ -1282,429 +1998,75 @@ const ERROR_PATTERNS = [
 		pattern: /network.*error|connection.*refused|timeout|ETIMEDOUT|ECONNRESET/i,
 		type: PulumiErrorType.NetworkError,
 		suggestion: "Check your network connection and try again.",
-		retryable: true
-	},
-	{
-		pattern: /not found|does not exist|404/i,
-		type: PulumiErrorType.ResourceNotFound,
-		suggestion: "The resource may have been deleted externally. Run: kuckit infra repair --refresh",
-		retryable: false
-	},
-	{
-		pattern: /invalid.*config|configuration.*error|missing.*required/i,
-		type: PulumiErrorType.InvalidConfig,
-		suggestion: "Check your configuration in .kuckit/infra.json and Pulumi stack config.",
-		retryable: false
-	}
-];
-/**
-* Extract resource name from error output
-*/
-function extractResourceName(error) {
-	const urnMatch = error.match(/urn:pulumi:[^:]+:[^:]+::([^:]+:[^:\s]+)/i);
-	if (urnMatch) return urnMatch[1];
-	const gcpMatch = error.match(/projects\/[^/]+\/(?:locations|regions)\/[^/]+\/([^/\s]+\/[^/\s]+)/i);
-	if (gcpMatch) return gcpMatch[1];
-}
-/**
-* Parse an error output and return a structured ParsedError
-*/
-function parseError(error) {
-	for (const { pattern, type, suggestion, retryable } of ERROR_PATTERNS) if (pattern.test(error)) return {
-		type,
-		message: getErrorMessage(type, error),
-		resource: extractResourceName(error),
-		suggestion,
-		retryable,
-		originalError: error
-	};
-	return {
-		type: PulumiErrorType.Unknown,
-		message: "An unknown error occurred during infrastructure operation.",
-		resource: extractResourceName(error),
-		suggestion: "Check the error output above. If the issue persists, run: kuckit infra repair --refresh",
-		retryable: false,
-		originalError: error
-	};
-}
-/**
-* Get a human-readable error message for an error type
-*/
-function getErrorMessage(type, originalError) {
-	switch (type) {
-		case PulumiErrorType.ConcurrentUpdate: return "Another infrastructure update is already in progress.";
-		case PulumiErrorType.ResourceConflict: return "A resource with this name already exists.";
-		case PulumiErrorType.QuotaExceeded: return "GCP quota limit has been reached.";
-		case PulumiErrorType.PermissionDenied: return "Permission denied. Check your IAM permissions.";
-		case PulumiErrorType.StateCorruption: return "Infrastructure state is inconsistent.";
-		case PulumiErrorType.NetworkError: return "Network error occurred. This may be a transient issue.";
-		case PulumiErrorType.ResourceNotFound: return "A required resource was not found.";
-		case PulumiErrorType.InvalidConfig: return "Invalid configuration detected.";
-		default: return originalError.split("\n").find((line) => line.trim().length > 0)?.slice(0, 200) ?? "An error occurred.";
-	}
-}
-/**
-* Format a ParsedError for console output
-*/
-function formatError(error) {
-	const lines = [`Error: ${error.message}`, ""];
-	if (error.resource) lines.push(`Resource: ${error.resource}`);
-	lines.push(`Suggestion: ${error.suggestion}`);
-	return lines.join("\n");
-}
-
-//#endregion
-//#region src/commands/infra/init.ts
-const KUCKIT_DIR$8 = ".kuckit";
-const CONFIG_FILE$8 = "infra.json";
-async function fileExists$8(path) {
-	try {
-		await access(path, constants$1.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function findProjectRoot$8(cwd) {
-	let dir = cwd;
-	while (dir !== dirname$1(dir)) {
-		if (await fileExists$8(join$1(dir, "package.json"))) return dir;
-		dir = dirname$1(dir);
-	}
-	return null;
-}
-async function loadExistingConfig(projectRoot) {
-	const configPath = join$1(projectRoot, KUCKIT_DIR$8, CONFIG_FILE$8);
-	if (!await fileExists$8(configPath)) return null;
-	try {
-		const content = await readFile(configPath, "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return null;
-	}
-}
-async function saveConfig$1(projectRoot, config) {
-	const kuckitDir = join$1(projectRoot, KUCKIT_DIR$8);
-	await mkdir(kuckitDir, { recursive: true });
-	await writeFile(join$1(kuckitDir, CONFIG_FILE$8), JSON.stringify(config, null, 2), "utf-8");
-}
-async function infraInit(options) {
-	console.log("Initializing kuckit infrastructure...\n");
-	if (!await checkPulumiInstalled()) {
-		console.error("Error: Pulumi CLI is not installed.");
-		console.error("Install it from: https://www.pulumi.com/docs/install/");
-		process.exit(1);
-	}
-	if (!await checkGcloudInstalled()) {
-		console.error("Error: gcloud CLI is not installed.");
-		console.error("Install it from: https://cloud.google.com/sdk/docs/install");
-		process.exit(1);
-	}
-	const projectRoot = await findProjectRoot$8(process.cwd());
-	if (!projectRoot) {
-		console.error("Error: Could not find project root (no package.json found)");
-		process.exit(1);
-	}
-	const infraDir = getInfraDir(projectRoot);
-	if (!await fileExists$8(infraDir)) {
-		console.error("Error: packages/infra not found.");
-		console.error("Make sure you have the @kuckit/infra package in your project.");
-		process.exit(1);
-	}
-	const existingConfig = await loadExistingConfig(projectRoot);
-	const provider = options.provider ?? "gcp";
-	if (provider !== "gcp") {
-		console.error(`Error: Provider '${provider}' is not supported. Only 'gcp' is currently supported.`);
-		process.exit(1);
-	}
-	let gcpProject = options.project ?? existingConfig?.gcpProject;
-	if (!gcpProject) gcpProject = await input({
-		message: "GCP Project ID:",
-		validate: (value) => value.length > 0 ? true : "Project ID is required"
-	});
-	let region = options.region ?? existingConfig?.region ?? "us-central1";
-	if (!options.region && !existingConfig?.region) region = await input({
-		message: "GCP Region:",
-		default: "us-central1"
-	});
-	let env = options.env ?? existingConfig?.env ?? "dev";
-	if (!options.env && !existingConfig?.env) env = await input({
-		message: "Environment (dev/prod):",
-		default: "dev",
-		validate: (value) => value === "dev" || value === "prod" ? true : "Must be dev or prod"
-	});
-	const stackName = `${gcpProject}-${env}`;
-	console.log("\nConfiguration:");
-	console.log(`  Provider: ${provider}`);
-	console.log(`  GCP Project: ${gcpProject}`);
-	console.log(`  Region: ${region}`);
-	console.log(`  Environment: ${env}`);
-	console.log(`  Stack: ${stackName}`);
-	console.log("");
-	if (!options.yes) {
-		if (!await confirm({
-			message: "Proceed with infrastructure initialization?",
-			default: true
-		})) {
-			console.log("Aborted.");
-			process.exit(0);
-		}
-	}
-	console.log("\nInstalling infrastructure dependencies...");
-	const { spawn: spawn$1 } = await import("child_process");
-	await new Promise((resolve, reject) => {
-		spawn$1("bun", ["install"], {
-			cwd: infraDir,
-			stdio: "inherit",
-			shell: true
-		}).on("close", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`bun install failed with code ${code}`));
-		});
-	});
-	console.log("\nBuilding infrastructure package...");
-	await new Promise((resolve, reject) => {
-		spawn$1("bun", ["run", "build"], {
-			cwd: infraDir,
-			stdio: "inherit",
-			shell: true
-		}).on("close", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`Build failed with code ${code}`));
-		});
-	});
-	console.log(`\nSelecting Pulumi stack: ${stackName}`);
-	if (!await selectOrCreateStack(stackName, { cwd: infraDir })) {
-		console.error("Error: Failed to select or create Pulumi stack");
-		process.exit(1);
-	}
-	console.log("Configuring stack...");
-	await setPulumiConfig("gcp:project", gcpProject, { cwd: infraDir });
-	await setPulumiConfig("gcp:region", region, { cwd: infraDir });
-	await setPulumiConfig("env", env, { cwd: infraDir });
-	console.log("\nCreating infrastructure...");
-	console.log("This may take several minutes.\n");
-	const result = await pulumiUp({
-		cwd: infraDir,
-		stream: true
-	});
-	if (result.code !== 0) {
-		const parsed = parseError(result.stderr);
-		console.error("\n" + formatError(parsed));
-		process.exit(1);
-	}
-	console.log("\nRetrieving outputs...");
-	const outputs = await getPulumiOutputs({ cwd: infraDir });
-	await saveConfig$1(projectRoot, {
-		provider: "gcp",
-		gcpProject,
-		region,
-		projectName: "kuckit-infra",
-		stackName,
-		env,
-		outputs: outputs ? {
-			registryUrl: outputs.registryUrl,
-			databaseConnectionName: outputs.databaseConnectionName,
-			redisHost: outputs.redisHost,
-			secretIds: {
-				dbPassword: outputs.dbPasswordSecretId,
-				redisAuth: outputs.redisAuthSecretId ?? ""
-			}
-		} : void 0,
-		createdAt: existingConfig?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-	console.log(`\nConfiguration saved to ${KUCKIT_DIR$8}/${CONFIG_FILE$8}`);
-	console.log("\n" + "=".repeat(60));
-	console.log("Infrastructure initialized successfully!");
-	console.log("=".repeat(60));
-	if (outputs) {
-		console.log("\nOutputs:");
-		console.log(`  Registry: ${outputs.registryUrl}`);
-		console.log(`  Database: ${outputs.databaseConnectionName}`);
-		console.log(`  Redis: ${outputs.redisHost}`);
+		retryable: true
+	},
+	{
+		pattern: /not found|does not exist|404/i,
+		type: PulumiErrorType.ResourceNotFound,
+		suggestion: "The resource may have been deleted externally. Run: kuckit infra repair --refresh",
+		retryable: false
+	},
+	{
+		pattern: /invalid.*config|configuration.*error|missing.*required/i,
+		type: PulumiErrorType.InvalidConfig,
+		suggestion: "Check your configuration in .kuckit/infra.json and Pulumi stack config.",
+		retryable: false
 	}
-	console.log("\nNext steps:");
-	console.log("  1. Ensure you have a Dockerfile in your project root");
-	console.log(`  2. Run: kuckit infra deploy --env ${env}`);
-	console.log("");
-}
-
-//#endregion
-//#region src/commands/infra/deploy.ts
-const KUCKIT_DIR$7 = ".kuckit";
-const CONFIG_FILE$7 = "infra.json";
-async function saveConfig(projectRoot, config) {
-	const kuckitDir = join$1(projectRoot, KUCKIT_DIR$7);
-	await mkdir(kuckitDir, { recursive: true });
-	await writeFile(join$1(kuckitDir, CONFIG_FILE$7), JSON.stringify(config, null, 2), "utf-8");
-}
+];
 /**
-* Get the current git commit short hash
-* Returns null if not in a git repo or git command fails
+* Extract resource name from error output
 */
-function getGitShortHash() {
-	try {
-		return execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
-	} catch {
-		return null;
-	}
-}
-async function fileExists$7(path) {
-	try {
-		await access(path, constants$1.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
+function extractResourceName(error) {
+	const urnMatch = error.match(/urn:pulumi:[^:]+:[^:]+::([^:]+:[^:\s]+)/i);
+	if (urnMatch) return urnMatch[1];
+	const gcpMatch = error.match(/projects\/[^/]+\/(?:locations|regions)\/[^/]+\/([^/\s]+\/[^/\s]+)/i);
+	if (gcpMatch) return gcpMatch[1];
 }
-async function findProjectRoot$7(cwd) {
-	let dir = cwd;
-	while (dir !== dirname$1(dir)) {
-		if (await fileExists$7(join$1(dir, "package.json"))) return dir;
-		dir = dirname$1(dir);
-	}
-	return null;
+/**
+* Parse an error output and return a structured ParsedError
+*/
+function parseError(error) {
+	for (const { pattern, type, suggestion, retryable } of ERROR_PATTERNS) if (pattern.test(error)) return {
+		type,
+		message: getErrorMessage(type, error),
+		resource: extractResourceName(error),
+		suggestion,
+		retryable,
+		originalError: error
+	};
+	return {
+		type: PulumiErrorType.Unknown,
+		message: "An unknown error occurred during infrastructure operation.",
+		resource: extractResourceName(error),
+		suggestion: "Check the error output above. If the issue persists, run: kuckit infra repair --refresh",
+		retryable: false,
+		originalError: error
+	};
 }
-async function loadConfig$7(projectRoot) {
-	const configPath = join$1(projectRoot, KUCKIT_DIR$7, CONFIG_FILE$7);
-	if (!await fileExists$7(configPath)) return null;
-	try {
-		const content = await readFile(configPath, "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return null;
+/**
+* Get a human-readable error message for an error type
+*/
+function getErrorMessage(type, originalError) {
+	switch (type) {
+		case PulumiErrorType.ConcurrentUpdate: return "Another infrastructure update is already in progress.";
+		case PulumiErrorType.ResourceConflict: return "A resource with this name already exists.";
+		case PulumiErrorType.QuotaExceeded: return "GCP quota limit has been reached.";
+		case PulumiErrorType.PermissionDenied: return "Permission denied. Check your IAM permissions.";
+		case PulumiErrorType.StateCorruption: return "Infrastructure state is inconsistent.";
+		case PulumiErrorType.NetworkError: return "Network error occurred. This may be a transient issue.";
+		case PulumiErrorType.ResourceNotFound: return "A required resource was not found.";
+		case PulumiErrorType.InvalidConfig: return "Invalid configuration detected.";
+		default: return originalError.split("\n").find((line) => line.trim().length > 0)?.slice(0, 200) ?? "An error occurred.";
 	}
 }
-async function infraDeploy(options) {
-	console.log("Deploying kuckit application...\n");
-	if (!await checkPulumiInstalled()) {
-		console.error("Error: Pulumi CLI is not installed.");
-		console.error("Install it from: https://www.pulumi.com/docs/install/");
-		process.exit(1);
-	}
-	if (!await checkGcloudInstalled()) {
-		console.error("Error: gcloud CLI is not installed.");
-		console.error("Install it from: https://cloud.google.com/sdk/docs/install");
-		process.exit(1);
-	}
-	const projectRoot = await findProjectRoot$7(process.cwd());
-	if (!projectRoot) {
-		console.error("Error: Could not find project root (no package.json found)");
-		process.exit(1);
-	}
-	const config = await loadConfig$7(projectRoot);
-	if (!config) {
-		console.error("Error: No infrastructure configuration found.");
-		console.error("Run: kuckit infra init");
-		process.exit(1);
-	}
-	const env = options.env ?? config.env;
-	if (env !== "dev" && env !== "prod") {
-		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
-		process.exit(1);
-	}
-	const infraDir = getInfraDir(projectRoot);
-	if (!await fileExists$7(infraDir)) {
-		console.error("Error: packages/infra not found.");
-		process.exit(1);
-	}
-	const dockerfilePath = join$1(projectRoot, "Dockerfile");
-	if (!options.skipBuild && !options.image && !await fileExists$7(dockerfilePath)) {
-		console.error("Error: Dockerfile not found in project root.");
-		console.error("Create a Dockerfile or use --skip-build with an existing image.");
-		process.exit(1);
-	}
-	if (!config.outputs?.registryUrl) {
-		console.error("Error: No registry URL found in configuration.");
-		console.error("Run: kuckit infra init");
-		process.exit(1);
-	}
-	console.log("Configuration:");
-	console.log(`  Project: ${config.gcpProject}`);
-	console.log(`  Region: ${config.region}`);
-	console.log(`  Environment: ${env}`);
-	console.log(`  Registry: ${config.outputs.registryUrl}`);
-	if (options.preview) console.log("  Mode: Preview (no changes will be applied)");
-	console.log("");
-	let imageUrl;
-	if (options.image) {
-		imageUrl = options.image;
-		console.log(`Using provided image: ${imageUrl}\n`);
-	} else if (options.skipBuild) {
-		imageUrl = `${config.outputs.registryUrl}/kuckit:latest`;
-		console.log(`Using existing image: ${imageUrl}\n`);
-	} else {
-		console.log("Building and pushing Docker image...");
-		console.log("(Using Cloud Build - no local Docker required)\n");
-		const buildResult = await buildAndPushImage({
-			project: config.gcpProject,
-			registryUrl: config.outputs.registryUrl,
-			tag: process.env.GIT_SHA ?? process.env.GITHUB_SHA ?? getGitShortHash() ?? "latest",
-			cwd: projectRoot
-		});
-		if (buildResult.code !== 0) {
-			console.error("\nError: Docker build failed.");
-			process.exit(1);
-		}
-		imageUrl = buildResult.imageUrl;
-		console.log(`\nImage built: ${imageUrl}\n`);
-	}
-	if (!options.yes && !options.preview) {
-		if (!await confirm({
-			message: "Proceed with deployment?",
-			default: true
-		})) {
-			console.log("Aborted.");
-			process.exit(0);
-		}
-	}
-	const stackName = config.stackName;
-	console.log(`Selecting Pulumi stack: ${stackName}`);
-	if (!await selectOrCreateStack(stackName, { cwd: infraDir })) {
-		console.error("Error: Failed to select Pulumi stack");
-		process.exit(1);
-	}
-	console.log("Configuring deployment...");
-	await setPulumiConfig("imageUrl", imageUrl, { cwd: infraDir });
-	if (config.outputs?.serviceUrl) await setPulumiConfig("appUrl", config.outputs.serviceUrl, { cwd: infraDir });
-	if (options.preview) console.log("\nPreviewing changes...\n");
-	else console.log("\nDeploying to Cloud Run...\n");
-	const result = await pulumiUp({
-		cwd: infraDir,
-		stream: true,
-		preview: options.preview
-	});
-	if (result.code !== 0) {
-		const parsed = parseError(result.stderr);
-		console.error("\n" + formatError(parsed));
-		process.exit(1);
-	}
-	if (!options.preview) {
-		console.log("\nRetrieving deployment info...");
-		const outputs = await getPulumiOutputs({ cwd: infraDir });
-		if (outputs) {
-			config.outputs = {
-				...config.outputs,
-				...outputs
-			};
-			config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			await saveConfig(projectRoot, config);
-		}
-		console.log("\n" + "=".repeat(60));
-		console.log("Deployment successful!");
-		console.log("=".repeat(60));
-		if (outputs?.serviceUrl) console.log(`\nService URL: ${outputs.serviceUrl}`);
-		if (outputs?.migrationJobName) console.log(`Migration Job: ${outputs.migrationJobName}`);
-		console.log("\nUseful commands:");
-		console.log(`  View logs: kuckit infra logs --env ${env}`);
-		console.log(`  Check status: kuckit infra status --env ${env}`);
-		console.log(`  Run migrations: kuckit infra db:migrate --env ${env}`);
-		console.log("");
-	} else {
-		console.log("\nPreview complete. No changes were applied.");
-		console.log("Run without --preview to apply changes.");
-	}
+/**
+* Format a ParsedError for console output
+*/
+function formatError(error) {
+	const lines = [`Error: ${error.message}`, ""];
+	if (error.resource) lines.push(`Resource: ${error.resource}`);
+	lines.push(`Suggestion: ${error.suggestion}`);
+	return lines.join("\n");
 }
 
 //#endregion
@@ -1762,7 +2124,7 @@ async function infraDestroy(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
-	const infraDir = getInfraDir(projectRoot);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$6(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -1915,7 +2277,7 @@ async function infraRepair(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
-	const infraDir = getInfraDir(projectRoot);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$5(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -2022,6 +2384,12 @@ async function getJobContext(options) {
 		console.error("Run: kuckit infra init");
 		process.exit(1);
 	}
+	if (!isGcpConfig(config)) {
+		console.error("Error: Database commands only support GCP provider.");
+		console.error(`Current provider: ${config.provider}`);
+		process.exit(1);
+	}
+	const gcpProject = config.providerConfig.gcpProject;
 	const env = options.env ?? config.env;
 	if (env !== "dev" && env !== "prod") {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
@@ -2036,6 +2404,7 @@ async function getJobContext(options) {
 	}
 	return {
 		config,
+		gcpProject,
 		projectRoot,
 		env,
 		jobName
@@ -2112,18 +2481,18 @@ async function infraDbPush(options) {
 	console.log("Running database schema push via Cloud Run Job...\n");
 	const ctx = await getJobContext(options);
 	console.log("Configuration:");
-	console.log(`  Project: ${ctx.config.gcpProject}`);
+	console.log(`  Project: ${ctx.gcpProject}`);
 	console.log(`  Environment: ${ctx.env}`);
 	console.log(`  Job: ${ctx.jobName}`);
 	console.log("");
 	const commandOverride = [`export NODE_PATH=/app/node_modules && cd /app && node /app/node_modules/drizzle-kit/bin.cjs push --config=packages/db/drizzle.config.ts${options.force ? " --force" : ""}`];
-	if (!await executeCloudRunJob(ctx.config.gcpProject, ctx.config.region, ctx.jobName, commandOverride)) {
+	if (!await executeCloudRunJob(ctx.gcpProject, ctx.config.region, ctx.jobName, commandOverride)) {
 		console.error("\nError: Schema push failed.");
 		console.error("Check the Cloud Run Job logs for details:");
 		console.error(`  gcloud run jobs executions list --job ${ctx.jobName} --region ${ctx.config.region}`);
 		process.exit(1);
 	}
-	const execution = await getLatestJobExecution(ctx.config.gcpProject, ctx.config.region, ctx.jobName);
+	const execution = await getLatestJobExecution(ctx.gcpProject, ctx.config.region, ctx.jobName);
 	if (execution?.logs) {
 		console.log("\nJob output:");
 		console.log(execution.logs);
@@ -2143,17 +2512,17 @@ async function infraDbMigrate(options) {
 	}
 	const ctx = await getJobContext(options);
 	console.log("Configuration:");
-	console.log(`  Project: ${ctx.config.gcpProject}`);
+	console.log(`  Project: ${ctx.gcpProject}`);
 	console.log(`  Environment: ${ctx.env}`);
 	console.log(`  Job: ${ctx.jobName}`);
 	console.log("");
-	if (!await executeCloudRunJob(ctx.config.gcpProject, ctx.config.region, ctx.jobName)) {
+	if (!await executeCloudRunJob(ctx.gcpProject, ctx.config.region, ctx.jobName)) {
 		console.error("\nError: Migration failed.");
 		console.error("Check the Cloud Run Job logs for details:");
 		console.error(`  gcloud run jobs executions list --job ${ctx.jobName} --region ${ctx.config.region}`);
 		process.exit(1);
 	}
-	const execution = await getLatestJobExecution(ctx.config.gcpProject, ctx.config.region, ctx.jobName);
+	const execution = await getLatestJobExecution(ctx.gcpProject, ctx.config.region, ctx.jobName);
 	if (execution?.logs) {
 		console.log("\nJob output:");
 		console.log(execution.logs);
@@ -2475,9 +2844,8 @@ async function infraStatus(options) {
 		console.error("Run: kuckit infra init");
 		process.exit(1);
 	}
-	const env = options.env ?? config.env ?? "dev";
-	const stackName = `${config.gcpProject}-${env}`;
-	const infraDir = getInfraDir(projectRoot);
+	const stackName = config.stackName;
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$1(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -2587,8 +2955,8 @@ async function infraOutputs(options) {
 		process.exit(1);
 	}
 	const env = options.env ?? config.env ?? "dev";
-	const stackName = `${config.gcpProject}-${env}`;
-	const infraDir = getInfraDir(projectRoot);
+	const stackName = config.stackName;
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -2634,6 +3002,210 @@ async function infraOutputs(options) {
 	console.log("");
 }
 
+//#endregion
+//#region src/commands/infra/config.ts
+/**
+* Known configuration keys with their descriptions
+*/
+const KNOWN_CONFIG_KEYS = {
+	appUrl: {
+		description: "Application URL (used for CORS and redirects)",
+		example: "https://app.example.com"
+	},
+	region: {
+		description: "Deployment region",
+		example: "us-central1"
+	},
+	env: {
+		description: "Environment (dev, staging, prod)",
+		example: "prod"
+	}
+};
+function getProjectRoot() {
+	return process.cwd();
+}
+async function ensureConfigExists(projectRoot) {
+	const config = await loadStoredConfig(projectRoot);
+	if (!config) throw new Error("No infrastructure configuration found. Run `kuckit infra init` first.");
+	return config;
+}
+function getStackName(config, env) {
+	return `${config.projectName}-${env}`;
+}
+async function getInfraDir(projectRoot, config) {
+	if (config.localInfraDir) return config.localInfraDir;
+	return (await loadProviderFromPackage(config.providerPackage ?? getProviderPackage(config.provider), projectRoot)).getInfraDir(projectRoot);
+}
+async function selectStack(infraDir, stackName) {
+	return selectOrCreateStack(stackName, { cwd: infraDir });
+}
+async function syncToPulumi(projectRoot, config, env, key, value) {
+	const infraDir = await getInfraDir(projectRoot, config);
+	const stackName = getStackName(config, env);
+	const pulumiOptions = { cwd: infraDir };
+	if (!await selectStack(infraDir, stackName)) throw new Error(`Could not select stack '${stackName}'. Run 'kuckit infra init --env ${env}' first.`);
+	await setPulumiConfig(key, value, pulumiOptions);
+}
+async function getPulumiConfigValue(projectRoot, config, env, key) {
+	const infraDir = await getInfraDir(projectRoot, config);
+	const stackName = getStackName(config, env);
+	const pulumiOptions = { cwd: infraDir };
+	if (!await selectStack(infraDir, stackName)) return null;
+	try {
+		const result = await runPulumi([
+			"config",
+			"get",
+			key
+		], pulumiOptions);
+		return result.code === 0 ? result.stdout.trim() : null;
+	} catch {
+		return null;
+	}
+}
+async function getAllPulumiConfig(projectRoot, config, env) {
+	const infraDir = await getInfraDir(projectRoot, config);
+	const stackName = getStackName(config, env);
+	const pulumiOptions = { cwd: infraDir };
+	if (!await selectStack(infraDir, stackName)) return {};
+	try {
+		const result = await runPulumi(["config", "--json"], pulumiOptions);
+		if (result.code === 0 && result.stdout) {
+			const parsed = JSON.parse(result.stdout);
+			const configMap = {};
+			for (const [fullKey, data] of Object.entries(parsed)) {
+				const key = fullKey.includes(":") ? fullKey.split(":")[1] : fullKey;
+				if (key) configMap[key] = data.value;
+			}
+			return configMap;
+		}
+		return {};
+	} catch {
+		return {};
+	}
+}
+async function unsetPulumiConfig(projectRoot, config, env, key) {
+	const infraDir = await getInfraDir(projectRoot, config);
+	const stackName = getStackName(config, env);
+	const pulumiOptions = { cwd: infraDir };
+	if (!await selectStack(infraDir, stackName)) throw new Error(`Could not select stack '${stackName}'. Run 'kuckit infra init --env ${env}' first.`);
+	await runPulumi([
+		"config",
+		"rm",
+		key
+	], pulumiOptions);
+}
+/**
+* Set a configuration value
+*/
+async function infraConfigSet(key, value, options = {}) {
+	const projectRoot = getProjectRoot();
+	const config = await ensureConfigExists(projectRoot);
+	const env = options.env ?? config.env ?? "dev";
+	if (["region", "projectName"].includes(key)) {
+		if (key === "region") config.region = value;
+		else if (key === "projectName") config.projectName = value;
+		await saveStoredConfig(projectRoot, config);
+		console.log(`✓ Set ${key}=${value} in .kuckit/infra.json`);
+		return;
+	}
+	if (key.startsWith("provider.")) {
+		const providerKey = key.replace("provider.", "");
+		if (isGcpConfig(config) && providerKey === "gcpProject") {
+			config.providerConfig.gcpProject = value;
+			await saveStoredConfig(projectRoot, config);
+			console.log(`✓ Set ${key}=${value} in .kuckit/infra.json`);
+			return;
+		}
+	}
+	await syncToPulumi(projectRoot, config, env, key, value);
+	console.log(`✓ Set ${key}=${value} for env '${env}'`);
+	if (key === "appUrl") console.log(`\nNote: Run 'kuckit infra deploy --env ${env}' to apply this change.`);
+}
+/**
+* Get a configuration value
+*/
+async function infraConfigGet(key, options = {}) {
+	const projectRoot = getProjectRoot();
+	const config = await ensureConfigExists(projectRoot);
+	const env = options.env ?? config.env ?? "dev";
+	const localKeys = {
+		region: (c) => c.region,
+		projectName: (c) => c.projectName,
+		provider: (c) => c.provider,
+		"provider.gcpProject": (c) => isGcpConfig(c) ? c.providerConfig.gcpProject : void 0
+	};
+	if (key in localKeys) {
+		const getter = localKeys[key];
+		if (getter) {
+			const value$1 = getter(config);
+			if (value$1 !== void 0) {
+				console.log(value$1);
+				return;
+			}
+		}
+	}
+	const value = await getPulumiConfigValue(projectRoot, config, env, key);
+	if (value !== null) console.log(value);
+	else {
+		console.error(`Config key '${key}' is not set for env '${env}'.`);
+		process.exit(1);
+	}
+}
+/**
+* List all configuration values
+*/
+async function infraConfigList(options = {}) {
+	const projectRoot = getProjectRoot();
+	const config = await ensureConfigExists(projectRoot);
+	const env = options.env ?? config.env ?? "dev";
+	const localConfig = {
+		provider: config.provider,
+		region: config.region,
+		projectName: config.projectName
+	};
+	if (isGcpConfig(config)) localConfig["provider.gcpProject"] = config.providerConfig.gcpProject;
+	const pulumiConfig = await getAllPulumiConfig(projectRoot, config, env);
+	const allConfig = {
+		...localConfig,
+		...pulumiConfig
+	};
+	if (options.json) {
+		console.log(JSON.stringify({
+			env,
+			config: allConfig
+		}, null, 2));
+		return;
+	}
+	console.log(`\nInfrastructure Configuration (env: ${env})\n`);
+	console.log("Shared (.kuckit/infra.json):");
+	for (const [key, value] of Object.entries(localConfig)) console.log(`  ${key}: ${value}`);
+	if (Object.keys(pulumiConfig).length > 0) {
+		console.log(`\nEnvironment '${env}' Config:`);
+		for (const [key, value] of Object.entries(pulumiConfig)) if (!(key in localConfig)) {
+			const desc = KNOWN_CONFIG_KEYS[key]?.description;
+			console.log(`  ${key}: ${value}${desc ? ` (${desc})` : ""}`);
+		}
+	} else console.log(`\nEnvironment '${env}' Config: (none set)`);
+	console.log("\nAvailable keys:");
+	for (const [key, info] of Object.entries(KNOWN_CONFIG_KEYS)) if (!(key in allConfig)) console.log(`  ${key}: ${info.description} (e.g., ${info.example})`);
+	console.log(`\nTip: Use --env to configure other environments (dev, staging, prod)`);
+}
+/**
+* Unset a configuration value
+*/
+async function infraConfigUnset(key, options = {}) {
+	const projectRoot = getProjectRoot();
+	const config = await ensureConfigExists(projectRoot);
+	const env = options.env ?? config.env ?? "dev";
+	if ([
+		"provider",
+		"region",
+		"projectName"
+	].includes(key)) throw new Error(`Cannot unset required key '${key}'.`);
+	await unsetPulumiConfig(projectRoot, config, env, key);
+	console.log(`✓ Unset ${key} for env '${env}'`);
+}
+
 //#endregion
 //#region src/bin.ts
 program.name("kuckit").description("CLI tools for Kuckit SDK module development").version("0.1.0");
@@ -2673,6 +3245,10 @@ db.command("studio").description("Open Drizzle Studio with all module schemas").
 });
 registerAuthCommands(program);
 const infra = program.command("infra").description("Infrastructure deployment and management");
+infra.command("up").description("Initialize (if needed) and deploy infrastructure in one command").option("-p, --provider <provider>", "Cloud provider (gcp)", "gcp").option("--project <id>", "GCP project ID").option("--region <region>", "Deployment region", "us-central1").option("-e, --env <env>", "Environment (dev, prod)", "dev").option("--preview", "Preview changes without applying", false).option("-y, --yes", "Skip confirmation prompts", false).action(async (options) => {
+	requireAuth();
+	await infraUp(options);
+});
 infra.command("init").description("Initialize base infrastructure (no Docker required)").option("-p, --provider <provider>", "Cloud provider (gcp)", "gcp").option("--project <id>", "GCP project ID").option("--region <region>", "Deployment region", "us-central1").option("-e, --env <env>", "Environment (dev, prod)", "dev").option("-y, --yes", "Skip confirmation prompts", false).action(async (options) => {
 	requireAuth();
 	await infraInit(options);
@@ -2681,6 +3257,10 @@ infra.command("deploy").description("Build and deploy application to Cloud Run")
 	requireAuth();
 	await infraDeploy(options);
 });
+infra.command("eject").description("Eject provider infrastructure code to local project for customization").option("-d, --dir <directory>", "Target directory for ejected code", "infra").option("--force", "Overwrite existing directory", false).action(async (options) => {
+	requireAuth();
+	await infraEject(options);
+});
 infra.command("destroy").description("Destroy infrastructure resources").option("-e, --env <env>", "Environment (dev, prod)", "dev").option("--app-only", "Only destroy Cloud Run, keep DB/Redis", false).option("--force", "Skip confirmation prompt", false).action(async (options) => {
 	requireAuth();
 	await infraDestroy(options);
@@ -2713,7 +3293,25 @@ infra.command("outputs").description("Display infrastructure outputs (URLs, conn
 	requireAuth();
 	await infraOutputs(options);
 });
+const configCmd = infra.command("config").description("Manage infrastructure configuration");
+configCmd.command("set <key> <value>").description("Set a configuration value").option("-e, --env <env>", "Environment (dev, prod)", "dev").action(async (key, value, options) => {
+	requireAuth();
+	await infraConfigSet(key, value, options);
+});
+configCmd.command("get <key>").description("Get a configuration value").option("-e, --env <env>", "Environment (dev, prod)", "dev").action(async (key, options) => {
+	requireAuth();
+	await infraConfigGet(key, options);
+});
+configCmd.command("list").description("List all configuration values").option("-e, --env <env>", "Environment (dev, prod)", "dev").option("--json", "Output as JSON", false).action(async (options) => {
+	requireAuth();
+	await infraConfigList(options);
+});
+configCmd.command("unset <key>").description("Remove a configuration value").option("-e, --env <env>", "Environment (dev, prod)", "dev").action(async (key, options) => {
+	requireAuth();
+	await infraConfigUnset(key, options);
+});
 program.parse();
 
 //#endregion
-export {  };
+export {  };
+//# sourceMappingURL=bin.js.map