@kuckit/cli 2.0.1 → 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
@@ -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");
@@ -1426,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";
@@ -1460,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);
 		}
@@ -1607,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",
@@ -1639,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
@@ -1786,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",
@@ -1813,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
@@ -1922,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;
@@ -2124,16 +2417,18 @@ async function infraDestroy(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
+	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.");
@@ -2171,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");
@@ -2277,6 +2571,7 @@ async function infraRepair(options) {
 		console.error(`Error: Invalid environment '${env}'. Must be 'dev' or 'prod'.`);
 		process.exit(1);
 	}
+	const stackName = computeStackName(config, env);
 	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists$5(infraDir)) {
 		console.error("Error: packages/infra not found.");
@@ -2284,7 +2579,7 @@ async function infraRepair(options) {
 	}
 	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("");
@@ -2297,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);
 	}
@@ -2616,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);
@@ -2668,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);
@@ -2708,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);
 		});
 	});
 }
@@ -2752,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}`);
@@ -2767,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");
@@ -2844,7 +3149,7 @@ async function infraStatus(options) {
 		console.error("Run: kuckit infra init");
 		process.exit(1);
 	}
-	const stackName = config.stackName;
+	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.");
@@ -2955,7 +3260,7 @@ async function infraOutputs(options) {
 		process.exit(1);
 	}
 	const env = options.env ?? config.env ?? "dev";
-	const stackName = config.stackName;
+	const stackName = computeStackName(config, env);
 	const infraDir = getInfraDir$1(projectRoot);
 	if (!await fileExists(infraDir)) {
 		console.error("Error: packages/infra not found.");
@@ -3024,8 +3329,8 @@ const KNOWN_CONFIG_KEYS = {
 function getProjectRoot() {
 	return process.cwd();
 }
-async function ensureConfigExists(projectRoot) {
-	const config = await loadStoredConfig(projectRoot);
+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;
 }
@@ -3099,8 +3404,9 @@ async function unsetPulumiConfig(projectRoot, config, env, key) {
 */
 async function infraConfigSet(key, value, options = {}) {
 	const projectRoot = getProjectRoot();
-	const config = await ensureConfigExists(projectRoot);
-	const env = options.env ?? config.env ?? "dev";
+	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;
@@ -3117,17 +3423,18 @@ async function infraConfigSet(key, value, options = {}) {
 			return;
 		}
 	}
-	await syncToPulumi(projectRoot, config, env, key, value);
-	console.log(`✓ Set ${key}=${value} for env '${env}'`);
-	if (key === "appUrl") console.log(`\nNote: Run 'kuckit infra deploy --env ${env}' to apply this change.`);
+	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 config = await ensureConfigExists(projectRoot);
-	const env = options.env ?? config.env ?? "dev";
+	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,
@@ -3144,10 +3451,10 @@ async function infraConfigGet(key, options = {}) {
 			}
 		}
 	}
-	const value = await getPulumiConfigValue(projectRoot, config, env, key);
+	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 '${env}'.`);
+		console.error(`Config key '${key}' is not set for env '${resolvedEnv}'.`);
 		process.exit(1);
 	}
 }
@@ -3156,36 +3463,37 @@ async function infraConfigGet(key, options = {}) {
 */
 async function infraConfigList(options = {}) {
 	const projectRoot = getProjectRoot();
-	const config = await ensureConfigExists(projectRoot);
-	const env = options.env ?? config.env ?? "dev";
+	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, env);
+	const pulumiConfig = await getAllPulumiConfig(projectRoot, config, resolvedEnv);
 	const allConfig = {
 		...localConfig,
 		...pulumiConfig
 	};
 	if (options.json) {
 		console.log(JSON.stringify({
-			env,
+			env: resolvedEnv,
 			config: allConfig
 		}, null, 2));
 		return;
 	}
-	console.log(`\nInfrastructure Configuration (env: ${env})\n`);
+	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 '${env}' Config:`);
+		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 '${env}' Config: (none set)`);
+	} 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)`);
@@ -3195,20 +3503,30 @@ async function infraConfigList(options = {}) {
 */
 async function infraConfigUnset(key, options = {}) {
 	const projectRoot = getProjectRoot();
-	const config = await ensureConfigExists(projectRoot);
-	const env = options.env ?? config.env ?? "dev";
+	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, env, key);
-	console.log(`✓ Unset ${key} for env '${env}'`);
+	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);