@kuckit/cli 1.0.1 → 2.0.0

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-B7rxN4vq.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, unlinkSync, writeFileSync } from "node:fs";
-import { execSync, spawn } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+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 = [
@@ -15,6 +16,15 @@ const CONFIG_FILES = [
 	"kuckit.config.js",
 	"kuckit.config.mjs"
 ];
+const FRAMEWORK_PACKAGES = [
+	"@kuckit/sdk",
+	"@kuckit/sdk-react",
+	"@kuckit/api",
+	"@kuckit/db",
+	"@kuckit/auth",
+	"@kuckit/domain",
+	"@kuckit/contracts"
+];
 function findConfigFile(cwd) {
 	let dir = cwd;
 	while (dir !== dirname(dir)) {
@@ -58,6 +68,18 @@ function findPackagePath(packageName, cwd) {
 	}
 	return null;
 }
+function scanSourceFiles(dir) {
+	const files = [];
+	try {
+		const entries = readdirSync(dir);
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			if (statSync(fullPath).isDirectory()) files.push(...scanSourceFiles(fullPath));
+			else if (entry.endsWith(".ts") || entry.endsWith(".tsx")) files.push(fullPath);
+		}
+	} catch {}
+	return files;
+}
 function checkModuleExports(packageName, cwd) {
 	const result = {
 		server: false,
@@ -78,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");
@@ -118,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)) {
@@ -211,18 +233,75 @@ async function doctor(options) {
 		status: "pass",
 		message: "Module exports valid"
 	});
-	const sdkPackages = ["@kuckit/sdk", "@kuckit/sdk-react"];
-	const missingSdk = [];
-	for (const sdk of sdkPackages) if (!readPackageJson(sdk, cwd)) missingSdk.push(sdk);
-	if (missingSdk.length > 0) checks.push({
-		name: "sdk-installed",
+	const missingFramework = [];
+	const installedFramework = [];
+	for (const pkg of FRAMEWORK_PACKAGES) {
+		const pkgJson = readPackageJson(pkg, cwd);
+		if (!pkgJson) missingFramework.push(pkg);
+		else installedFramework.push({
+			name: pkg,
+			version: pkgJson.version
+		});
+	}
+	if (missingFramework.length > 0) checks.push({
+		name: "framework-installed",
 		status: "warn",
-		message: `SDK package(s) not found: ${missingSdk.join(", ")}`
+		message: `Framework package(s) not found: ${missingFramework.length}/${FRAMEWORK_PACKAGES.length}`,
+		details: missingFramework.map((p) => `  - ${p} (not installed)`)
 	});
 	else checks.push({
-		name: "sdk-installed",
+		name: "framework-installed",
+		status: "pass",
+		message: `All ${FRAMEWORK_PACKAGES.length} framework packages installed`
+	});
+	const kuckitVersions = /* @__PURE__ */ new Map();
+	for (const { name, version } of installedFramework) if (version) kuckitVersions.set(name, version);
+	const uniqueVersions = new Set(kuckitVersions.values());
+	if (uniqueVersions.size > 1 && installedFramework.length >= 2) {
+		const versionParts = [...uniqueVersions].map((v) => {
+			const match = v.match(/^(\d+)\.(\d+)/);
+			return match ? `${match[1]}.${match[2]}` : v;
+		});
+		if (new Set(versionParts).size > 1) checks.push({
+			name: "version-compatibility",
+			status: "warn",
+			message: "Framework packages have mismatched versions",
+			details: [...kuckitVersions.entries()].map(([name, ver]) => `  - ${name}: ${ver}`)
+		});
+		else checks.push({
+			name: "version-compatibility",
+			status: "pass",
+			message: "Framework package versions are compatible"
+		});
+	} else if (installedFramework.length >= 2) checks.push({
+		name: "version-compatibility",
+		status: "pass",
+		message: "Framework package versions are compatible"
+	});
+	const localImportIssues = [];
+	for (const packageName of installedPackages) {
+		const packagePath = findPackagePath(packageName, cwd);
+		if (!packagePath) continue;
+		const srcPath = join(packagePath, "src");
+		if (!existsSync(srcPath)) continue;
+		try {
+			const files = scanSourceFiles(srcPath);
+			for (const file of files) if (readFileSync(file, "utf-8").match(/from\s+['"]@(?!kuckit\/)[^'"/]+\/(api|db|auth|domain|contracts)['"]/g)) {
+				const relPath = file.replace(cwd, ".");
+				localImportIssues.push(`${packageName}: ${relPath} imports from local package instead of @kuckit/*`);
+			}
+		} catch {}
+	}
+	if (localImportIssues.length > 0) checks.push({
+		name: "framework-imports",
+		status: "warn",
+		message: `${localImportIssues.length} module(s) import from local packages instead of @kuckit/*`,
+		details: localImportIssues.slice(0, 5).map((i) => `  - ${i}`)
+	});
+	else if (installedPackages.length > 0) checks.push({
+		name: "framework-imports",
 		status: "pass",
-		message: "SDK packages installed"
+		message: "Module imports use @kuckit/* framework packages"
 	});
 	const serverModulesPath = join(cwd, "apps", "server", "src", "config", "modules.ts");
 	const clientModulesPath = join(cwd, "apps", "web", "src", "modules.client.ts");
@@ -384,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;
@@ -394,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;
@@ -410,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 {}
@@ -426,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;
@@ -444,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
@@ -453,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);
@@ -512,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);
@@ -557,10 +636,10 @@ async function dbStudio(options) {
 
 //#endregion
 //#region src/lib/credentials.ts
-const DEFAULT_SERVER_URL = "https://dev-app-nyh7i73bea-uc.a.run.app/";
+const DEFAULT_SERVER_URL = "https://api.kuckit.dev";
 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");
@@ -569,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
@@ -613,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");
@@ -678,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,
@@ -711,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.");
@@ -744,7 +823,7 @@ async function authWhoami(options) {
 	}
 }
 async function authLogout() {
-	if (!loadConfig$8()?.cliToken) {
+	if (!loadConfig$7()?.cliToken) {
 		console.log("Already logged out.");
 		return;
 	}
@@ -771,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);
@@ -782,6 +861,732 @@ function requireAuth() {
 	}
 }
 
+//#endregion
+//#region src/lib/package-manager.ts
+/**
+* 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 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";
+}
+/**
+* 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
+*/
+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";
+/**
+* Default provider packages by provider ID
+*/
+const DEFAULT_PROVIDER_PACKAGES = {
+	gcp: "@kuckit/infra-gcp",
+	aws: "@kuckit/infra-aws",
+	azure: "@kuckit/infra-azure"
+};
+/**
+* Load the stored infrastructure config from .kuckit/infra.json
+*/
+async function loadStoredConfig(projectRoot) {
+	const configPath = join$1(projectRoot, KUCKIT_DIR$7, CONFIG_FILE$7);
+	try {
+		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 null;
+	}
+}
+/**
+* Save infrastructure config to .kuckit/infra.json
+*/
+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");
+}
+/**
+* Error thrown when provider package is not installed
+*/
+var ProviderNotInstalledError = class extends Error {
+	constructor(packageName, installCommand) {
+		super(`Provider package '${packageName}' is not installed.`);
+		this.packageName = packageName;
+		this.installCommand = installCommand;
+		this.name = "ProviderNotInstalledError";
+	}
+};
+/**
+* Error thrown when provider package is invalid
+*/
+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";
+	}
+};
+/**
+* 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 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 provider package name for a given provider ID
+*/
+function getProviderPackage(providerId) {
+	return DEFAULT_PROVIDER_PACKAGES[providerId] ?? `@kuckit/infra-${providerId}`;
+}
+/**
+* Check if a provider package is available
+*/
+async function isProviderAvailable(providerId) {
+	const packageName = getProviderPackage(providerId);
+	try {
+		await import(packageName);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* List available provider packages
+*/
+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 {
+		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;
+}
+/**
+* Check if legacy packages/infra directory exists
+*/
+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}`);
+		}
+		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
 /**
@@ -1003,31 +1808,6 @@ function runGcloud(args, options = {}) {
 	});
 }
 /**
-* Build and push Docker image using Cloud Build
-* No local Docker daemon required!
-*/
-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
-	};
-}
-/**
 * Get the path to the packages/infra directory
 */
 function getInfraDir(projectRoot) {
@@ -1275,359 +2055,6 @@ function formatError(error) {
 	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}`);
-	}
-	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
-*/
-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;
-	}
-}
-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 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;
-	}
-}
-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 (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.");
-	}
-}
-
 //#endregion
 //#region src/commands/infra/destroy.ts
 const KUCKIT_DIR$6 = ".kuckit";
@@ -2594,6 +3021,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);
@@ -2602,6 +3033,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);
@@ -2637,4 +3072,5 @@ infra.command("outputs").description("Display infrastructure outputs (URLs, conn
 program.parse();
 
 //#endregion
-export {  };
+export {  };
+//# sourceMappingURL=bin.js.map