@kuckit/cli 2.0.0 → 2.0.2

package/dist/bin.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
-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 { a as isLegacyConfig, c as loadTryLoadKuckitConfig, i as isGcpConfig, l as addModule, o as migrateLegacyConfig, s as discoverModules, u as generateModule } from "./provider-Cx1wuAN4.js";
 import { program } from "commander";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { spawn } from "child_process";
+import { spawn as spawn$1 } 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";
+import { confirm, input, select } from "@inquirer/prompts";
 
 //#region src/commands/doctor.ts
-const CONFIG_FILES = [
+const CONFIG_FILES$1 = [
 	"kuckit.config.ts",
 	"kuckit.config.js",
 	"kuckit.config.mjs"
@@ -25,10 +26,10 @@ const FRAMEWORK_PACKAGES = [
 	"@kuckit/domain",
 	"@kuckit/contracts"
 ];
-function findConfigFile(cwd) {
+function findConfigFile$1(cwd) {
 	let dir = cwd;
 	while (dir !== dirname(dir)) {
-		for (const file of CONFIG_FILES) {
+		for (const file of CONFIG_FILES$1) {
 			const configPath = join(dir, file);
 			if (existsSync(configPath)) return configPath;
 		}
@@ -42,7 +43,7 @@ function readPackageJson(packageName, cwd) {
 		join(cwd, "apps", "server", "node_modules", packageName, "package.json"),
 		join(cwd, "apps", "web", "node_modules", packageName, "package.json")
 	];
-	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] ?? packageName : packageName;
 	locations.push(join(cwd, "packages", packageDir, "package.json"));
 	for (const location of locations) try {
 		const content = readFileSync(location, "utf-8");
@@ -57,7 +58,7 @@ function findPackagePath(packageName, cwd) {
 		join(cwd, "apps", "server", "node_modules", packageName),
 		join(cwd, "apps", "web", "node_modules", packageName)
 	];
-	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+	const packageDir = packageName.startsWith("@") ? packageName.split("/")[1] ?? packageName : packageName;
 	locations.push(join(cwd, "packages", packageDir));
 	for (const location of locations) if (existsSync(location)) {
 		const pkgJsonPath = join(location, "package.json");
@@ -127,7 +128,7 @@ async function doctor(options) {
 	const cwd = process.cwd();
 	const checks = [];
 	if (!options.json) console.log("\nKuckit Doctor - Checking your setup...\n");
-	const configPath = findConfigFile(cwd);
+	const configPath = findConfigFile$1(cwd);
 	if (configPath) checks.push({
 		name: "config-exists",
 		status: "pass",
@@ -315,11 +316,17 @@ async function doctor(options) {
 		let match;
 		while ((match = serverModulePattern.exec(serverContent)) !== null) {
 			const lineStart = serverContent.lastIndexOf("\n", match.index) + 1;
-			if (!serverContent.slice(lineStart, match.index).includes("//")) serverModules.add(match[1]);
+			if (!serverContent.slice(lineStart, match.index).includes("//")) {
+				const matchedModule = match[1];
+				if (matchedModule) serverModules.add(matchedModule);
+			}
 		}
 		while ((match = clientModulePattern.exec(clientContent)) !== null) {
 			const lineStart = clientContent.lastIndexOf("\n", match.index) + 1;
-			if (!clientContent.slice(lineStart, match.index).includes("//")) clientModules.add(match[1]);
+			if (!clientContent.slice(lineStart, match.index).includes("//")) {
+				const matchedModule = match[1];
+				if (matchedModule) clientModules.add(matchedModule);
+			}
 		}
 		const clientOnly = [...clientModules].filter((m) => !serverModules.has(m));
 		const serverOnly = [...serverModules].filter((m) => !clientModules.has(m));
@@ -448,7 +455,7 @@ async function search(keyword, options) {
 		}
 		console.log(`\n${results.length} package${results.length === 1 ? "" : "s"} found`);
 		if (results.some((r) => !r.isKuckitModule)) console.log("\n[?] = May not be a Kuckit module (verify before installing)");
-		if (results.length > 0) console.log(`\nInstall: kuckit add ${results[0].name}`);
+		if (results.length > 0 && results[0]) console.log(`\nInstall: kuckit add ${results[0].name}`);
 	} catch (error) {
 		if (options.json) console.log(JSON.stringify({
 			error: error instanceof Error ? error.message : "Unknown error",
@@ -491,7 +498,7 @@ async function getDatabaseUrl(cwd, options) {
 	];
 	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, "");
+		if (match?.[1]) return match[1].replace(/^["']|["']$/g, "");
 	} catch {}
 	return null;
 }
@@ -557,8 +564,8 @@ export default defineConfig({
 	return configPath;
 }
 function runDrizzleKit(command, configPath, cwd) {
-	return new Promise((resolve) => {
-		const proc = spawn("npx", ["drizzle-kit", ...[
+	return new Promise((resolve$1) => {
+		const proc = spawn$1("npx", ["drizzle-kit", ...[
 			command,
 			"--config",
 			configPath
@@ -582,7 +589,7 @@ function runDrizzleKit(command, configPath, cwd) {
 			process.stderr.write(data);
 		});
 		proc.on("close", (code) => {
-			resolve({
+			resolve$1({
 				code: code ?? 1,
 				stdout,
 				stderr
@@ -636,7 +643,7 @@ async function dbStudio(options) {
 
 //#endregion
 //#region src/lib/credentials.ts
-const DEFAULT_SERVER_URL = "https://api.kuckit.dev";
+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$7() {
@@ -680,7 +687,7 @@ async function openBrowser(url) {
 	}
 }
 function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
 }
 function formatExpiryDate(expiresAt) {
 	return new Date(expiresAt).toLocaleDateString("en-US", {
@@ -861,6 +868,32 @@ function requireAuth() {
 	}
 }
 
+//#endregion
+//#region src/commands/server-utils.ts
+const CONFIG_FILES = [
+	"kuckit.config.ts",
+	"kuckit.config.js",
+	"kuckit.config.mjs"
+];
+/**
+* Find the config file path by searching from cwd upward
+*/
+function findConfigFile(cwd = process.cwd()) {
+	let dir = cwd;
+	while (dir !== dirname(dir)) {
+		for (const file of CONFIG_FILES) {
+			const configPath = resolve(dir, file);
+			if (existsSync(configPath)) return configPath;
+		}
+		dir = dirname(dir);
+	}
+	for (const file of CONFIG_FILES) {
+		const configPath = resolve(dir, file);
+		if (existsSync(configPath)) return configPath;
+	}
+	return null;
+}
+
 //#endregion
 //#region src/lib/package-manager.ts
 /**
@@ -901,11 +934,238 @@ function getInstallCommand(pm, packageName, options = {}) {
 	}
 }
 
+//#endregion
+//#region src/commands/dev.ts
+/**
+* Start the development server
+*/
+async function dev(options) {
+	const cwd = process.cwd();
+	const configPath = options.config ? resolve(cwd, options.config) : findConfigFile(cwd);
+	if (!configPath) {
+		console.error("Error: No kuckit.config.ts found.");
+		console.error("Create one at your project root or specify with --config");
+		process.exit(1);
+	}
+	const projectRoot = dirname(configPath);
+	const pm = detectPackageManager(projectRoot);
+	console.log(`[kuckit] Using config: ${configPath}`);
+	console.log(`[kuckit] Starting development server...`);
+	const env = {
+		...process.env,
+		KUCKIT_CONFIG_PATH: configPath,
+		NODE_ENV: "development"
+	};
+	if (options.port) env.PORT = options.port;
+	const serverEntry = await findServerEntry(projectRoot);
+	if (serverEntry) {
+		const args = getRunArgs(pm, serverEntry);
+		const command = args[0];
+		if (!command) {
+			console.error("Error: Could not determine run command.");
+			process.exit(1);
+		}
+		const child = spawn(command, args.slice(1), {
+			cwd: projectRoot,
+			env,
+			stdio: "inherit"
+		});
+		child.on("error", (error) => {
+			console.error("Failed to start dev server:", error);
+			process.exit(1);
+		});
+		child.on("exit", (code) => {
+			process.exit(code ?? 0);
+		});
+	} else {
+		console.error("Error: Could not find server entry point.");
+		console.error("Expected: apps/server/src/server.ts or src/server.ts");
+		process.exit(1);
+	}
+}
+/**
+* Find the server entry point
+*/
+async function findServerEntry(projectRoot) {
+	const { existsSync: existsSync$1 } = await import("node:fs");
+	for (const candidate of [
+		"apps/server/src/server.ts",
+		"server/src/server.ts",
+		"src/server.ts",
+		"server.ts"
+	]) if (existsSync$1(resolve(projectRoot, candidate))) return candidate;
+	return null;
+}
+/**
+* Get run command arguments based on package manager
+*/
+function getRunArgs(pm, entry) {
+	switch (pm) {
+		case "bun": return [
+			"bun",
+			"--watch",
+			entry
+		];
+		default: return [
+			"npx",
+			"tsx",
+			"watch",
+			entry
+		];
+	}
+}
+
+//#endregion
+//#region src/commands/build.ts
+/**
+* Build the production bundle
+*/
+async function build(options) {
+	const cwd = process.cwd();
+	const configPath = options.config ? resolve(cwd, options.config) : findConfigFile(cwd);
+	if (!configPath) {
+		console.error("Error: No kuckit.config.ts found.");
+		console.error("Create one at your project root or specify with --config");
+		process.exit(1);
+	}
+	const projectRoot = dirname(configPath);
+	const pm = detectPackageManager(projectRoot);
+	const outDir = options.outDir || "dist";
+	console.log(`[kuckit] Using config: ${configPath}`);
+	console.log(`[kuckit] Building for production...`);
+	const args = getBuildArgs(pm);
+	const command = args[0];
+	if (!command) {
+		console.error("Error: Could not determine build command.");
+		process.exit(1);
+	}
+	const child = spawn(command, args.slice(1), {
+		cwd: projectRoot,
+		env: {
+			...process.env,
+			KUCKIT_CONFIG_PATH: configPath,
+			NODE_ENV: "production",
+			BUILD_OUT_DIR: outDir
+		},
+		stdio: "inherit"
+	});
+	child.on("error", (error) => {
+		console.error("Failed to run build:", error);
+		process.exit(1);
+	});
+	child.on("exit", (code) => {
+		if (code === 0) console.log(`[kuckit] Build complete. Output: ${outDir}/`);
+		process.exit(code ?? 0);
+	});
+}
+/**
+* Get build command arguments based on package manager
+*/
+function getBuildArgs(pm) {
+	switch (pm) {
+		case "bun": return [
+			"bun",
+			"run",
+			"build"
+		];
+		case "pnpm": return [
+			"pnpm",
+			"run",
+			"build"
+		];
+		case "yarn": return ["yarn", "build"];
+		default: return [
+			"npm",
+			"run",
+			"build"
+		];
+	}
+}
+
+//#endregion
+//#region src/commands/start.ts
+/**
+* Start the production server
+*/
+async function start(options) {
+	const cwd = process.cwd();
+	const configPath = options.config ? resolve(cwd, options.config) : findConfigFile(cwd);
+	if (!configPath) {
+		console.error("Error: No kuckit.config.ts found.");
+		console.error("Create one at your project root or specify with --config");
+		process.exit(1);
+	}
+	const projectRoot = dirname(configPath);
+	const pm = detectPackageManager(projectRoot);
+	console.log(`[kuckit] Using config: ${configPath}`);
+	console.log(`[kuckit] Starting production server...`);
+	const env = {
+		...process.env,
+		KUCKIT_CONFIG_PATH: configPath,
+		NODE_ENV: "production"
+	};
+	if (options.port) env.PORT = options.port;
+	const serverEntry = await findBuiltServerEntry(projectRoot);
+	if (serverEntry) {
+		const args = getStartArgs(pm, serverEntry);
+		const command = args[0];
+		if (!command) {
+			console.error("Error: Could not determine start command.");
+			process.exit(1);
+		}
+		const child = spawn(command, args.slice(1), {
+			cwd: projectRoot,
+			env,
+			stdio: "inherit"
+		});
+		child.on("error", (error) => {
+			console.error("Failed to start production server:", error);
+			process.exit(1);
+		});
+		child.on("exit", (code) => {
+			process.exit(code ?? 0);
+		});
+	} else {
+		console.error("Error: Could not find built server entry point.");
+		console.error("Run `kuckit build` first, then `kuckit start`");
+		console.error("Expected: dist/server.js or apps/server/dist/server.js");
+		process.exit(1);
+	}
+}
+/**
+* Find the built server entry point
+*/
+async function findBuiltServerEntry(projectRoot) {
+	for (const candidate of [
+		"dist/server.js",
+		"apps/server/dist/server.js",
+		"server/dist/server.js",
+		"build/server.js"
+	]) if (existsSync(resolve(projectRoot, candidate))) return candidate;
+	return null;
+}
+/**
+* Get start command arguments based on package manager
+*/
+function getStartArgs(pm, entry) {
+	switch (pm) {
+		case "bun": return ["bun", entry];
+		default: return ["node", entry];
+	}
+}
+
 //#endregion
 //#region src/commands/infra/provider-loader.ts
 const KUCKIT_DIR$7 = ".kuckit";
 const CONFIG_FILE$7 = "infra.json";
 /**
+* Get the config file name for a specific environment
+* Returns 'infra.{env}.json' for per-env configs
+*/
+function getEnvConfigFile(env) {
+	return `infra.${env}.json`;
+}
+/**
 * Default provider packages by provider ID
 */
 const DEFAULT_PROVIDER_PACKAGES = {
@@ -914,10 +1174,28 @@ const DEFAULT_PROVIDER_PACKAGES = {
 	azure: "@kuckit/infra-azure"
 };
 /**
-* Load the stored infrastructure config from .kuckit/infra.json
+* Load the stored infrastructure config
+*
+* Priority:
+* 1. If env is specified, try .kuckit/infra.{env}.json first
+* 2. Fall back to .kuckit/infra.json (legacy single-file format)
+*
+* @param projectRoot - Project root directory
+* @param env - Optional environment to load config for
 */
-async function loadStoredConfig(projectRoot) {
-	const configPath = join$1(projectRoot, KUCKIT_DIR$7, CONFIG_FILE$7);
+async function loadStoredConfig(projectRoot, env) {
+	const kuckitDir = join$1(projectRoot, KUCKIT_DIR$7);
+	if (env) {
+		const envConfigPath = join$1(kuckitDir, getEnvConfigFile(env));
+		try {
+			await access(envConfigPath, constants$1.F_OK);
+			const content = await readFile(envConfigPath, "utf-8");
+			const parsed = JSON.parse(content);
+			if (isLegacyConfig(parsed)) return migrateLegacyConfig(parsed);
+			return parsed;
+		} catch {}
+	}
+	const configPath = join$1(kuckitDir, CONFIG_FILE$7);
 	try {
 		await access(configPath, constants$1.F_OK);
 		const content = await readFile(configPath, "utf-8");
@@ -929,13 +1207,16 @@ async function loadStoredConfig(projectRoot) {
 	}
 }
 /**
-* Save infrastructure config to .kuckit/infra.json
+* Save infrastructure config to per-environment file
+*
+* Saves to .kuckit/infra.{env}.json based on the config's env field
+* Falls back to .kuckit/infra.json if no env is set
 */
 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);
+	const configPath = join$1(kuckitDir, config.env ? getEnvConfigFile(config.env) : CONFIG_FILE$7);
 	config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 	await writeFile$1(configPath, JSON.stringify(config, null, 2), "utf-8");
 }
@@ -989,6 +1270,18 @@ function getProviderPackage(providerId) {
 	return DEFAULT_PROVIDER_PACKAGES[providerId] ?? `@kuckit/infra-${providerId}`;
 }
 /**
+* Compute the Pulumi stack name for a given config and environment.
+* Stack names follow the pattern: {gcpProject}-{env}
+*
+* @param config - The stored infrastructure config
+* @param env - The target environment (dev, staging, prod)
+* @returns The computed stack name
+*/
+function computeStackName(config, env) {
+	if (config.provider === "gcp" && "gcpProject" in config.providerConfig) return `${config.providerConfig.gcpProject}-${env}`;
+	return config.stackName;
+}
+/**
 * Check if a provider package is available
 */
 async function isProviderAvailable(providerId) {
@@ -1052,7 +1345,7 @@ async function infraInit(options) {
 		console.log("See docs/MIGRATION.md for details.");
 		console.log("");
 	}
-	const existingConfig = await loadStoredConfig(projectRoot);
+	const existingConfig = await loadStoredConfig(projectRoot, options.env);
 	let providerId = options.provider ?? existingConfig?.provider ?? "gcp";
 	if (!options.provider && !existingConfig) {
 		const installedProviders = (await listAvailableProviders()).filter((p) => p.available);
@@ -1265,7 +1558,7 @@ async function infraDeploy(options) {
 		console.error("Error: Could not find project root (no package.json found)");
 		process.exit(1);
 	}
-	const config = await loadStoredConfig(projectRoot);
+	const config = await loadStoredConfig(projectRoot, options.env);
 	if (!config) {
 		console.error("Error: No infrastructure configuration found.");
 		console.error("Run: kuckit infra init");
@@ -1375,6 +1668,20 @@ async function infraDeploy(options) {
 			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}`);
@@ -1412,7 +1719,7 @@ async function infraUp(options) {
 		console.error("Error: Could not find project root (no package.json found)");
 		process.exit(1);
 	}
-	const existingConfig = await loadStoredConfig(projectRoot);
+	const existingConfig = await loadStoredConfig(projectRoot, options.env);
 	if (!existingConfig) {
 		const providerPackage = getProviderPackage(options.provider ?? "gcp");
 		let providerLabel = "cloud";
@@ -1446,7 +1753,7 @@ async function infraUp(options) {
 			env: options.env,
 			yes: options.yes
 		});
-		if (!await loadStoredConfig(projectRoot)) {
+		if (!await loadStoredConfig(projectRoot, options.env)) {
 			console.error("Error: Initialization completed but no configuration found.");
 			process.exit(1);
 		}
@@ -1593,8 +1900,8 @@ async function infraEject(options) {
 * Run a Pulumi CLI command
 */
 function runPulumi(args, options) {
-	return new Promise((resolve) => {
-		const proc = spawn("pulumi", args, {
+	return new Promise((resolve$1) => {
+		const proc = spawn$1("pulumi", args, {
 			cwd: options.cwd,
 			stdio: options.stream ? [
 				"inherit",
@@ -1625,7 +1932,7 @@ function runPulumi(args, options) {
 			if (options.stream) process.stderr.write(data);
 		});
 		proc.on("close", (code) => {
-			resolve({
+			resolve$1({
 				code: code ?? 1,
 				stdout,
 				stderr
@@ -1772,8 +2079,8 @@ async function pulumiStackExport(filePath, options) {
 * Run a gcloud CLI command
 */
 function runGcloud(args, options = {}) {
-	return new Promise((resolve) => {
-		const proc = spawn("gcloud", args, {
+	return new Promise((resolve$1) => {
+		const proc = spawn$1("gcloud", args, {
 			cwd: options.cwd ?? process.cwd(),
 			stdio: options.stream ? [
 				"inherit",
@@ -1799,7 +2106,7 @@ function runGcloud(args, options = {}) {
 			if (options.stream) process.stderr.write(data);
 		});
 		proc.on("close", (code) => {
-			resolve({
+			resolve$1({
 				code: code ?? 1,
 				stdout,
 				stderr
@@ -1810,7 +2117,7 @@ function runGcloud(args, options = {}) {
 /**
 * Get the path to the packages/infra directory
 */
-function getInfraDir(projectRoot) {
+function getInfraDir$1(projectRoot) {
 	return join$1(projectRoot, "packages", "infra");
 }
 /**
@@ -1908,7 +2215,7 @@ function extractServiceNameFromUrl(url) {
 	try {
 		const hostname = new URL(url).hostname;
 		const match = hostname.match(/^([^-]+(?:-[^-]+)*?)-[a-z0-9]+-[a-z]+\.a\.run\.app$/);
-		if (match) return match[1];
+		if (match) return match[1] ?? null;
 		const parts = hostname.split("-");
 		if (parts.length >= 3) return parts.slice(0, -2).join("-");
 		return null;
@@ -2110,16 +2417,18 @@ async function infraDestroy(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
-	const infraDir = getInfraDir(projectRoot);
+	const stackName = computeStackName(config, env);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$6(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
 	}
+	const projectDisplay = isGcpConfig(config) ? config.providerConfig.gcpProject : config.projectName;
 	console.log("Configuration:");
-	console.log(`  Project: ${config.gcpProject}`);
+	console.log(`  Project: ${projectDisplay}`);
 	console.log(`  Region: ${config.region}`);
 	console.log(`  Environment: ${env}`);
-	console.log(`  Stack: ${config.stackName}`);
+	console.log(`  Stack: ${stackName}`);
 	console.log("");
 	if (isAppOnly) {
 		console.log("WARNING: This will destroy the Cloud Run service.");
@@ -2157,7 +2466,6 @@ async function infraDestroy(options) {
 			}
 		}
 	}
-	const stackName = config.stackName;
 	console.log(`\nSelecting Pulumi stack: ${stackName}`);
 	if (!await selectOrCreateStack(stackName, { cwd: infraDir })) {
 		console.error("Error: Failed to select Pulumi stack");
@@ -2263,14 +2571,15 @@ async function infraRepair(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
-	const infraDir = getInfraDir(projectRoot);
+	const stackName = computeStackName(config, env);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$5(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
 	}
 	const runCancel = options.cancel || !options.cancel && !options.refresh;
 	const runRefresh = options.refresh || !options.cancel && !options.refresh;
-	console.log(`Repairing stack: ${config.stackName}`);
+	console.log(`Repairing stack: ${stackName}`);
 	console.log(`  Environment: ${env}`);
 	console.log(`  Operations: ${[runCancel && "cancel", runRefresh && "refresh"].filter(Boolean).join(", ")}`);
 	console.log("");
@@ -2283,8 +2592,8 @@ async function infraRepair(options) {
 			process.exit(0);
 		}
 	}
-	console.log(`Selecting Pulumi stack: ${config.stackName}`);
-	if (!await selectOrCreateStack(config.stackName, { cwd: infraDir })) {
+	console.log(`Selecting Pulumi stack: ${stackName}`);
+	if (!await selectOrCreateStack(stackName, { cwd: infraDir })) {
 		console.error("Error: Failed to select Pulumi stack");
 		process.exit(1);
 	}
@@ -2370,6 +2679,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'.`);
@@ -2384,6 +2699,7 @@ async function getJobContext(options) {
 	}
 	return {
 		config,
+		gcpProject,
 		projectRoot,
 		env,
 		jobName
@@ -2460,18 +2776,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);
@@ -2491,17 +2807,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);
@@ -2595,12 +2911,17 @@ async function infraRollback(options) {
 		console.error("Error: Could not determine service name from URL:", serviceUrl);
 		process.exit(1);
 	}
+	if (!isGcpConfig(config)) {
+		console.error("Error: Rollback command is only supported for GCP deployments.");
+		process.exit(1);
+	}
+	const gcpProject = config.providerConfig.gcpProject;
 	console.log(`Service: ${serviceName}`);
-	console.log(`Project: ${config.gcpProject}`);
+	console.log(`Project: ${gcpProject}`);
 	console.log(`Region: ${config.region}`);
 	console.log("");
 	console.log("Fetching revisions...");
-	const revisions = await listCloudRunRevisions(serviceName, config.gcpProject, config.region);
+	const revisions = await listCloudRunRevisions(serviceName, gcpProject, config.region);
 	if (revisions.length === 0) {
 		console.error("Error: No revisions found for service:", serviceName);
 		process.exit(1);
@@ -2647,7 +2968,7 @@ async function infraRollback(options) {
 		process.exit(0);
 	}
 	console.log(`Rolling back to ${targetRevision}...`);
-	const result = await updateCloudRunTraffic(serviceName, targetRevision, config.gcpProject, config.region);
+	const result = await updateCloudRunTraffic(serviceName, targetRevision, gcpProject, config.region);
 	if (result.code !== 0) {
 		console.error("\nError: Failed to update traffic routing");
 		console.error(result.stderr);
@@ -2687,12 +3008,12 @@ async function loadConfig$2(projectRoot) {
 	}
 }
 function runGcloudStreaming(args) {
-	return new Promise((resolve) => {
-		spawn("gcloud", args, {
+	return new Promise((resolve$1) => {
+		spawn$1("gcloud", args, {
 			stdio: "inherit",
 			shell: true
 		}).on("close", (code) => {
-			resolve(code ?? 1);
+			resolve$1(code ?? 1);
 		});
 	});
 }
@@ -2731,8 +3052,13 @@ async function infraLogs(options) {
 		process.exit(1);
 	}
 	const since = options.since ?? "1h";
+	if (!isGcpConfig(config)) {
+		console.error("Error: Logs command is only supported for GCP deployments.");
+		process.exit(1);
+	}
+	const gcpProject = config.providerConfig.gcpProject;
 	console.log(`Fetching logs for service: ${serviceName}`);
-	console.log(`  Project: ${config.gcpProject}`);
+	console.log(`  Project: ${gcpProject}`);
 	console.log(`  Region: ${config.region}`);
 	if (options.follow) console.log("  Mode: Following (Ctrl+C to stop)");
 	else console.log(`  Since: ${since}`);
@@ -2746,7 +3072,7 @@ async function infraLogs(options) {
 	if (options.follow) args.push("tail");
 	else args.push("read");
 	args.push(serviceName);
-	args.push("--project", config.gcpProject);
+	args.push("--project", gcpProject);
 	args.push("--region", config.region);
 	if (!options.follow) {
 		args.push("--limit", "100");
@@ -2823,9 +3149,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 = computeStackName(config, options.env ?? config.env);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$1(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -2935,8 +3260,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 = computeStackName(config, env);
+	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists(infraDir)) {
 		console.error("Error: packages/infra not found.");
 		process.exit(1);
@@ -2982,9 +3307,226 @@ 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, env) {
+	const config = await loadStoredConfig(projectRoot, env);
+	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 env = options.env;
+	const config = await ensureConfigExists(projectRoot, env);
+	const resolvedEnv = 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, resolvedEnv, key, value);
+	console.log(`✓ Set ${key}=${value} for env '${resolvedEnv}'`);
+	if (key === "appUrl") console.log(`\nNote: Run 'kuckit infra deploy --env ${resolvedEnv}' to apply this change.`);
+}
+/**
+* Get a configuration value
+*/
+async function infraConfigGet(key, options = {}) {
+	const projectRoot = getProjectRoot();
+	const env = options.env;
+	const config = await ensureConfigExists(projectRoot, env);
+	const resolvedEnv = 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, resolvedEnv, key);
+	if (value !== null) console.log(value);
+	else {
+		console.error(`Config key '${key}' is not set for env '${resolvedEnv}'.`);
+		process.exit(1);
+	}
+}
+/**
+* List all configuration values
+*/
+async function infraConfigList(options = {}) {
+	const projectRoot = getProjectRoot();
+	const env = options.env;
+	const config = await ensureConfigExists(projectRoot, env);
+	const resolvedEnv = 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, resolvedEnv);
+	const allConfig = {
+		...localConfig,
+		...pulumiConfig
+	};
+	if (options.json) {
+		console.log(JSON.stringify({
+			env: resolvedEnv,
+			config: allConfig
+		}, null, 2));
+		return;
+	}
+	console.log(`\nInfrastructure Configuration (env: ${resolvedEnv})\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 '${resolvedEnv}' 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 '${resolvedEnv}' 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 env = options.env;
+	const config = await ensureConfigExists(projectRoot, env);
+	const resolvedEnv = env ?? config.env ?? "dev";
+	if ([
+		"provider",
+		"region",
+		"projectName"
+	].includes(key)) throw new Error(`Cannot unset required key '${key}'.`);
+	await unsetPulumiConfig(projectRoot, config, resolvedEnv, key);
+	console.log(`✓ Unset ${key} for env '${resolvedEnv}'`);
+}
+
 //#endregion
 //#region src/bin.ts
 program.name("kuckit").description("CLI tools for Kuckit SDK module development").version("0.1.0");
+program.command("dev").description("Start the development server with hot reload").option("-c, --config <path>", "Path to kuckit.config.ts").option("-p, --port <port>", "Port to run the server on").action(async (options) => {
+	await dev(options);
+});
+program.command("build").description("Build the application for production").option("-c, --config <path>", "Path to kuckit.config.ts").option("-o, --out-dir <dir>", "Output directory", "dist").action(async (options) => {
+	await build(options);
+});
+program.command("start").description("Start the production server").option("-c, --config <path>", "Path to kuckit.config.ts").option("-p, --port <port>", "Port to run the server on").action(async (options) => {
+	await start(options);
+});
 program.command("generate").description("Generate Kuckit resources").command("module <name>").description("Generate a new Kuckit module").option("-o, --org <org>", "Organization scope for package name", "").option("-d, --dir <directory>", "Target directory", "packages").action(async (name, options) => {
 	requireAuth();
 	await generateModule(name, options);
@@ -3069,6 +3611,23 @@ 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