@geekmidas/cli 0.45.0 → 0.47.0

package/dist/index.cjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env -S npx tsx
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_workspace = require('./workspace-BDAhr6Kb.cjs');
-const require_config = require('./config-xVZsRjN7.cjs');
-const require_openapi = require('./openapi-DhcCtKzM.cjs');
+const require_workspace = require('./workspace-CaVW6j2q.cjs');
+const require_config = require('./config-HYiM3iQJ.cjs');
+const require_openapi = require('./openapi-D7WwlpPF.cjs');
 const require_storage = require('./storage-BPRgh3DU.cjs');
-const require_dokploy_api = require('./dokploy-api-BdxOMH_V.cjs');
+const require_dokploy_api = require('./dokploy-api-BnX2OxyF.cjs');
 const require_encryption = require('./encryption-DaCB_NmS.cjs');
 const require_openapi_react_query = require('./openapi-react-query-C_MxpBgF.cjs');
 const node_fs = require_chunk.__toESM(require("node:fs"));
@@ -23,13 +23,14 @@ const __geekmidas_constructs_crons = require_chunk.__toESM(require("@geekmidas/c
 const __geekmidas_constructs_functions = require_chunk.__toESM(require("@geekmidas/constructs/functions"));
 const __geekmidas_constructs_subscribers = require_chunk.__toESM(require("@geekmidas/constructs/subscribers"));
 const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const node_dns_promises = require_chunk.__toESM(require("node:dns/promises"));
 const node_url = require_chunk.__toESM(require("node:url"));
 const prompts = require_chunk.__toESM(require("prompts"));
 const node_module = require_chunk.__toESM(require("node:module"));
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.44.0";
+var version = "0.47.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -220,15 +221,40 @@ async function getDokployRegistryId(options) {
 	const stored = await getDokployCredentials(options);
 	return stored?.registryId ?? void 0;
 }
+/**
+* Store Hostinger API token
+*
+* @param token - API token from hpanel.hostinger.com/profile/api
+*/
+async function storeHostingerToken(token, options) {
+	const credentials = await readCredentials(options);
+	credentials.hostinger = {
+		token,
+		storedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeCredentials(credentials, options);
+}
+/**
+* Get stored Hostinger API token
+*
+* Checks environment variable first (HOSTINGER_API_TOKEN),
+* then falls back to stored credentials.
+*/
+async function getHostingerToken(options) {
+	const envToken = process.env.HOSTINGER_API_TOKEN;
+	if (envToken) return envToken;
+	const credentials = await readCredentials(options);
+	return credentials.hostinger?.token ?? null;
+}
 
 //#endregion
 //#region src/auth/index.ts
-const logger$10 = console;
+const logger$11 = console;
 /**
 * Validate Dokploy token by making a test API call
 */
 async function validateDokployToken(endpoint, token) {
-	const { DokployApi: DokployApi$1 } = await Promise.resolve().then(() => require("./dokploy-api-Bdmk5ImW.cjs"));
+	const { DokployApi: DokployApi$1 } = await Promise.resolve().then(() => require("./dokploy-api-4a6h35VY.cjs"));
 	const api = new DokployApi$1({
 		baseUrl: endpoint,
 		token
@@ -291,36 +317,36 @@ async function prompt$1(message, hidden = false) {
 async function loginCommand(options) {
 	const { service, token: providedToken, endpoint: providedEndpoint } = options;
 	if (service === "dokploy") {
-		logger$10.log("\n🔐 Logging in to Dokploy...\n");
+		logger$11.log("\n🔐 Logging in to Dokploy...\n");
 		let endpoint = providedEndpoint;
 		if (!endpoint) endpoint = await prompt$1("Dokploy URL (e.g., https://dokploy.example.com): ");
 		endpoint = endpoint.replace(/\/$/, "");
 		try {
 			new URL(endpoint);
 		} catch {
-			logger$10.error("Invalid URL format");
+			logger$11.error("Invalid URL format");
 			process.exit(1);
 		}
 		let token = providedToken;
 		if (!token) {
-			logger$10.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
+			logger$11.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
 			token = await prompt$1("API Token: ", true);
 		}
 		if (!token) {
-			logger$10.error("Token is required");
+			logger$11.error("Token is required");
 			process.exit(1);
 		}
-		logger$10.log("\nValidating credentials...");
+		logger$11.log("\nValidating credentials...");
 		const isValid = await validateDokployToken(endpoint, token);
 		if (!isValid) {
-			logger$10.error("\n✗ Invalid credentials. Please check your token and try again.");
+			logger$11.error("\n✗ Invalid credentials. Please check your token and try again.");
 			process.exit(1);
 		}
 		await storeDokployCredentials(token, endpoint);
-		logger$10.log("\n✓ Successfully logged in to Dokploy!");
-		logger$10.log(`  Endpoint: ${endpoint}`);
-		logger$10.log(`  Credentials stored in: ${getCredentialsPath()}`);
-		logger$10.log("\nYou can now use deploy commands without setting DOKPLOY_API_TOKEN.");
+		logger$11.log("\n✓ Successfully logged in to Dokploy!");
+		logger$11.log(`  Endpoint: ${endpoint}`);
+		logger$11.log(`  Credentials stored in: ${getCredentialsPath()}`);
+		logger$11.log("\nYou can now use deploy commands without setting DOKPLOY_API_TOKEN.");
 	}
 }
 /**
@@ -330,28 +356,28 @@ async function logoutCommand(options) {
 	const { service = "dokploy" } = options;
 	if (service === "all") {
 		const dokployRemoved = await removeDokployCredentials();
-		if (dokployRemoved) logger$10.log("\n✓ Logged out from all services");
-		else logger$10.log("\nNo stored credentials found");
+		if (dokployRemoved) logger$11.log("\n✓ Logged out from all services");
+		else logger$11.log("\nNo stored credentials found");
 		return;
 	}
 	if (service === "dokploy") {
 		const removed = await removeDokployCredentials();
-		if (removed) logger$10.log("\n✓ Logged out from Dokploy");
-		else logger$10.log("\nNo Dokploy credentials found");
+		if (removed) logger$11.log("\n✓ Logged out from Dokploy");
+		else logger$11.log("\nNo Dokploy credentials found");
 	}
 }
 /**
 * Show current login status
 */
 async function whoamiCommand() {
-	logger$10.log("\n📋 Current credentials:\n");
+	logger$11.log("\n📋 Current credentials:\n");
 	const dokploy = await getDokployCredentials();
 	if (dokploy) {
-		logger$10.log("  Dokploy:");
-		logger$10.log(`    Endpoint: ${dokploy.endpoint}`);
-		logger$10.log(`    Token: ${maskToken(dokploy.token)}`);
-	} else logger$10.log("  Dokploy: Not logged in");
-	logger$10.log(`\n  Credentials file: ${getCredentialsPath()}`);
+		logger$11.log("  Dokploy:");
+		logger$11.log(`    Endpoint: ${dokploy.endpoint}`);
+		logger$11.log(`    Token: ${maskToken(dokploy.token)}`);
+	} else logger$11.log("  Dokploy: Not logged in");
+	logger$11.log(`\n  Credentials file: ${getCredentialsPath()}`);
 }
 /**
 * Mask a token for display
@@ -437,7 +463,7 @@ function isEnabled(config) {
 var CronGenerator = class extends require_openapi.ConstructGenerator {
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$11 = console;
+		const logger$12 = console;
 		const cronInfos = [];
 		if (constructs.length === 0 || provider !== "aws-lambda") return cronInfos;
 		const cronsDir = (0, node_path.join)(outputDir, "crons");
@@ -452,7 +478,7 @@ var CronGenerator = class extends require_openapi.ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$11.log(`Generated cron handler: ${key}`);
+			logger$12.log(`Generated cron handler: ${key}`);
 		}
 		return cronInfos;
 	}
@@ -488,7 +514,7 @@ var FunctionGenerator = class extends require_openapi.ConstructGenerator {
 	}
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$11 = console;
+		const logger$12 = console;
 		const functionInfos = [];
 		if (constructs.length === 0 || provider !== "aws-lambda") return functionInfos;
 		const functionsDir = (0, node_path.join)(outputDir, "functions");
@@ -502,7 +528,7 @@ var FunctionGenerator = class extends require_openapi.ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$11.log(`Generated function handler: ${key}`);
+			logger$12.log(`Generated function handler: ${key}`);
 		}
 		return functionInfos;
 	}
@@ -535,11 +561,11 @@ var SubscriberGenerator = class extends require_openapi.ConstructGenerator {
 	}
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-lambda";
-		const logger$11 = console;
+		const logger$12 = console;
 		const subscriberInfos = [];
 		if (provider === "server") {
 			await this.generateServerSubscribersFile(outputDir, constructs);
-			logger$11.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
+			logger$12.log(`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`);
 			return subscriberInfos;
 		}
 		if (constructs.length === 0) return subscriberInfos;
@@ -556,7 +582,7 @@ var SubscriberGenerator = class extends require_openapi.ConstructGenerator {
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment()
 			});
-			logger$11.log(`Generated subscriber handler: ${key}`);
+			logger$12.log(`Generated subscriber handler: ${key}`);
 		}
 		return subscriberInfos;
 	}
@@ -722,7 +748,7 @@ export async function setupSubscribers(
 
 //#endregion
 //#region src/workspace/client-generator.ts
-const logger$9 = console;
+const logger$10 = console;
 /**
 * Cache of OpenAPI spec hashes to detect changes.
 */
@@ -842,7 +868,7 @@ ${spec.content}
 * Generate clients for all frontend apps in the workspace.
 */
 async function generateAllClients(workspace, options = {}) {
-	const log = options.silent ? () => {} : logger$9.log.bind(logger$9);
+	const log = options.silent ? () => {} : logger$10.log.bind(logger$10);
 	const allResults = [];
 	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "frontend" && app.dependencies.length > 0) {
 		const results = await generateClientForFrontend(workspace, appName, { force: options.force });
@@ -864,7 +890,7 @@ function getDependentFrontends(workspace, backendAppName) {
 
 //#endregion
 //#region src/dev/index.ts
-const logger$8 = console;
+const logger$9 = console;
 /**
 * Load environment files
 * @internal Exported for testing
@@ -915,7 +941,7 @@ async function findAvailablePort(preferredPort, maxAttempts = 10) {
 	for (let i = 0; i < maxAttempts; i++) {
 		const port = preferredPort + i;
 		if (await isPortAvailable(port)) return port;
-		logger$8.log(`⚠️  Port ${port} is in use, trying ${port + 1}...`);
+		logger$9.log(`⚠️  Port ${port} is in use, trying ${port + 1}...`);
 	}
 	throw new Error(`Could not find an available port after trying ${maxAttempts} ports starting from ${preferredPort}`);
 }
@@ -1016,7 +1042,7 @@ function getProductionConfigFromGkm(config) {
 async function devCommand(options) {
 	if (options.entry) return entryDevCommand(options);
 	const defaultEnv = loadEnvFiles(".env");
-	if (defaultEnv.loaded.length > 0) logger$8.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
+	if (defaultEnv.loaded.length > 0) logger$9.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
 	const appName = require_config.getAppNameFromCwd();
 	let config;
 	let appRoot = process.cwd();
@@ -1030,9 +1056,9 @@ async function devCommand(options) {
 		secretsRoot = appConfig.workspaceRoot;
 		workspaceAppName = appConfig.appName;
 		workspaceAppPort = appConfig.app.port;
-		logger$8.log(`📦 Running app: ${appConfig.appName} on port ${workspaceAppPort}`);
+		logger$9.log(`📦 Running app: ${appConfig.appName} on port ${workspaceAppPort}`);
 		if (appConfig.app.entry) {
-			logger$8.log(`📄 Using entry point: ${appConfig.app.entry}`);
+			logger$9.log(`📄 Using entry point: ${appConfig.app.entry}`);
 			return entryDevCommand({
 				...options,
 				entry: appConfig.app.entry,
@@ -1043,7 +1069,7 @@ async function devCommand(options) {
 	} catch {
 		const loadedConfig = await require_config.loadWorkspaceConfig();
 		if (loadedConfig.type === "workspace") {
-			logger$8.log("📦 Detected workspace configuration");
+			logger$9.log("📦 Detected workspace configuration");
 			return workspaceDevCommand(loadedConfig.workspace, options);
 		}
 		config = loadedConfig.raw;
@@ -1051,34 +1077,34 @@ async function devCommand(options) {
 	else {
 		const loadedConfig = await require_config.loadWorkspaceConfig();
 		if (loadedConfig.type === "workspace") {
-			logger$8.log("📦 Detected workspace configuration");
+			logger$9.log("📦 Detected workspace configuration");
 			return workspaceDevCommand(loadedConfig.workspace, options);
 		}
 		config = loadedConfig.raw;
 	}
 	if (config.env) {
 		const { loaded, missing } = loadEnvFiles(config.env, appRoot);
-		if (loaded.length > 0) logger$8.log(`📦 Loaded env: ${loaded.join(", ")}`);
-		if (missing.length > 0) logger$8.warn(`⚠️  Missing env files: ${missing.join(", ")}`);
+		if (loaded.length > 0) logger$9.log(`📦 Loaded env: ${loaded.join(", ")}`);
+		if (missing.length > 0) logger$9.warn(`⚠️  Missing env files: ${missing.join(", ")}`);
 	}
 	const resolved = resolveProviders(config, { provider: "server" });
-	logger$8.log("🚀 Starting development server...");
-	logger$8.log(`Loading routes from: ${config.routes}`);
-	if (config.functions) logger$8.log(`Loading functions from: ${config.functions}`);
-	if (config.crons) logger$8.log(`Loading crons from: ${config.crons}`);
-	if (config.subscribers) logger$8.log(`Loading subscribers from: ${config.subscribers}`);
-	logger$8.log(`Using envParser: ${config.envParser}`);
+	logger$9.log("🚀 Starting development server...");
+	logger$9.log(`Loading routes from: ${config.routes}`);
+	if (config.functions) logger$9.log(`Loading functions from: ${config.functions}`);
+	if (config.crons) logger$9.log(`Loading crons from: ${config.crons}`);
+	if (config.subscribers) logger$9.log(`Loading subscribers from: ${config.subscribers}`);
+	logger$9.log(`Using envParser: ${config.envParser}`);
 	const { path: envParserPath, importPattern: envParserImportPattern } = require_config.parseModuleConfig(config.envParser, "envParser");
 	const { path: loggerPath, importPattern: loggerImportPattern } = require_config.parseModuleConfig(config.logger, "logger");
 	const telescope = normalizeTelescopeConfig(config.telescope);
-	if (telescope) logger$8.log(`🔭 Telescope enabled at ${telescope.path}`);
+	if (telescope) logger$9.log(`🔭 Telescope enabled at ${telescope.path}`);
 	const studio = normalizeStudioConfig(config.studio);
-	if (studio) logger$8.log(`🗄️  Studio enabled at ${studio.path}`);
+	if (studio) logger$9.log(`🗄️  Studio enabled at ${studio.path}`);
 	const hooks = normalizeHooksConfig(config.hooks, appRoot);
-	if (hooks) logger$8.log(`🪝 Server hooks enabled from ${config.hooks?.server}`);
+	if (hooks) logger$9.log(`🪝 Server hooks enabled from ${config.hooks?.server}`);
 	const openApiConfig = require_openapi.resolveOpenApiConfig(config);
 	const enableOpenApi = openApiConfig.enabled || resolved.enableOpenApi;
-	if (enableOpenApi) logger$8.log(`📄 OpenAPI output: ${require_openapi.OPENAPI_OUTPUT_PATH}`);
+	if (enableOpenApi) logger$9.log(`📄 OpenAPI output: ${require_openapi.OPENAPI_OUTPUT_PATH}`);
 	const buildContext = {
 		envParserPath,
 		envParserImportPattern,
@@ -1098,7 +1124,7 @@ async function devCommand(options) {
 		await (0, node_fs_promises.mkdir)(secretsDir, { recursive: true });
 		secretsJsonPath = (0, node_path.join)(secretsDir, "dev-secrets.json");
 		await (0, node_fs_promises.writeFile)(secretsJsonPath, JSON.stringify(appSecrets, null, 2));
-		logger$8.log(`🔐 Loaded ${Object.keys(appSecrets).length} secret(s)`);
+		logger$9.log(`🔐 Loaded ${Object.keys(appSecrets).length} secret(s)`);
 	}
 	const devServer = new DevServer(resolved.providers[0], options.port ?? workspaceAppPort ?? 3e3, options.portExplicit ?? false, enableOpenApi, telescope, studio, runtime, appRoot, secretsJsonPath);
 	await devServer.start();
@@ -1116,7 +1142,7 @@ async function devCommand(options) {
 		...hooksFile ? [hooksFile.endsWith(".ts") ? hooksFile : `${hooksFile}.ts`] : []
 	].flat().filter((p) => typeof p === "string");
 	const normalizedPatterns = watchPatterns.map((p) => p.startsWith("./") ? p.slice(2) : p);
-	logger$8.log(`👀 Watching for changes in: ${normalizedPatterns.join(", ")}`);
+	logger$9.log(`👀 Watching for changes in: ${normalizedPatterns.join(", ")}`);
 	const resolvedFiles = await (0, fast_glob.default)(normalizedPatterns, {
 		cwd: appRoot,
 		absolute: false,
@@ -1126,7 +1152,7 @@ async function devCommand(options) {
 		const parts = f.split("/");
 		return parts.slice(0, -1).join("/");
 	}))];
-	logger$8.log(`📁 Found ${resolvedFiles.length} files in ${dirsToWatch.length} directories`);
+	logger$9.log(`📁 Found ${resolvedFiles.length} files in ${dirsToWatch.length} directories`);
 	const watcher = chokidar.default.watch([...resolvedFiles, ...dirsToWatch], {
 		ignored: /(^|[/\\])\../,
 		persistent: true,
@@ -1134,24 +1160,24 @@ async function devCommand(options) {
 		cwd: appRoot
 	});
 	watcher.on("ready", () => {
-		logger$8.log("🔍 File watcher ready");
+		logger$9.log("🔍 File watcher ready");
 	});
 	watcher.on("error", (error) => {
-		logger$8.error("❌ Watcher error:", error);
+		logger$9.error("❌ Watcher error:", error);
 	});
 	let rebuildTimeout = null;
 	watcher.on("change", async (path) => {
-		logger$8.log(`📝 File changed: ${path}`);
+		logger$9.log(`📝 File changed: ${path}`);
 		if (rebuildTimeout) clearTimeout(rebuildTimeout);
 		rebuildTimeout = setTimeout(async () => {
 			try {
-				logger$8.log("🔄 Rebuilding...");
+				logger$9.log("🔄 Rebuilding...");
 				await buildServer(config, buildContext, resolved.providers[0], enableOpenApi, appRoot);
 				if (enableOpenApi) await require_openapi.generateOpenApi(config, { silent: true });
-				logger$8.log("✅ Rebuild complete, restarting server...");
+				logger$9.log("✅ Rebuild complete, restarting server...");
 				await devServer.restart();
 			} catch (error) {
-				logger$8.error("❌ Rebuild failed:", error.message);
+				logger$9.error("❌ Rebuild failed:", error.message);
 			}
 		}, 300);
 	});
@@ -1159,9 +1185,9 @@ async function devCommand(options) {
 	const shutdown = () => {
 		if (isShuttingDown) return;
 		isShuttingDown = true;
-		logger$8.log("\n🛑 Shutting down...");
+		logger$9.log("\n🛑 Shutting down...");
 		Promise.all([watcher.close(), devServer.stop()]).catch((err) => {
-			logger$8.error("Error during shutdown:", err);
+			logger$9.error("Error during shutdown:", err);
 		}).finally(() => {
 			process.exit(0);
 		});
@@ -1264,11 +1290,11 @@ async function loadDevSecrets(workspace) {
 	for (const stage of stages) if (require_storage.secretsExist(stage, workspace.root)) {
 		const secrets = await require_storage.readStageSecrets(stage, workspace.root);
 		if (secrets) {
-			logger$8.log(`🔐 Loading secrets from stage: ${stage}`);
+			logger$9.log(`🔐 Loading secrets from stage: ${stage}`);
 			return require_storage.toEmbeddableSecrets(secrets);
 		}
 	}
-	logger$8.warn("⚠️  Secrets enabled but no dev/development secrets found. Run \"gkm secrets:init --stage dev\"");
+	logger$9.warn("⚠️  Secrets enabled but no dev/development secrets found. Run \"gkm secrets:init --stage dev\"");
 	return {};
 }
 /**
@@ -1283,7 +1309,7 @@ async function loadSecretsForApp(secretsRoot, appName) {
 	for (const stage of stages) if (require_storage.secretsExist(stage, secretsRoot)) {
 		const stageSecrets = await require_storage.readStageSecrets(stage, secretsRoot);
 		if (stageSecrets) {
-			logger$8.log(`🔐 Loading secrets from stage: ${stage}`);
+			logger$9.log(`🔐 Loading secrets from stage: ${stage}`);
 			secrets = require_storage.toEmbeddableSecrets(stageSecrets);
 			break;
 		}
@@ -1308,20 +1334,20 @@ async function startWorkspaceServices(workspace) {
 	if (services.cache) servicesToStart.push("redis");
 	if (services.mail) servicesToStart.push("mailpit");
 	if (servicesToStart.length === 0) return;
-	logger$8.log(`🐳 Starting services: ${servicesToStart.join(", ")}`);
+	logger$9.log(`🐳 Starting services: ${servicesToStart.join(", ")}`);
 	try {
 		const composeFile = (0, node_path.join)(workspace.root, "docker-compose.yml");
 		if (!(0, node_fs.existsSync)(composeFile)) {
-			logger$8.warn("⚠️  No docker-compose.yml found. Services will not be started.");
+			logger$9.warn("⚠️  No docker-compose.yml found. Services will not be started.");
 			return;
 		}
 		(0, node_child_process.execSync)(`docker compose up -d ${servicesToStart.join(" ")}`, {
 			cwd: workspace.root,
 			stdio: "inherit"
 		});
-		logger$8.log("✅ Services started");
+		logger$9.log("✅ Services started");
 	} catch (error) {
-		logger$8.error("❌ Failed to start services:", error.message);
+		logger$9.error("❌ Failed to start services:", error.message);
 		throw error;
 	}
 }
@@ -1338,40 +1364,40 @@ async function workspaceDevCommand(workspace, options) {
 	const appCount = Object.keys(workspace.apps).length;
 	const backendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "backend");
 	const frontendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "frontend");
-	logger$8.log(`\n🚀 Starting workspace: ${workspace.name}`);
-	logger$8.log(`   ${backendApps.length} backend app(s), ${frontendApps.length} frontend app(s)`);
+	logger$9.log(`\n🚀 Starting workspace: ${workspace.name}`);
+	logger$9.log(`   ${backendApps.length} backend app(s), ${frontendApps.length} frontend app(s)`);
 	const conflicts = checkPortConflicts(workspace);
 	if (conflicts.length > 0) {
-		for (const conflict of conflicts) logger$8.error(`❌ Port conflict: Apps "${conflict.app1}" and "${conflict.app2}" both use port ${conflict.port}`);
+		for (const conflict of conflicts) logger$9.error(`❌ Port conflict: Apps "${conflict.app1}" and "${conflict.app2}" both use port ${conflict.port}`);
 		throw new Error("Port conflicts detected. Please assign unique ports to each app.");
 	}
 	if (frontendApps.length > 0) {
-		logger$8.log("\n🔍 Validating frontend apps...");
+		logger$9.log("\n🔍 Validating frontend apps...");
 		const validationResults = await validateFrontendApps(workspace);
 		let hasErrors = false;
 		for (const result of validationResults) {
 			if (!result.valid) {
 				hasErrors = true;
-				logger$8.error(`\n❌ Frontend app "${result.appName}" validation failed:`);
-				for (const error of result.errors) logger$8.error(`   • ${error}`);
+				logger$9.error(`\n❌ Frontend app "${result.appName}" validation failed:`);
+				for (const error of result.errors) logger$9.error(`   • ${error}`);
 			}
-			for (const warning of result.warnings) logger$8.warn(`   ⚠️  ${result.appName}: ${warning}`);
+			for (const warning of result.warnings) logger$9.warn(`   ⚠️  ${result.appName}: ${warning}`);
 		}
 		if (hasErrors) throw new Error("Frontend app validation failed. Fix the issues above and try again.");
-		logger$8.log("✅ Frontend apps validated");
+		logger$9.log("✅ Frontend apps validated");
 	}
 	if (frontendApps.length > 0) {
 		const clientResults = await generateAllClients(workspace, { force: true });
 		const generatedCount = clientResults.filter((r) => r.generated).length;
-		if (generatedCount > 0) logger$8.log(`\n📦 Generated ${generatedCount} API client(s)`);
+		if (generatedCount > 0) logger$9.log(`\n📦 Generated ${generatedCount} API client(s)`);
 	}
 	await startWorkspaceServices(workspace);
 	const secretsEnv = await loadDevSecrets(workspace);
-	if (Object.keys(secretsEnv).length > 0) logger$8.log(`   Loaded ${Object.keys(secretsEnv).length} secret(s)`);
+	if (Object.keys(secretsEnv).length > 0) logger$9.log(`   Loaded ${Object.keys(secretsEnv).length} secret(s)`);
 	const dependencyEnv = generateAllDependencyEnvVars(workspace);
 	if (Object.keys(dependencyEnv).length > 0) {
-		logger$8.log("📡 Dependency URLs:");
-		for (const [key, value] of Object.entries(dependencyEnv)) logger$8.log(`   ${key}=${value}`);
+		logger$9.log("📡 Dependency URLs:");
+		for (const [key, value] of Object.entries(dependencyEnv)) logger$9.log(`   ${key}=${value}`);
 	}
 	let turboFilter = [];
 	if (options.app) {
@@ -1380,18 +1406,18 @@ async function workspaceDevCommand(workspace, options) {
 			throw new Error(`App "${options.app}" not found. Available apps: ${appNames}`);
 		}
 		turboFilter = ["--filter", options.app];
-		logger$8.log(`\n🎯 Running single app: ${options.app}`);
+		logger$9.log(`\n🎯 Running single app: ${options.app}`);
 	} else if (options.filter) {
 		turboFilter = ["--filter", options.filter];
-		logger$8.log(`\n🔍 Using filter: ${options.filter}`);
-	} else logger$8.log(`\n🎯 Running all ${appCount} apps`);
+		logger$9.log(`\n🔍 Using filter: ${options.filter}`);
+	} else logger$9.log(`\n🎯 Running all ${appCount} apps`);
 	const buildOrder = require_workspace.getAppBuildOrder(workspace);
-	logger$8.log("\n📋 Apps (in dependency order):");
+	logger$9.log("\n📋 Apps (in dependency order):");
 	for (const appName of buildOrder) {
 		const app = workspace.apps[appName];
 		if (!app) continue;
 		const deps = app.dependencies.length > 0 ? ` (depends on: ${app.dependencies.join(", ")})` : "";
-		logger$8.log(`   ${app.type === "backend" ? "🔧" : "🌐"} ${appName} → http://localhost:${app.port}${deps}`);
+		logger$9.log(`   ${app.type === "backend" ? "🔧" : "🌐"} ${appName} → http://localhost:${app.port}${deps}`);
 	}
 	const configFiles = [
 		"gkm.config.ts",
@@ -1413,7 +1439,7 @@ async function workspaceDevCommand(workspace, options) {
 		NODE_ENV: "development",
 		...configPath ? { GKM_CONFIG_PATH: configPath } : {}
 	};
-	logger$8.log("\n🏃 Starting turbo run dev...\n");
+	logger$9.log("\n🏃 Starting turbo run dev...\n");
 	const turboProcess = (0, node_child_process.spawn)("pnpm", [
 		"turbo",
 		"run",
@@ -1445,7 +1471,7 @@ async function workspaceDevCommand(workspace, options) {
 				onlyFiles: true
 			});
 			if (resolvedFiles.length > 0) {
-				logger$8.log(`\n👀 Watching ${resolvedFiles.length} endpoint file(s) for schema changes`);
+				logger$9.log(`\n👀 Watching ${resolvedFiles.length} endpoint file(s) for schema changes`);
 				endpointWatcher = chokidar.default.watch(resolvedFiles, {
 					ignored: /(^|[/\\])\../,
 					persistent: true,
@@ -1473,12 +1499,12 @@ async function workspaceDevCommand(workspace, options) {
 							for (const frontend of dependents) affectedFrontends.add(frontend);
 						}
 						if (affectedFrontends.size === 0) return;
-						logger$8.log(`\n🔄 Detected schema change in ${changedBackends.join(", ")}`);
+						logger$9.log(`\n🔄 Detected schema change in ${changedBackends.join(", ")}`);
 						for (const frontend of affectedFrontends) try {
 							const results = await generateClientForFrontend(workspace, frontend);
-							for (const result of results) if (result.generated) logger$8.log(`   📦 Regenerated client for ${result.frontendApp} (${result.endpointCount} endpoints)`);
+							for (const result of results) if (result.generated) logger$9.log(`   📦 Regenerated client for ${result.frontendApp} (${result.endpointCount} endpoints)`);
 						} catch (error) {
-							logger$8.error(`   ❌ Failed to regenerate client for ${frontend}: ${error.message}`);
+							logger$9.error(`   ❌ Failed to regenerate client for ${frontend}: ${error.message}`);
 						}
 					}, 500);
 				});
@@ -1489,7 +1515,7 @@ async function workspaceDevCommand(workspace, options) {
 	const shutdown = () => {
 		if (isShuttingDown) return;
 		isShuttingDown = true;
-		logger$8.log("\n🛑 Shutting down workspace...");
+		logger$9.log("\n🛑 Shutting down workspace...");
 		if (endpointWatcher) endpointWatcher.close().catch(() => {});
 		if (turboProcess.pid) try {
 			process.kill(-turboProcess.pid, "SIGTERM");
@@ -1504,7 +1530,7 @@ async function workspaceDevCommand(workspace, options) {
 	process.on("SIGTERM", shutdown);
 	return new Promise((resolve$3, reject) => {
 		turboProcess.on("error", (error) => {
-			logger$8.error("❌ Turbo error:", error);
+			logger$9.error("❌ Turbo error:", error);
 			reject(error);
 		});
 		turboProcess.on("exit", (code) => {
@@ -1616,7 +1642,7 @@ async function prepareEntryCredentials(options) {
 		secretsRoot = appConfig.workspaceRoot;
 		appName = appConfig.appName;
 	} catch (error) {
-		logger$8.log(`⚠️  Could not load workspace config: ${error.message}`);
+		logger$9.log(`⚠️  Could not load workspace config: ${error.message}`);
 		secretsRoot = findSecretsRoot(cwd);
 		appName = require_config.getAppNameFromCwd(cwd) ?? void 0;
 	}
@@ -1646,11 +1672,11 @@ async function entryDevCommand(options) {
 	const entryPath = (0, node_path.resolve)(process.cwd(), entry);
 	if (!(0, node_fs.existsSync)(entryPath)) throw new Error(`Entry file not found: ${entryPath}`);
 	const defaultEnv = loadEnvFiles(".env");
-	if (defaultEnv.loaded.length > 0) logger$8.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
+	if (defaultEnv.loaded.length > 0) logger$9.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
 	const { credentials, resolvedPort, secretsJsonPath, appName } = await prepareEntryCredentials({ explicitPort: options.portExplicit ? options.port : void 0 });
-	if (appName) logger$8.log(`📦 App: ${appName} (port ${resolvedPort})`);
-	logger$8.log(`🚀 Starting entry file: ${entry} on port ${resolvedPort}`);
-	if (Object.keys(credentials).length > 1) logger$8.log(`🔐 Loaded ${Object.keys(credentials).length - 1} secret(s) + PORT`);
+	if (appName) logger$9.log(`📦 App: ${appName} (port ${resolvedPort})`);
+	logger$9.log(`🚀 Starting entry file: ${entry} on port ${resolvedPort}`);
+	if (Object.keys(credentials).length > 1) logger$9.log(`🔐 Loaded ${Object.keys(credentials).length - 1} secret(s) + PORT`);
 	const wrapperDir = (0, node_path.join)(process.cwd(), ".gkm");
 	await (0, node_fs_promises.mkdir)(wrapperDir, { recursive: true });
 	const wrapperPath = (0, node_path.join)(wrapperDir, "entry-wrapper.ts");
@@ -1661,7 +1687,7 @@ async function entryDevCommand(options) {
 	const shutdown = () => {
 		if (isShuttingDown) return;
 		isShuttingDown = true;
-		logger$8.log("\n🛑 Shutting down...");
+		logger$9.log("\n🛑 Shutting down...");
 		runner.stop();
 		process.exit(0);
 	};
@@ -1693,14 +1719,14 @@ var EntryRunner = class {
 			});
 			let restartTimeout = null;
 			this.watcher.on("change", (path) => {
-				logger$8.log(`📝 File changed: ${path}`);
+				logger$9.log(`📝 File changed: ${path}`);
 				if (restartTimeout) clearTimeout(restartTimeout);
 				restartTimeout = setTimeout(async () => {
-					logger$8.log("🔄 Restarting...");
+					logger$9.log("🔄 Restarting...");
 					await this.restart();
 				}, 300);
 			});
-			logger$8.log(`👀 Watching for changes in: ${watchDir}`);
+			logger$9.log(`👀 Watching for changes in: ${watchDir}`);
 		}
 	}
 	async runProcess() {
@@ -1715,14 +1741,14 @@ var EntryRunner = class {
 		});
 		this.isRunning = true;
 		this.childProcess.on("error", (error) => {
-			logger$8.error("❌ Process error:", error);
+			logger$9.error("❌ Process error:", error);
 		});
 		this.childProcess.on("exit", (code) => {
-			if (code !== null && code !== 0 && code !== 143) logger$8.error(`❌ Process exited with code ${code}`);
+			if (code !== null && code !== 0 && code !== 143) logger$9.error(`❌ Process exited with code ${code}`);
 			this.isRunning = false;
 		});
 		await new Promise((resolve$3) => setTimeout(resolve$3, 500));
-		if (this.isRunning) logger$8.log(`\n🎉 Running at http://localhost:${this.port}`);
+		if (this.isRunning) logger$9.log(`\n🎉 Running at http://localhost:${this.port}`);
 	}
 	async restart() {
 		this.stopProcess();
@@ -1772,11 +1798,11 @@ var DevServer = class {
 			this.actualPort = this.requestedPort;
 		} else {
 			this.actualPort = await findAvailablePort(this.requestedPort);
-			if (this.actualPort !== this.requestedPort) logger$8.log(`ℹ️  Port ${this.requestedPort} was in use, using port ${this.actualPort} instead`);
+			if (this.actualPort !== this.requestedPort) logger$9.log(`ℹ️  Port ${this.requestedPort} was in use, using port ${this.actualPort} instead`);
 		}
 		const serverEntryPath = (0, node_path.join)(this.appRoot, ".gkm", this.provider, "server.ts");
 		await this.createServerEntry();
-		logger$8.log(`\n✨ Starting server on port ${this.actualPort}...`);
+		logger$9.log(`\n✨ Starting server on port ${this.actualPort}...`);
 		this.serverProcess = (0, node_child_process.spawn)("npx", [
 			"tsx",
 			serverEntryPath,
@@ -1792,18 +1818,18 @@ var DevServer = class {
 		});
 		this.isRunning = true;
 		this.serverProcess.on("error", (error) => {
-			logger$8.error("❌ Server error:", error);
+			logger$9.error("❌ Server error:", error);
 		});
 		this.serverProcess.on("exit", (code, signal) => {
-			if (code !== null && code !== 0 && signal !== "SIGTERM") logger$8.error(`❌ Server exited with code ${code}`);
+			if (code !== null && code !== 0 && signal !== "SIGTERM") logger$9.error(`❌ Server exited with code ${code}`);
 			this.isRunning = false;
 		});
 		await new Promise((resolve$3) => setTimeout(resolve$3, 1e3));
 		if (this.isRunning) {
-			logger$8.log(`\n🎉 Server running at http://localhost:${this.actualPort}`);
-			if (this.enableOpenApi) logger$8.log(`📚 API Docs available at http://localhost:${this.actualPort}/__docs`);
-			if (this.telescope) logger$8.log(`🔭 Telescope available at http://localhost:${this.actualPort}${this.telescope.path}`);
-			if (this.studio) logger$8.log(`🗄️  Studio available at http://localhost:${this.actualPort}${this.studio.path}`);
+			logger$9.log(`\n🎉 Server running at http://localhost:${this.actualPort}`);
+			if (this.enableOpenApi) logger$9.log(`📚 API Docs available at http://localhost:${this.actualPort}/__docs`);
+			if (this.telescope) logger$9.log(`🔭 Telescope available at http://localhost:${this.actualPort}${this.telescope.path}`);
+			if (this.studio) logger$9.log(`🗄️  Studio available at http://localhost:${this.actualPort}${this.studio.path}`);
 		}
 	}
 	async stop() {
@@ -1911,18 +1937,18 @@ async function execCommand(commandArgs, options = {}) {
 	const cwd = options.cwd ?? process.cwd();
 	if (commandArgs.length === 0) throw new Error("No command specified. Usage: gkm exec -- <command>");
 	const defaultEnv = loadEnvFiles(".env");
-	if (defaultEnv.loaded.length > 0) logger$8.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
+	if (defaultEnv.loaded.length > 0) logger$9.log(`📦 Loaded env: ${defaultEnv.loaded.join(", ")}`);
 	const { credentials, secretsJsonPath, appName } = await prepareEntryCredentials({ cwd });
-	if (appName) logger$8.log(`📦 App: ${appName}`);
+	if (appName) logger$9.log(`📦 App: ${appName}`);
 	const secretCount = Object.keys(credentials).filter((k) => k !== "PORT").length;
-	if (secretCount > 0) logger$8.log(`🔐 Loaded ${secretCount} secret(s)`);
+	if (secretCount > 0) logger$9.log(`🔐 Loaded ${secretCount} secret(s)`);
 	const preloadDir = (0, node_path.join)(cwd, ".gkm");
 	await (0, node_fs_promises.mkdir)(preloadDir, { recursive: true });
 	const preloadPath = (0, node_path.join)(preloadDir, "credentials-preload.ts");
 	await createCredentialsPreload(preloadPath, secretsJsonPath);
 	const [cmd, ...args] = commandArgs;
 	if (!cmd) throw new Error("No command specified");
-	logger$8.log(`🚀 Running: ${commandArgs.join(" ")}`);
+	logger$9.log(`🚀 Running: ${commandArgs.join(" ")}`);
 	const existingNodeOptions = process.env.NODE_OPTIONS ?? "";
 	const tsxImport = "--import tsx";
 	const preloadImport = `--import ${preloadPath}`;
@@ -1943,7 +1969,7 @@ async function execCommand(commandArgs, options = {}) {
 	const exitCode = await new Promise((resolve$3) => {
 		child.on("close", (code) => resolve$3(code ?? 0));
 		child.on("error", (error) => {
-			logger$8.error(`Failed to run command: ${error.message}`);
+			logger$9.error(`Failed to run command: ${error.message}`);
 			resolve$3(1);
 		});
 	});
@@ -1952,7 +1978,7 @@ async function execCommand(commandArgs, options = {}) {
 
 //#endregion
 //#region src/build/manifests.ts
-const logger$7 = console;
+const logger$8 = console;
 async function generateAwsManifest(outputDir, routes, functions, crons, subscribers) {
 	const manifestDir = (0, node_path.join)(outputDir, "manifest");
 	await (0, node_fs_promises.mkdir)(manifestDir, { recursive: true });
@@ -1977,8 +2003,8 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = (0, node_path.join)(manifestDir, "aws.ts");
 	await (0, node_fs_promises.writeFile)(manifestPath, content);
-	logger$7.log(`Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`);
-	logger$7.log(`Manifest: ${(0, node_path.relative)(process.cwd(), manifestPath)}`);
+	logger$8.log(`Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`);
+	logger$8.log(`Manifest: ${(0, node_path.relative)(process.cwd(), manifestPath)}`);
 }
 async function generateServerManifest(outputDir, appInfo, routes, subscribers) {
 	const manifestDir = (0, node_path.join)(outputDir, "manifest");
@@ -2009,13 +2035,13 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = (0, node_path.join)(manifestDir, "server.ts");
 	await (0, node_fs_promises.writeFile)(manifestPath, content);
-	logger$7.log(`Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`);
-	logger$7.log(`Manifest: ${(0, node_path.relative)(process.cwd(), manifestPath)}`);
+	logger$8.log(`Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`);
+	logger$8.log(`Manifest: ${(0, node_path.relative)(process.cwd(), manifestPath)}`);
 }
 
 //#endregion
 //#region src/build/index.ts
-const logger$6 = console;
+const logger$7 = console;
 async function buildCommand(options) {
 	const loadedConfig = await require_config.loadWorkspaceConfig();
 	if (loadedConfig.type === "workspace") {
@@ -2023,7 +2049,7 @@ async function buildCommand(options) {
 		const workspaceRoot = (0, node_path.resolve)(loadedConfig.workspace.root);
 		const isAtWorkspaceRoot = cwd === workspaceRoot;
 		if (isAtWorkspaceRoot) {
-			logger$6.log("📦 Detected workspace configuration");
+			logger$7.log("📦 Detected workspace configuration");
 			return workspaceBuildCommand(loadedConfig.workspace, options);
 		}
 	}
@@ -2031,21 +2057,21 @@ async function buildCommand(options) {
 	const resolved = resolveProviders(config, options);
 	const productionConfigFromGkm = getProductionConfigFromGkm(config);
 	const production = normalizeProductionConfig(options.production ?? false, productionConfigFromGkm);
-	if (production) logger$6.log(`🏭 Building for PRODUCTION`);
-	logger$6.log(`Building with providers: ${resolved.providers.join(", ")}`);
-	logger$6.log(`Loading routes from: ${config.routes}`);
-	if (config.functions) logger$6.log(`Loading functions from: ${config.functions}`);
-	if (config.crons) logger$6.log(`Loading crons from: ${config.crons}`);
-	if (config.subscribers) logger$6.log(`Loading subscribers from: ${config.subscribers}`);
-	logger$6.log(`Using envParser: ${config.envParser}`);
+	if (production) logger$7.log(`🏭 Building for PRODUCTION`);
+	logger$7.log(`Building with providers: ${resolved.providers.join(", ")}`);
+	logger$7.log(`Loading routes from: ${config.routes}`);
+	if (config.functions) logger$7.log(`Loading functions from: ${config.functions}`);
+	if (config.crons) logger$7.log(`Loading crons from: ${config.crons}`);
+	if (config.subscribers) logger$7.log(`Loading subscribers from: ${config.subscribers}`);
+	logger$7.log(`Using envParser: ${config.envParser}`);
 	const { path: envParserPath, importPattern: envParserImportPattern } = require_config.parseModuleConfig(config.envParser, "envParser");
 	const { path: loggerPath, importPattern: loggerImportPattern } = require_config.parseModuleConfig(config.logger, "logger");
 	const telescope = production ? void 0 : normalizeTelescopeConfig(config.telescope);
-	if (telescope) logger$6.log(`🔭 Telescope enabled at ${telescope.path}`);
+	if (telescope) logger$7.log(`🔭 Telescope enabled at ${telescope.path}`);
 	const studio = production ? void 0 : normalizeStudioConfig(config.studio);
-	if (studio) logger$6.log(`🗄️  Studio enabled at ${studio.path}`);
+	if (studio) logger$7.log(`🗄️  Studio enabled at ${studio.path}`);
 	const hooks = normalizeHooksConfig(config.hooks);
-	if (hooks) logger$6.log(`🪝 Server hooks enabled`);
+	if (hooks) logger$7.log(`🪝 Server hooks enabled`);
 	const services = config.docker?.compose?.services;
 	const dockerServices = services ? Array.isArray(services) ? {
 		postgres: services.includes("postgres"),
@@ -2077,12 +2103,12 @@ async function buildCommand(options) {
 		config.crons ? cronGenerator.load(config.crons) : [],
 		config.subscribers ? subscriberGenerator.load(config.subscribers) : []
 	]);
-	logger$6.log(`Found ${allEndpoints.length} endpoints`);
-	logger$6.log(`Found ${allFunctions.length} functions`);
-	logger$6.log(`Found ${allCrons.length} crons`);
-	logger$6.log(`Found ${allSubscribers.length} subscribers`);
+	logger$7.log(`Found ${allEndpoints.length} endpoints`);
+	logger$7.log(`Found ${allFunctions.length} functions`);
+	logger$7.log(`Found ${allCrons.length} crons`);
+	logger$7.log(`Found ${allSubscribers.length} subscribers`);
 	if (allEndpoints.length === 0 && allFunctions.length === 0 && allCrons.length === 0 && allSubscribers.length === 0) {
-		logger$6.log("No endpoints, functions, crons, or subscribers found to process");
+		logger$7.log("No endpoints, functions, crons, or subscribers found to process");
 		return {};
 	}
 	const rootOutputDir = (0, node_path.join)(process.cwd(), ".gkm");
@@ -2097,7 +2123,7 @@ async function buildCommand(options) {
 async function buildForProvider(provider, context, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, endpoints, functions, crons, subscribers, enableOpenApi, skipBundle, stage) {
 	const outputDir = (0, node_path.join)(process.cwd(), ".gkm", provider);
 	await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
-	logger$6.log(`\nGenerating handlers for provider: ${provider}`);
+	logger$7.log(`\nGenerating handlers for provider: ${provider}`);
 	const [routes, functionInfos, cronInfos, subscriberInfos] = await Promise.all([
 		endpointGenerator.build(context, endpoints, outputDir, {
 			provider,
@@ -2107,7 +2133,7 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 		cronGenerator.build(context, crons, outputDir, { provider }),
 		subscriberGenerator.build(context, subscribers, outputDir, { provider })
 	]);
-	logger$6.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`);
+	logger$7.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`);
 	if (provider === "server") {
 		const routeMetadata = await Promise.all(endpoints.map(async ({ construct }) => ({
 			path: construct._path,
@@ -2122,7 +2148,7 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 		await generateServerManifest(rootOutputDir, appInfo, routeMetadata, subscriberInfos);
 		let masterKey;
 		if (context.production?.bundle && !skipBundle) {
-			logger$6.log(`\n📦 Bundling production server...`);
+			logger$7.log(`\n📦 Bundling production server...`);
 			const { bundleServer } = await Promise.resolve().then(() => require("./bundler-BB-kETMd.cjs"));
 			const allConstructs = [
 				...endpoints.map((e) => e.construct),
@@ -2142,10 +2168,10 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 				dockerServices
 			});
 			masterKey = bundleResult.masterKey;
-			logger$6.log(`✅ Bundle complete: .gkm/server/dist/server.mjs`);
+			logger$7.log(`✅ Bundle complete: .gkm/server/dist/server.mjs`);
 			if (masterKey) {
-				logger$6.log(`\n🔐 Secrets encrypted for deployment`);
-				logger$6.log(`   Deploy with: GKM_MASTER_KEY=${masterKey}`);
+				logger$7.log(`\n🔐 Secrets encrypted for deployment`);
+				logger$7.log(`   Deploy with: GKM_MASTER_KEY=${masterKey}`);
 			}
 		}
 		return { masterKey };
@@ -2182,17 +2208,17 @@ async function workspaceBuildCommand(workspace, options) {
 	const apps = Object.entries(workspace.apps);
 	const backendApps = apps.filter(([, app]) => app.type === "backend");
 	const frontendApps = apps.filter(([, app]) => app.type === "frontend");
-	logger$6.log(`\n🏗️  Building workspace: ${workspace.name}`);
-	logger$6.log(`   Backend apps: ${backendApps.map(([name$1]) => name$1).join(", ") || "none"}`);
-	logger$6.log(`   Frontend apps: ${frontendApps.map(([name$1]) => name$1).join(", ") || "none"}`);
-	if (options.production) logger$6.log(`   🏭 Production mode enabled`);
+	logger$7.log(`\n🏗️  Building workspace: ${workspace.name}`);
+	logger$7.log(`   Backend apps: ${backendApps.map(([name$1]) => name$1).join(", ") || "none"}`);
+	logger$7.log(`   Frontend apps: ${frontendApps.map(([name$1]) => name$1).join(", ") || "none"}`);
+	if (options.production) logger$7.log(`   🏭 Production mode enabled`);
 	const buildOrder = require_workspace.getAppBuildOrder(workspace);
-	logger$6.log(`   Build order: ${buildOrder.join(" → ")}`);
+	logger$7.log(`   Build order: ${buildOrder.join(" → ")}`);
 	const pm = detectPackageManager$2();
-	logger$6.log(`\n📦 Using ${pm} with Turbo for parallel builds...\n`);
+	logger$7.log(`\n📦 Using ${pm} with Turbo for parallel builds...\n`);
 	try {
 		const turboCommand = getTurboCommand(pm);
-		logger$6.log(`Running: ${turboCommand}`);
+		logger$7.log(`Running: ${turboCommand}`);
 		await new Promise((resolve$3, reject) => {
 			const child = (0, node_child_process.spawn)(turboCommand, {
 				shell: true,
@@ -2220,15 +2246,15 @@ async function workspaceBuildCommand(workspace, options) {
 				outputPath
 			});
 		}
-		logger$6.log(`\n✅ Workspace build complete!`);
-		logger$6.log(`\n📋 Build Summary:`);
+		logger$7.log(`\n✅ Workspace build complete!`);
+		logger$7.log(`\n📋 Build Summary:`);
 		for (const result of results) {
 			const icon = result.type === "backend" ? "⚙️" : "🌐";
-			logger$6.log(`   ${icon} ${result.appName}: ${result.outputPath || "built"}`);
+			logger$7.log(`   ${icon} ${result.appName}: ${result.outputPath || "built"}`);
 		}
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : "Build failed";
-		logger$6.log(`\n❌ Build failed: ${errorMessage}`);
+		logger$7.log(`\n❌ Build failed: ${errorMessage}`);
 		for (const [appName, app] of apps) results.push({
 			appName,
 			type: app.type,
@@ -3336,7 +3362,7 @@ CMD ["node", "index.mjs"]
 
 //#endregion
 //#region src/docker/index.ts
-const logger$5 = console;
+const logger$6 = console;
 /**
 * Docker command implementation
 * Generates Dockerfile, docker-compose.yml, and related files
@@ -3347,7 +3373,7 @@ const logger$5 = console;
 async function dockerCommand(options) {
 	const loadedConfig = await require_config.loadWorkspaceConfig();
 	if (loadedConfig.type === "workspace") {
-		logger$5.log("📦 Detected workspace configuration");
+		logger$6.log("📦 Detected workspace configuration");
 		return workspaceDockerCommand(loadedConfig.workspace, options);
 	}
 	const config = await require_config.loadConfig();
@@ -3368,14 +3394,14 @@ async function dockerCommand(options) {
 	let useTurbo = options.turbo ?? false;
 	if (inMonorepo && !useSlim) if (hasTurbo) {
 		useTurbo = true;
-		logger$5.log("   Detected monorepo with turbo.json - using turbo prune");
+		logger$6.log("   Detected monorepo with turbo.json - using turbo prune");
 	} else throw new Error("Monorepo detected but turbo.json not found.\n\nDocker builds in monorepos require Turborepo for proper dependency isolation.\n\nTo fix this:\n  1. Install turbo: pnpm add -Dw turbo\n  2. Create turbo.json in your monorepo root\n  3. Run this command again\n\nSee: https://turbo.build/repo/docs/guides/tools/docker");
 	let turboPackage = options.turboPackage ?? dockerConfig.imageName;
 	if (useTurbo && !options.turboPackage) try {
 		const pkg$1 = require(`${process.cwd()}/package.json`);
 		if (pkg$1.name) {
 			turboPackage = pkg$1.name;
-			logger$5.log(`   Turbo package: ${turboPackage}`);
+			logger$6.log(`   Turbo package: ${turboPackage}`);
 		}
 	} catch {}
 	const templateOptions = {
@@ -3392,7 +3418,7 @@ async function dockerCommand(options) {
 	const dockerMode = useSlim ? "slim" : useTurbo ? "turbo" : "multi-stage";
 	const dockerfilePath = (0, node_path.join)(dockerDir, "Dockerfile");
 	await (0, node_fs_promises.writeFile)(dockerfilePath, dockerfile);
-	logger$5.log(`Generated: .gkm/docker/Dockerfile (${dockerMode}, ${packageManager})`);
+	logger$6.log(`Generated: .gkm/docker/Dockerfile (${dockerMode}, ${packageManager})`);
 	const composeOptions = {
 		imageName: dockerConfig.imageName,
 		registry: options.registry ?? dockerConfig.registry,
@@ -3404,15 +3430,15 @@ async function dockerCommand(options) {
 	const dockerCompose = hasServices ? generateDockerCompose(composeOptions) : generateMinimalDockerCompose(composeOptions);
 	const composePath = (0, node_path.join)(dockerDir, "docker-compose.yml");
 	await (0, node_fs_promises.writeFile)(composePath, dockerCompose);
-	logger$5.log("Generated: .gkm/docker/docker-compose.yml");
+	logger$6.log("Generated: .gkm/docker/docker-compose.yml");
 	const dockerignore = generateDockerignore();
 	const dockerignorePath = (0, node_path.join)(process.cwd(), ".dockerignore");
 	await (0, node_fs_promises.writeFile)(dockerignorePath, dockerignore);
-	logger$5.log("Generated: .dockerignore (project root)");
+	logger$6.log("Generated: .dockerignore (project root)");
 	const entrypoint = generateDockerEntrypoint();
 	const entrypointPath = (0, node_path.join)(dockerDir, "docker-entrypoint.sh");
 	await (0, node_fs_promises.writeFile)(entrypointPath, entrypoint);
-	logger$5.log("Generated: .gkm/docker/docker-entrypoint.sh");
+	logger$6.log("Generated: .gkm/docker/docker-entrypoint.sh");
 	const result = {
 		dockerfile: dockerfilePath,
 		dockerCompose: composePath,
@@ -3431,13 +3457,13 @@ async function dockerCommand(options) {
 function ensureLockfile(cwd) {
 	const lockfilePath = findLockfilePath(cwd);
 	if (!lockfilePath) {
-		logger$5.warn("\n⚠️  No lockfile found. Docker build may fail or use stale dependencies.");
+		logger$6.warn("\n⚠️  No lockfile found. Docker build may fail or use stale dependencies.");
 		return null;
 	}
 	const lockfileName = (0, node_path.basename)(lockfilePath);
 	const localLockfile = (0, node_path.join)(cwd, lockfileName);
 	if (lockfilePath === localLockfile) return null;
-	logger$5.log(`   Copying ${lockfileName} from monorepo root...`);
+	logger$6.log(`   Copying ${lockfileName} from monorepo root...`);
 	(0, node_fs.copyFileSync)(lockfilePath, localLockfile);
 	return () => {
 		try {
@@ -3453,7 +3479,7 @@ async function buildDockerImage(imageName, options) {
 	const tag = options.tag ?? "latest";
 	const registry = options.registry;
 	const fullImageName = registry ? `${registry}/${imageName}:${tag}` : `${imageName}:${tag}`;
-	logger$5.log(`\n🐳 Building Docker image: ${fullImageName}`);
+	logger$6.log(`\n🐳 Building Docker image: ${fullImageName}`);
 	const cwd = process.cwd();
 	const cleanup = ensureLockfile(cwd);
 	try {
@@ -3465,7 +3491,7 @@ async function buildDockerImage(imageName, options) {
 				DOCKER_BUILDKIT: "1"
 			}
 		});
-		logger$5.log(`✅ Docker image built: ${fullImageName}`);
+		logger$6.log(`✅ Docker image built: ${fullImageName}`);
 	} catch (error) {
 		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
 	} finally {
@@ -3480,13 +3506,13 @@ async function pushDockerImage(imageName, options) {
 	const registry = options.registry;
 	if (!registry) throw new Error("Registry is required to push Docker image. Use --registry or configure docker.registry in gkm.config.ts");
 	const fullImageName = `${registry}/${imageName}:${tag}`;
-	logger$5.log(`\n🚀 Pushing Docker image: ${fullImageName}`);
+	logger$6.log(`\n🚀 Pushing Docker image: ${fullImageName}`);
 	try {
 		(0, node_child_process.execSync)(`docker push ${fullImageName}`, {
 			cwd: process.cwd(),
 			stdio: "inherit"
 		});
-		logger$5.log(`✅ Docker image pushed: ${fullImageName}`);
+		logger$6.log(`✅ Docker image pushed: ${fullImageName}`);
 	} catch (error) {
 		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
@@ -3512,11 +3538,11 @@ function getAppPackageName(appPath) {
 async function workspaceDockerCommand(workspace, options) {
 	const results = [];
 	const apps = Object.entries(workspace.apps);
-	logger$5.log(`\n🐳 Generating Dockerfiles for workspace: ${workspace.name}`);
+	logger$6.log(`\n🐳 Generating Dockerfiles for workspace: ${workspace.name}`);
 	const dockerDir = (0, node_path.join)(workspace.root, ".gkm", "docker");
 	await (0, node_fs_promises.mkdir)(dockerDir, { recursive: true });
 	const packageManager = detectPackageManager$1(workspace.root);
-	logger$5.log(`   Package manager: ${packageManager}`);
+	logger$6.log(`   Package manager: ${packageManager}`);
 	for (const [appName, app] of apps) {
 		const appPath = app.path;
 		const fullAppPath = (0, node_path.join)(workspace.root, appPath);
@@ -3524,7 +3550,7 @@ async function workspaceDockerCommand(workspace, options) {
 		const imageName = appName;
 		const hasEntry = !!app.entry;
 		const buildType = hasEntry ? "entry" : app.type;
-		logger$5.log(`\n   📄 Generating Dockerfile for ${appName} (${buildType})`);
+		logger$6.log(`\n   📄 Generating Dockerfile for ${appName} (${buildType})`);
 		let dockerfile;
 		if (app.type === "frontend") dockerfile = generateNextjsDockerfile({
 			imageName,
@@ -3555,7 +3581,7 @@ async function workspaceDockerCommand(workspace, options) {
 		});
 		const dockerfilePath = (0, node_path.join)(dockerDir, `Dockerfile.${appName}`);
 		await (0, node_fs_promises.writeFile)(dockerfilePath, dockerfile);
-		logger$5.log(`      Generated: .gkm/docker/Dockerfile.${appName}`);
+		logger$6.log(`      Generated: .gkm/docker/Dockerfile.${appName}`);
 		results.push({
 			appName,
 			type: app.type,
@@ -3566,19 +3592,19 @@ async function workspaceDockerCommand(workspace, options) {
 	const dockerignore = generateDockerignore();
 	const dockerignorePath = (0, node_path.join)(workspace.root, ".dockerignore");
 	await (0, node_fs_promises.writeFile)(dockerignorePath, dockerignore);
-	logger$5.log(`\n   Generated: .dockerignore (workspace root)`);
+	logger$6.log(`\n   Generated: .dockerignore (workspace root)`);
 	const dockerCompose = generateWorkspaceCompose(workspace, { registry: options.registry });
 	const composePath = (0, node_path.join)(dockerDir, "docker-compose.yml");
 	await (0, node_fs_promises.writeFile)(composePath, dockerCompose);
-	logger$5.log(`   Generated: .gkm/docker/docker-compose.yml`);
-	logger$5.log(`\n✅ Generated ${results.length} Dockerfile(s) + docker-compose.yml`);
-	logger$5.log("\n📋 Build commands:");
+	logger$6.log(`   Generated: .gkm/docker/docker-compose.yml`);
+	logger$6.log(`\n✅ Generated ${results.length} Dockerfile(s) + docker-compose.yml`);
+	logger$6.log("\n📋 Build commands:");
 	for (const result of results) {
 		const icon = result.type === "backend" ? "⚙️" : "🌐";
-		logger$5.log(`   ${icon} docker build -f .gkm/docker/Dockerfile.${result.appName} -t ${result.imageName} .`);
+		logger$6.log(`   ${icon} docker build -f .gkm/docker/Dockerfile.${result.appName} -t ${result.imageName} .`);
 	}
-	logger$5.log("\n📋 Run all services:");
-	logger$5.log("   docker compose -f .gkm/docker/docker-compose.yml up --build");
+	logger$6.log("\n📋 Run all services:");
+	logger$6.log("   docker compose -f .gkm/docker/docker-compose.yml up --build");
 	return {
 		apps: results,
 		dockerCompose: composePath,
@@ -3618,7 +3644,7 @@ function getAppNameFromPackageJson() {
 	} catch {}
 	return void 0;
 }
-const logger$4 = console;
+const logger$5 = console;
 /**
 * Get the full image reference
 */
@@ -3633,18 +3659,18 @@ function getImageRef(registry, imageName, tag) {
 * @param buildArgs - Build arguments to pass to docker build
 */
 async function buildImage(imageRef, appName, buildArgs) {
-	logger$4.log(`\n🔨 Building Docker image: ${imageRef}`);
+	logger$5.log(`\n🔨 Building Docker image: ${imageRef}`);
 	const cwd = process.cwd();
 	const lockfilePath = findLockfilePath(cwd);
 	const lockfileDir = lockfilePath ? (0, node_path.dirname)(lockfilePath) : cwd;
 	const inMonorepo = lockfileDir !== cwd;
-	if (appName || inMonorepo) logger$4.log("   Generating Dockerfile for monorepo (turbo prune)...");
-	else logger$4.log("   Generating Dockerfile...");
+	if (appName || inMonorepo) logger$5.log("   Generating Dockerfile for monorepo (turbo prune)...");
+	else logger$5.log("   Generating Dockerfile...");
 	await dockerCommand({});
 	const dockerfileSuffix = appName ? `.${appName}` : "";
 	const dockerfilePath = `.gkm/docker/Dockerfile${dockerfileSuffix}`;
 	const buildCwd = lockfilePath && (inMonorepo || appName) ? lockfileDir : cwd;
-	if (buildCwd !== cwd) logger$4.log(`   Building from workspace root: ${buildCwd}`);
+	if (buildCwd !== cwd) logger$5.log(`   Building from workspace root: ${buildCwd}`);
 	const buildArgsString = buildArgs && buildArgs.length > 0 ? buildArgs.map((arg) => `--build-arg "${arg}"`).join(" ") : "";
 	try {
 		const cmd = [
@@ -3663,7 +3689,7 @@ async function buildImage(imageRef, appName, buildArgs) {
 				DOCKER_BUILDKIT: "1"
 			}
 		});
-		logger$4.log(`✅ Image built: ${imageRef}`);
+		logger$5.log(`✅ Image built: ${imageRef}`);
 	} catch (error) {
 		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
@@ -3672,13 +3698,13 @@ async function buildImage(imageRef, appName, buildArgs) {
 * Push Docker image to registry
 */
 async function pushImage(imageRef) {
-	logger$4.log(`\n☁️  Pushing image: ${imageRef}`);
+	logger$5.log(`\n☁️  Pushing image: ${imageRef}`);
 	try {
 		(0, node_child_process.execSync)(`docker push ${imageRef}`, {
 			cwd: process.cwd(),
 			stdio: "inherit"
 		});
-		logger$4.log(`✅ Image pushed: ${imageRef}`);
+		logger$5.log(`✅ Image pushed: ${imageRef}`);
 	} catch (error) {
 		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
@@ -3691,17 +3717,17 @@ async function deployDocker(options) {
 	const imageName = config.imageName;
 	const imageRef = getImageRef(config.registry, imageName, tag);
 	await buildImage(imageRef, config.appName, buildArgs);
-	if (!skipPush) if (!config.registry) logger$4.warn("\n⚠️  No registry configured. Use --skip-push or configure docker.registry in gkm.config.ts");
+	if (!skipPush) if (!config.registry) logger$5.warn("\n⚠️  No registry configured. Use --skip-push or configure docker.registry in gkm.config.ts");
 	else await pushImage(imageRef);
-	logger$4.log("\n✅ Docker deployment ready!");
-	logger$4.log(`\n📋 Deployment details:`);
-	logger$4.log(`   Image: ${imageRef}`);
-	logger$4.log(`   Stage: ${stage}`);
+	logger$5.log("\n✅ Docker deployment ready!");
+	logger$5.log(`\n📋 Deployment details:`);
+	logger$5.log(`   Image: ${imageRef}`);
+	logger$5.log(`   Stage: ${stage}`);
 	if (masterKey) {
-		logger$4.log(`\n🔐 Deploy with this environment variable:`);
-		logger$4.log(`   GKM_MASTER_KEY=${masterKey}`);
-		logger$4.log("\n   Example docker run:");
-		logger$4.log(`   docker run -e GKM_MASTER_KEY=${masterKey} ${imageRef}`);
+		logger$5.log(`\n🔐 Deploy with this environment variable:`);
+		logger$5.log(`   GKM_MASTER_KEY=${masterKey}`);
+		logger$5.log("\n   Example docker run:");
+		logger$5.log(`   docker run -e GKM_MASTER_KEY=${masterKey} ${imageRef}`);
 	}
 	return {
 		imageRef,
@@ -3728,7 +3754,7 @@ function resolveDockerConfig(config) {
 
 //#endregion
 //#region src/deploy/dokploy.ts
-const logger$3 = console;
+const logger$4 = console;
 /**
 * Get the Dokploy API token from stored credentials or environment
 */
@@ -3752,25 +3778,25 @@ async function createApi$1(endpoint) {
 */
 async function deployDokploy(options) {
 	const { stage, imageRef, masterKey, config } = options;
-	logger$3.log(`\n🎯 Deploying to Dokploy...`);
-	logger$3.log(`   Endpoint: ${config.endpoint}`);
-	logger$3.log(`   Application: ${config.applicationId}`);
+	logger$4.log(`\n🎯 Deploying to Dokploy...`);
+	logger$4.log(`   Endpoint: ${config.endpoint}`);
+	logger$4.log(`   Application: ${config.applicationId}`);
 	const api = await createApi$1(config.endpoint);
-	logger$3.log(`  Configuring Docker image: ${imageRef}`);
+	logger$4.log(`  Configuring Docker image: ${imageRef}`);
 	const registryOptions = {};
 	if (config.registryId) {
 		registryOptions.registryId = config.registryId;
-		logger$3.log(`  Using Dokploy registry: ${config.registryId}`);
+		logger$4.log(`  Using Dokploy registry: ${config.registryId}`);
 	} else {
 		const storedRegistryId = await getDokployRegistryId();
 		if (storedRegistryId) {
 			registryOptions.registryId = storedRegistryId;
-			logger$3.log(`  Using stored Dokploy registry: ${storedRegistryId}`);
+			logger$4.log(`  Using stored Dokploy registry: ${storedRegistryId}`);
 		} else if (config.registryCredentials) {
 			registryOptions.username = config.registryCredentials.username;
 			registryOptions.password = config.registryCredentials.password;
 			registryOptions.registryUrl = config.registryCredentials.registryUrl;
-			logger$3.log(`  Using registry credentials for: ${config.registryCredentials.registryUrl}`);
+			logger$4.log(`  Using registry credentials for: ${config.registryCredentials.registryUrl}`);
 		} else {
 			const username = process.env.DOCKER_REGISTRY_USERNAME;
 			const password = process.env.DOCKER_REGISTRY_PASSWORD;
@@ -3779,31 +3805,31 @@ async function deployDokploy(options) {
 				registryOptions.username = username;
 				registryOptions.password = password;
 				registryOptions.registryUrl = registryUrl;
-				logger$3.log(`  Using registry credentials from environment`);
+				logger$4.log(`  Using registry credentials from environment`);
 			}
 		}
 	}
 	await api.saveDockerProvider(config.applicationId, imageRef, registryOptions);
-	logger$3.log("  ✓ Docker provider configured");
+	logger$4.log("  ✓ Docker provider configured");
 	const envVars = {};
 	if (masterKey) envVars.GKM_MASTER_KEY = masterKey;
 	if (Object.keys(envVars).length > 0) {
-		logger$3.log("  Updating environment variables...");
+		logger$4.log("  Updating environment variables...");
 		const envString = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
 		await api.saveApplicationEnv(config.applicationId, envString);
-		logger$3.log("  ✓ Environment variables updated");
+		logger$4.log("  ✓ Environment variables updated");
 	}
-	logger$3.log("  Triggering deployment...");
+	logger$4.log("  Triggering deployment...");
 	await api.deployApplication(config.applicationId);
-	logger$3.log("  ✓ Deployment triggered");
-	logger$3.log("\n✅ Dokploy deployment initiated!");
-	logger$3.log(`\n📋 Deployment details:`);
-	logger$3.log(`   Image: ${imageRef}`);
-	logger$3.log(`   Stage: ${stage}`);
-	logger$3.log(`   Application ID: ${config.applicationId}`);
-	if (masterKey) logger$3.log(`\n🔐 GKM_MASTER_KEY has been set in Dokploy environment`);
+	logger$4.log("  ✓ Deployment triggered");
+	logger$4.log("\n✅ Dokploy deployment initiated!");
+	logger$4.log(`\n📋 Deployment details:`);
+	logger$4.log(`   Image: ${imageRef}`);
+	logger$4.log(`   Stage: ${stage}`);
+	logger$4.log(`   Application ID: ${config.applicationId}`);
+	if (masterKey) logger$4.log(`\n🔐 GKM_MASTER_KEY has been set in Dokploy environment`);
 	const deploymentUrl = `${config.endpoint}/project/${config.projectId}`;
-	logger$3.log(`\n🔗 View deployment: ${deploymentUrl}`);
+	logger$4.log(`\n🔗 View deployment: ${deploymentUrl}`);
 	return {
 		imageRef,
 		masterKey,
@@ -3811,6 +3837,473 @@ async function deployDokploy(options) {
 	};
 }
 
+//#endregion
+//#region src/deploy/state.ts
+/**
+* Get the state file path for a stage
+*/
+function getStateFilePath(workspaceRoot, stage) {
+	return (0, node_path.join)(workspaceRoot, ".gkm", `deploy-${stage}.json`);
+}
+/**
+* Read the deploy state for a stage
+* Returns null if state file doesn't exist
+*/
+async function readStageState(workspaceRoot, stage) {
+	const filePath = getStateFilePath(workspaceRoot, stage);
+	try {
+		const content = await (0, node_fs_promises.readFile)(filePath, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		console.warn(`Warning: Could not read deploy state: ${error}`);
+		return null;
+	}
+}
+/**
+* Write the deploy state for a stage
+*/
+async function writeStageState(workspaceRoot, stage, state) {
+	const filePath = getStateFilePath(workspaceRoot, stage);
+	const dir = (0, node_path.join)(workspaceRoot, ".gkm");
+	await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+	state.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await (0, node_fs_promises.writeFile)(filePath, JSON.stringify(state, null, 2));
+}
+/**
+* Create a new empty state for a stage
+*/
+function createEmptyState(stage, environmentId) {
+	return {
+		provider: "dokploy",
+		stage,
+		environmentId,
+		applications: {},
+		services: {},
+		lastDeployedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* Get application ID from state
+*/
+function getApplicationId(state, appName) {
+	return state?.applications[appName];
+}
+/**
+* Set application ID in state (mutates state)
+*/
+function setApplicationId(state, appName, applicationId) {
+	state.applications[appName] = applicationId;
+}
+/**
+* Get postgres ID from state
+*/
+function getPostgresId(state) {
+	return state?.services.postgresId;
+}
+/**
+* Set postgres ID in state (mutates state)
+*/
+function setPostgresId(state, postgresId) {
+	state.services.postgresId = postgresId;
+}
+/**
+* Get redis ID from state
+*/
+function getRedisId(state) {
+	return state?.services.redisId;
+}
+/**
+* Set redis ID in state (mutates state)
+*/
+function setRedisId(state, redisId) {
+	state.services.redisId = redisId;
+}
+
+//#endregion
+//#region src/deploy/dns/hostinger-api.ts
+/**
+* Hostinger DNS API client
+*
+* API Documentation: https://developers.hostinger.com/
+* Authentication: Bearer token from hpanel.hostinger.com/profile/api
+*/
+const HOSTINGER_API_BASE = "https://api.hostinger.com";
+/**
+* Hostinger API error
+*/
+var HostingerApiError = class extends Error {
+	constructor(message, status, statusText, errors) {
+		super(message);
+		this.status = status;
+		this.statusText = statusText;
+		this.errors = errors;
+		this.name = "HostingerApiError";
+	}
+};
+/**
+* Hostinger DNS API client
+*
+* @example
+* ```ts
+* const api = new HostingerApi(token);
+*
+* // Get all records for a domain
+* const records = await api.getRecords('traflabs.io');
+*
+* // Create/update records
+* await api.upsertRecords('traflabs.io', [
+*   { name: 'api.joemoer', type: 'A', ttl: 300, records: ['1.2.3.4'] }
+* ]);
+* ```
+*/
+var HostingerApi = class {
+	token;
+	constructor(token) {
+		this.token = token;
+	}
+	/**
+	* Make a request to the Hostinger API
+	*/
+	async request(method, endpoint, body) {
+		const url = `${HOSTINGER_API_BASE}${endpoint}`;
+		const response = await fetch(url, {
+			method,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this.token}`
+			},
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (!response.ok) {
+			let errorMessage = `Hostinger API error: ${response.status} ${response.statusText}`;
+			let errors;
+			try {
+				const errorBody = await response.json();
+				if (errorBody.message) errorMessage = `Hostinger API error: ${errorBody.message}`;
+				errors = errorBody.errors;
+			} catch {}
+			throw new HostingerApiError(errorMessage, response.status, response.statusText, errors);
+		}
+		const text = await response.text();
+		if (!text || text.trim() === "") return void 0;
+		return JSON.parse(text);
+	}
+	/**
+	* Get all DNS records for a domain
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	*/
+	async getRecords(domain) {
+		const response = await this.request("GET", `/api/dns/v1/zones/${domain}`);
+		return response.data || [];
+	}
+	/**
+	* Create or update DNS records
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	* @param records - Records to create/update
+	* @param overwrite - If true, replaces all existing records. If false, merges with existing.
+	*/
+	async upsertRecords(domain, records, overwrite = false) {
+		await this.request("PUT", `/api/dns/v1/zones/${domain}`, {
+			overwrite,
+			zone: records
+		});
+	}
+	/**
+	* Validate DNS records before applying
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	* @param records - Records to validate
+	* @returns true if valid, throws if invalid
+	*/
+	async validateRecords(domain, records) {
+		await this.request("POST", `/api/dns/v1/zones/${domain}/validate`, {
+			overwrite: false,
+			zone: records
+		});
+		return true;
+	}
+	/**
+	* Delete specific DNS records
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	* @param filters - Filters to match records for deletion
+	*/
+	async deleteRecords(domain, filters) {
+		await this.request("DELETE", `/api/dns/v1/zones/${domain}`, { filters });
+	}
+	/**
+	* Check if a specific record exists
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	* @param name - Subdomain name (e.g., 'api.joemoer')
+	* @param type - Record type (e.g., 'A')
+	*/
+	async recordExists(domain, name$1, type$1 = "A") {
+		const records = await this.getRecords(domain);
+		return records.some((r) => r.name === name$1 && r.type === type$1);
+	}
+	/**
+	* Create a single A record if it doesn't exist
+	*
+	* @param domain - Root domain (e.g., 'traflabs.io')
+	* @param subdomain - Subdomain name (e.g., 'api.joemoer')
+	* @param ip - IP address to point to
+	* @param ttl - TTL in seconds (default: 300)
+	* @returns true if created, false if already exists
+	*/
+	async createARecordIfNotExists(domain, subdomain, ip, ttl = 300) {
+		const exists = await this.recordExists(domain, subdomain, "A");
+		if (exists) return false;
+		await this.upsertRecords(domain, [{
+			name: subdomain,
+			type: "A",
+			ttl,
+			records: [ip]
+		}]);
+		return true;
+	}
+};
+
+//#endregion
+//#region src/deploy/dns/index.ts
+const logger$3 = console;
+/**
+* Resolve IP address from a hostname
+*/
+async function resolveHostnameToIp(hostname) {
+	try {
+		const addresses = await (0, node_dns_promises.lookup)(hostname, { family: 4 });
+		return addresses.address;
+	} catch (error) {
+		throw new Error(`Failed to resolve IP for ${hostname}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Extract subdomain from full hostname relative to root domain
+*
+* @example
+* extractSubdomain('api.joemoer.traflabs.io', 'traflabs.io') => 'api.joemoer'
+* extractSubdomain('joemoer.traflabs.io', 'traflabs.io') => 'joemoer'
+*/
+function extractSubdomain(hostname, rootDomain) {
+	if (!hostname.endsWith(rootDomain)) throw new Error(`Hostname ${hostname} is not under root domain ${rootDomain}`);
+	const subdomain = hostname.slice(0, -(rootDomain.length + 1));
+	return subdomain || "@";
+}
+/**
+* Generate required DNS records for a deployment
+*/
+function generateRequiredRecords(appHostnames, rootDomain, serverIp) {
+	const records = [];
+	for (const [appName, hostname] of appHostnames) {
+		const subdomain = extractSubdomain(hostname, rootDomain);
+		records.push({
+			hostname,
+			subdomain,
+			type: "A",
+			value: serverIp,
+			appName
+		});
+	}
+	return records;
+}
+/**
+* Print DNS records table
+*/
+function printDnsRecordsTable(records, rootDomain) {
+	logger$3.log("\n   📋 DNS Records for " + rootDomain + ":");
+	logger$3.log("   ┌─────────────────────────────────────┬──────┬─────────────────┬────────┐");
+	logger$3.log("   │ Subdomain                           │ Type │ Value           │ Status │");
+	logger$3.log("   ├─────────────────────────────────────┼──────┼─────────────────┼────────┤");
+	for (const record of records) {
+		const subdomain = record.subdomain.padEnd(35);
+		const type$1 = record.type.padEnd(4);
+		const value = record.value.padEnd(15);
+		let status;
+		if (record.error) status = "✗";
+		else if (record.created) status = "✓ new";
+		else if (record.existed) status = "✓";
+		else status = "?";
+		logger$3.log(`   │ ${subdomain} │ ${type$1} │ ${value} │ ${status.padEnd(6)} │`);
+	}
+	logger$3.log("   └─────────────────────────────────────┴──────┴─────────────────┴────────┘");
+}
+/**
+* Print DNS records in a simple format for manual setup
+*/
+function printDnsRecordsSimple(records, rootDomain) {
+	logger$3.log("\n   📋 Required DNS Records:");
+	logger$3.log(`   Add these A records to your DNS provider (${rootDomain}):\n`);
+	for (const record of records) logger$3.log(`   ${record.subdomain}  →  ${record.value}  (A record)`);
+	logger$3.log("");
+}
+/**
+* Prompt for input (reuse from deploy/index.ts pattern)
+*/
+async function promptForToken(message) {
+	const { stdin, stdout } = await import("node:process");
+	const readline = await import("node:readline/promises");
+	if (!stdin.isTTY) throw new Error("Interactive input required for Hostinger token.");
+	stdout.write(message);
+	return new Promise((resolve$3) => {
+		let value = "";
+		const onData = (char) => {
+			const c = char.toString();
+			if (c === "\n" || c === "\r") {
+				stdin.setRawMode(false);
+				stdin.pause();
+				stdin.removeListener("data", onData);
+				stdout.write("\n");
+				resolve$3(value);
+			} else if (c === "") {
+				stdin.setRawMode(false);
+				stdin.pause();
+				stdout.write("\n");
+				process.exit(1);
+			} else if (c === "" || c === "\b") {
+				if (value.length > 0) value = value.slice(0, -1);
+			} else value += c;
+		};
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdin.on("data", onData);
+	});
+}
+/**
+* Create DNS records using the configured provider
+*/
+async function createDnsRecords(records, dnsConfig) {
+	const { provider, domain: rootDomain, ttl = 300 } = dnsConfig;
+	if (provider === "manual") return records.map((r) => ({
+		...r,
+		created: false,
+		existed: false
+	}));
+	if (provider === "hostinger") return createHostingerRecords(records, rootDomain, ttl);
+	if (provider === "cloudflare") {
+		logger$3.log("   ⚠ Cloudflare DNS integration not yet implemented");
+		return records.map((r) => ({
+			...r,
+			error: "Cloudflare not implemented"
+		}));
+	}
+	return records;
+}
+/**
+* Create DNS records at Hostinger
+*/
+async function createHostingerRecords(records, rootDomain, ttl) {
+	let token = await getHostingerToken();
+	if (!token) {
+		logger$3.log("\n   📋 Hostinger API token not found.");
+		logger$3.log("   Get your token from: https://hpanel.hostinger.com/profile/api\n");
+		try {
+			token = await promptForToken("   Hostinger API Token: ");
+			await storeHostingerToken(token);
+			logger$3.log("   ✓ Token saved");
+		} catch {
+			logger$3.log("   ⚠ Could not get token, skipping DNS creation");
+			return records.map((r) => ({
+				...r,
+				error: "No API token"
+			}));
+		}
+	}
+	const api = new HostingerApi(token);
+	const results = [];
+	let existingRecords = [];
+	try {
+		existingRecords = await api.getRecords(rootDomain);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		logger$3.log(`   ⚠ Failed to fetch existing DNS records: ${message}`);
+		return records.map((r) => ({
+			...r,
+			error: message
+		}));
+	}
+	for (const record of records) {
+		const existing = existingRecords.find((r) => r.name === record.subdomain && r.type === "A");
+		if (existing) {
+			results.push({
+				...record,
+				existed: true,
+				created: false
+			});
+			continue;
+		}
+		try {
+			await api.upsertRecords(rootDomain, [{
+				name: record.subdomain,
+				type: "A",
+				ttl,
+				records: [record.value]
+			}]);
+			results.push({
+				...record,
+				created: true,
+				existed: false
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			results.push({
+				...record,
+				error: message
+			});
+		}
+	}
+	return results;
+}
+/**
+* Main DNS orchestration function for deployments
+*/
+async function orchestrateDns(appHostnames, dnsConfig, dokployEndpoint) {
+	if (!dnsConfig) return null;
+	const { domain: rootDomain, autoCreate = true } = dnsConfig;
+	logger$3.log("\n🌐 Setting up DNS records...");
+	let serverIp;
+	try {
+		const endpointUrl = new URL(dokployEndpoint);
+		serverIp = await resolveHostnameToIp(endpointUrl.hostname);
+		logger$3.log(`   Server IP: ${serverIp} (from ${endpointUrl.hostname})`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		logger$3.log(`   ⚠ Failed to resolve server IP: ${message}`);
+		return null;
+	}
+	const requiredRecords = generateRequiredRecords(appHostnames, rootDomain, serverIp);
+	if (requiredRecords.length === 0) {
+		logger$3.log("   No DNS records needed");
+		return {
+			records: [],
+			success: true,
+			serverIp
+		};
+	}
+	let finalRecords;
+	if (autoCreate && dnsConfig.provider !== "manual") {
+		logger$3.log(`   Creating DNS records at ${dnsConfig.provider}...`);
+		finalRecords = await createDnsRecords(requiredRecords, dnsConfig);
+		const created = finalRecords.filter((r) => r.created).length;
+		const existed = finalRecords.filter((r) => r.existed).length;
+		const failed = finalRecords.filter((r) => r.error).length;
+		if (created > 0) logger$3.log(`   ✓ Created ${created} DNS record(s)`);
+		if (existed > 0) logger$3.log(`   ✓ ${existed} record(s) already exist`);
+		if (failed > 0) logger$3.log(`   ⚠ ${failed} record(s) failed`);
+	} else finalRecords = requiredRecords;
+	printDnsRecordsTable(finalRecords, rootDomain);
+	const hasFailures = finalRecords.some((r) => r.error);
+	if (dnsConfig.provider === "manual" || hasFailures) printDnsRecordsSimple(finalRecords.filter((r) => !r.created && !r.existed), rootDomain);
+	return {
+		records: finalRecords,
+		success: !hasFailures,
+		serverIp
+	};
+}
+
 //#endregion
 //#region src/deploy/domain.ts
 /**
@@ -4315,24 +4808,39 @@ async function prompt(message, hidden = false) {
 * Provision docker compose services in Dokploy
 * @internal Exported for testing
 */
-async function provisionServices(api, projectId, environmentId, appName, services, existingUrls) {
+async function provisionServices(api, projectId, environmentId, appName, services, existingServiceIds) {
 	logger$1.log(`\n🔍 provisionServices called: services=${JSON.stringify(services)}, envId=${environmentId}`);
 	if (!services || !environmentId) {
 		logger$1.log("   Skipping: no services or no environmentId");
 		return void 0;
 	}
 	const serviceUrls = {};
-	if (services.postgres) if (existingUrls?.DATABASE_URL) logger$1.log("\n🐘 PostgreSQL: Already configured (skipping)");
-	else {
-		logger$1.log("\n🐘 Provisioning PostgreSQL...");
-		const postgresName = `${appName}-db`;
+	const serviceIds = {};
+	if (services.postgres) {
+		logger$1.log("\n🐘 Checking PostgreSQL...");
+		const postgresName = "db";
 		try {
-			const { randomBytes: randomBytes$1 } = await import("node:crypto");
-			const databasePassword = randomBytes$1(16).toString("hex");
-			const postgres = await api.createPostgres(postgresName, projectId, environmentId, { databasePassword });
-			logger$1.log(`   ✓ Created PostgreSQL: ${postgres.postgresId}`);
-			await api.deployPostgres(postgres.postgresId);
-			logger$1.log("   ✓ PostgreSQL deployed");
+			let postgres = null;
+			let created = false;
+			if (existingServiceIds?.postgresId) {
+				logger$1.log(`   Using cached ID: ${existingServiceIds.postgresId}`);
+				postgres = await api.getPostgres(existingServiceIds.postgresId);
+				if (postgres) logger$1.log(`   ✓ PostgreSQL found: ${postgres.postgresId}`);
+				else logger$1.log(`   ⚠ Cached ID invalid, will create new`);
+			}
+			if (!postgres) {
+				const { randomBytes: randomBytes$1 } = await import("node:crypto");
+				const databasePassword = randomBytes$1(16).toString("hex");
+				const result = await api.findOrCreatePostgres(postgresName, projectId, environmentId, { databasePassword });
+				postgres = result.postgres;
+				created = result.created;
+				if (created) {
+					logger$1.log(`   ✓ Created PostgreSQL: ${postgres.postgresId}`);
+					await api.deployPostgres(postgres.postgresId);
+					logger$1.log("   ✓ PostgreSQL deployed");
+				} else logger$1.log(`   ✓ PostgreSQL already exists: ${postgres.postgresId}`);
+			}
+			serviceIds.postgresId = postgres.postgresId;
 			serviceUrls.DATABASE_HOST = postgres.appName;
 			serviceUrls.DATABASE_PORT = "5432";
 			serviceUrls.DATABASE_NAME = postgres.databaseName;
@@ -4342,21 +4850,34 @@ async function provisionServices(api, projectId, environmentId, appName, service
 			logger$1.log(`   ✓ Database credentials configured`);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : "Unknown error";
-			if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`   ℹ PostgreSQL already exists`);
-			else logger$1.log(`   ⚠ Failed to provision PostgreSQL: ${message}`);
+			logger$1.log(`   ⚠ Failed to provision PostgreSQL: ${message}`);
 		}
 	}
-	if (services.redis) if (existingUrls?.REDIS_URL) logger$1.log("\n🔴 Redis: Already configured (skipping)");
-	else {
-		logger$1.log("\n🔴 Provisioning Redis...");
-		const redisName = `${appName}-cache`;
+	if (services.redis) {
+		logger$1.log("\n🔴 Checking Redis...");
+		const redisName = "cache";
 		try {
-			const { randomBytes: randomBytes$1 } = await import("node:crypto");
-			const databasePassword = randomBytes$1(16).toString("hex");
-			const redis = await api.createRedis(redisName, projectId, environmentId, { databasePassword });
-			logger$1.log(`   ✓ Created Redis: ${redis.redisId}`);
-			await api.deployRedis(redis.redisId);
-			logger$1.log("   ✓ Redis deployed");
+			let redis = null;
+			let created = false;
+			if (existingServiceIds?.redisId) {
+				logger$1.log(`   Using cached ID: ${existingServiceIds.redisId}`);
+				redis = await api.getRedis(existingServiceIds.redisId);
+				if (redis) logger$1.log(`   ✓ Redis found: ${redis.redisId}`);
+				else logger$1.log(`   ⚠ Cached ID invalid, will create new`);
+			}
+			if (!redis) {
+				const { randomBytes: randomBytes$1 } = await import("node:crypto");
+				const databasePassword = randomBytes$1(16).toString("hex");
+				const result = await api.findOrCreateRedis(redisName, projectId, environmentId, { databasePassword });
+				redis = result.redis;
+				created = result.created;
+				if (created) {
+					logger$1.log(`   ✓ Created Redis: ${redis.redisId}`);
+					await api.deployRedis(redis.redisId);
+					logger$1.log("   ✓ Redis deployed");
+				} else logger$1.log(`   ✓ Redis already exists: ${redis.redisId}`);
+			}
+			serviceIds.redisId = redis.redisId;
 			serviceUrls.REDIS_HOST = redis.appName;
 			serviceUrls.REDIS_PORT = "6379";
 			if (redis.databasePassword) serviceUrls.REDIS_PASSWORD = redis.databasePassword;
@@ -4365,11 +4886,13 @@ async function provisionServices(api, projectId, environmentId, appName, service
 			logger$1.log(`   ✓ Redis credentials configured`);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : "Unknown error";
-			if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`   ℹ Redis already exists`);
-			else logger$1.log(`   ⚠ Failed to provision Redis: ${message}`);
+			logger$1.log(`   ⚠ Failed to provision Redis: ${message}`);
 		}
 	}
-	return Object.keys(serviceUrls).length > 0 ? serviceUrls : void 0;
+	return Object.keys(serviceUrls).length > 0 ? {
+		serviceUrls,
+		serviceIds
+	} : void 0;
 }
 /**
 * Ensure Dokploy is fully configured, recovering/creating resources as needed
@@ -4424,7 +4947,7 @@ async function ensureDokploySetup(config, dockerConfig, stage, services) {
 			}
 			const environmentId$1 = environment.environmentId;
 			logger$1.log(`   Services config: ${JSON.stringify(services)}, envId: ${environmentId$1}`);
-			const serviceUrls$1 = await provisionServices(api, existingConfig.projectId, environmentId$1, dockerConfig.appName, services, existingUrls);
+			const provisionResult$1 = await provisionServices(api, existingConfig.projectId, environmentId$1, dockerConfig.appName, services, void 0);
 			return {
 				config: {
 					endpoint: existingConfig.endpoint,
@@ -4433,7 +4956,7 @@ async function ensureDokploySetup(config, dockerConfig, stage, services) {
 					registry: existingConfig.registry,
 					registryId: storedRegistryId ?? void 0
 				},
-				serviceUrls: serviceUrls$1
+				serviceUrls: provisionResult$1?.serviceUrls
 			};
 		} catch {
 			logger$1.log("⚠ Project not found, will recover...");
@@ -4540,10 +5063,10 @@ async function ensureDokploySetup(config, dockerConfig, stage, services) {
 	logger$1.log(`   Project: ${project.projectId}`);
 	logger$1.log(`   Application: ${applicationId}`);
 	if (registryId) logger$1.log(`   Registry: ${registryId}`);
-	const serviceUrls = await provisionServices(api, project.projectId, environmentId, dockerConfig.appName, services, existingUrls);
+	const provisionResult = await provisionServices(api, project.projectId, environmentId, dockerConfig.appName, services, void 0);
 	return {
 		config: dokployConfig,
-		serviceUrls
+		serviceUrls: provisionResult?.serviceUrls
 	};
 }
 /**
@@ -4662,6 +5185,18 @@ async function workspaceDeployCommand(workspace, options) {
 		} else environmentId = result.environment.environmentId;
 		logger$1.log(`   ✓ Created project: ${project.projectId}`);
 	}
+	logger$1.log("\n📋 Loading deploy state...");
+	let state = await readStageState(workspace.root, stage);
+	if (state) {
+		logger$1.log(`   Found existing state for stage "${stage}"`);
+		if (state.environmentId !== environmentId) {
+			logger$1.log(`   ⚠ Environment ID changed, updating state`);
+			state.environmentId = environmentId;
+		}
+	} else {
+		logger$1.log(`   Creating new state for stage "${stage}"`);
+		state = createEmptyState(stage, environmentId);
+	}
 	logger$1.log("\n🐳 Checking registry...");
 	let registryId = await getDokployRegistryId();
 	const registry = workspace.deploy.dokploy?.registry;
@@ -4697,33 +5232,45 @@ async function workspaceDeployCommand(workspace, options) {
 	};
 	if (dockerServices.postgres || dockerServices.redis) {
 		logger$1.log("\n🔧 Provisioning infrastructure services...");
-		const existingUrls = stageSecrets ? {
-			DATABASE_URL: stageSecrets.urls?.DATABASE_URL,
-			REDIS_URL: stageSecrets.urls?.REDIS_URL
-		} : void 0;
-		await provisionServices(api, project.projectId, environmentId, workspace.name, dockerServices, existingUrls);
+		const existingServiceIds = {
+			postgresId: getPostgresId(state),
+			redisId: getRedisId(state)
+		};
+		const provisionResult = await provisionServices(api, project.projectId, environmentId, workspace.name, dockerServices, existingServiceIds);
+		if (provisionResult?.serviceIds) {
+			if (provisionResult.serviceIds.postgresId) setPostgresId(state, provisionResult.serviceIds.postgresId);
+			if (provisionResult.serviceIds.redisId) setRedisId(state, provisionResult.serviceIds.redisId);
+		}
 	}
 	const backendApps = appsToDeployNames.filter((name$1) => workspace.apps[name$1].type === "backend");
 	const frontendApps = appsToDeployNames.filter((name$1) => workspace.apps[name$1].type === "frontend");
 	const publicUrls = {};
 	const results = [];
 	const dokployConfig = workspace.deploy.dokploy;
+	const appHostnames = /* @__PURE__ */ new Map();
+	const appDomainIds = /* @__PURE__ */ new Map();
 	if (backendApps.length > 0) {
 		logger$1.log("\n📦 PHASE 1: Deploying backend applications...");
 		for (const appName of backendApps) {
 			const app = workspace.apps[appName];
 			logger$1.log(`\n   ⚙️  Deploying ${appName}...`);
 			try {
-				const dokployAppName = `${workspace.name}-${appName}`;
-				let application;
-				try {
-					application = await api.createApplication(dokployAppName, project.projectId, environmentId);
-					logger$1.log(`      Created application: ${application.applicationId}`);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : "Unknown error";
-					if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`      Application already exists`);
-					else throw error;
+				const dokployAppName = appName;
+				let application = null;
+				const cachedAppId = getApplicationId(state, appName);
+				if (cachedAppId) {
+					logger$1.log(`      Using cached ID: ${cachedAppId}`);
+					application = await api.getApplication(cachedAppId);
+					if (application) logger$1.log(`      ✓ Application found: ${application.applicationId}`);
+					else logger$1.log(`      ⚠ Cached ID invalid, will create new`);
 				}
+				if (!application) {
+					const result = await api.findOrCreateApplication(dokployAppName, project.projectId, environmentId);
+					application = result.application;
+					if (result.created) logger$1.log(`      Created application: ${application.applicationId}`);
+					else logger$1.log(`      Found existing application: ${application.applicationId}`);
+				}
+				setApplicationId(state, appName, application.applicationId);
 				const appSecrets = encryptedSecrets.get(appName);
 				const buildArgs = [];
 				if (appSecrets && appSecrets.secretCount > 0) {
@@ -4747,47 +5294,42 @@ async function workspaceDeployCommand(workspace, options) {
 				});
 				const envVars = [`NODE_ENV=production`, `PORT=${app.port}`];
 				if (appSecrets && appSecrets.masterKey) envVars.push(`GKM_MASTER_KEY=${appSecrets.masterKey}`);
-				if (application) {
-					await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
-					await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
-					logger$1.log(`      Deploying to Dokploy...`);
-					await api.deployApplication(application.applicationId);
-					try {
-						const host = resolveHost(appName, app, stage, dokployConfig, false);
-						await api.createDomain({
-							host,
-							port: app.port,
-							https: true,
-							certificateType: "letsencrypt",
-							applicationId: application.applicationId
-						});
-						const publicUrl = `https://${host}`;
-						publicUrls[appName] = publicUrl;
-						logger$1.log(`      ✓ Domain: ${publicUrl}`);
-					} catch (domainError) {
-						const host = resolveHost(appName, app, stage, dokployConfig, false);
-						publicUrls[appName] = `https://${host}`;
-						logger$1.log(`      ℹ Domain already configured: https://${host}`);
-					}
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						applicationId: application.applicationId,
-						imageRef
-					});
-					logger$1.log(`      ✓ ${appName} deployed successfully`);
-				} else {
-					const host = resolveHost(appName, app, stage, dokployConfig, false);
-					publicUrls[appName] = `https://${host}`;
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						imageRef
+				await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
+				await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
+				logger$1.log(`      Deploying to Dokploy...`);
+				await api.deployApplication(application.applicationId);
+				const backendHost = resolveHost(appName, app, stage, dokployConfig, false);
+				try {
+					const domain = await api.createDomain({
+						host: backendHost,
+						port: app.port,
+						https: true,
+						certificateType: "letsencrypt",
+						applicationId: application.applicationId
 					});
-					logger$1.log(`      ✓ ${appName} image pushed (app already exists)`);
+					appHostnames.set(appName, backendHost);
+					appDomainIds.set(appName, domain.domainId);
+					const publicUrl = `https://${backendHost}`;
+					publicUrls[appName] = publicUrl;
+					logger$1.log(`      ✓ Domain: ${publicUrl}`);
+				} catch (domainError) {
+					appHostnames.set(appName, backendHost);
+					try {
+						const existingDomains = await api.getDomainsByApplicationId(application.applicationId);
+						const matchingDomain = existingDomains.find((d) => d.host === backendHost);
+						if (matchingDomain) appDomainIds.set(appName, matchingDomain.domainId);
+					} catch {}
+					publicUrls[appName] = `https://${backendHost}`;
+					logger$1.log(`      ℹ Domain already configured: https://${backendHost}`);
 				}
+				results.push({
+					appName,
+					type: app.type,
+					success: true,
+					applicationId: application.applicationId,
+					imageRef
+				});
+				logger$1.log(`      ✓ ${appName} deployed successfully`);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : "Unknown error";
 				logger$1.log(`      ✗ Failed to deploy ${appName}: ${message}`);
@@ -4807,16 +5349,22 @@ async function workspaceDeployCommand(workspace, options) {
 			const app = workspace.apps[appName];
 			logger$1.log(`\n   🌐 Deploying ${appName}...`);
 			try {
-				const dokployAppName = `${workspace.name}-${appName}`;
-				let application;
-				try {
-					application = await api.createApplication(dokployAppName, project.projectId, environmentId);
-					logger$1.log(`      Created application: ${application.applicationId}`);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : "Unknown error";
-					if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`      Application already exists`);
-					else throw error;
+				const dokployAppName = appName;
+				let application = null;
+				const cachedAppId = getApplicationId(state, appName);
+				if (cachedAppId) {
+					logger$1.log(`      Using cached ID: ${cachedAppId}`);
+					application = await api.getApplication(cachedAppId);
+					if (application) logger$1.log(`      ✓ Application found: ${application.applicationId}`);
+					else logger$1.log(`      ⚠ Cached ID invalid, will create new`);
 				}
+				if (!application) {
+					const result = await api.findOrCreateApplication(dokployAppName, project.projectId, environmentId);
+					application = result.application;
+					if (result.created) logger$1.log(`      Created application: ${application.applicationId}`);
+					else logger$1.log(`      Found existing application: ${application.applicationId}`);
+				}
+				setApplicationId(state, appName, application.applicationId);
 				const buildArgs = generatePublicUrlBuildArgs(app, publicUrls);
 				if (buildArgs.length > 0) logger$1.log(`      Public URLs: ${buildArgs.join(", ")}`);
 				const imageName = `${workspace.name}-${appName}`;
@@ -4835,49 +5383,43 @@ async function workspaceDeployCommand(workspace, options) {
 					publicUrlArgs: getPublicUrlArgNames(app)
 				});
 				const envVars = [`NODE_ENV=production`, `PORT=${app.port}`];
-				if (application) {
-					await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
-					await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
-					logger$1.log(`      Deploying to Dokploy...`);
-					await api.deployApplication(application.applicationId);
-					const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
-					try {
-						const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
-						await api.createDomain({
-							host,
-							port: app.port,
-							https: true,
-							certificateType: "letsencrypt",
-							applicationId: application.applicationId
-						});
-						const publicUrl = `https://${host}`;
-						publicUrls[appName] = publicUrl;
-						logger$1.log(`      ✓ Domain: ${publicUrl}`);
-					} catch (domainError) {
-						const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
-						publicUrls[appName] = `https://${host}`;
-						logger$1.log(`      ℹ Domain already configured: https://${host}`);
-					}
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						applicationId: application.applicationId,
-						imageRef
-					});
-					logger$1.log(`      ✓ ${appName} deployed successfully`);
-				} else {
-					const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
-					const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
-					publicUrls[appName] = `https://${host}`;
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						imageRef
+				await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
+				await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
+				logger$1.log(`      Deploying to Dokploy...`);
+				await api.deployApplication(application.applicationId);
+				const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
+				const frontendHost = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
+				try {
+					const domain = await api.createDomain({
+						host: frontendHost,
+						port: app.port,
+						https: true,
+						certificateType: "letsencrypt",
+						applicationId: application.applicationId
 					});
-					logger$1.log(`      ✓ ${appName} image pushed (app already exists)`);
+					appHostnames.set(appName, frontendHost);
+					appDomainIds.set(appName, domain.domainId);
+					const publicUrl = `https://${frontendHost}`;
+					publicUrls[appName] = publicUrl;
+					logger$1.log(`      ✓ Domain: ${publicUrl}`);
+				} catch (domainError) {
+					appHostnames.set(appName, frontendHost);
+					try {
+						const existingDomains = await api.getDomainsByApplicationId(application.applicationId);
+						const matchingDomain = existingDomains.find((d) => d.host === frontendHost);
+						if (matchingDomain) appDomainIds.set(appName, matchingDomain.domainId);
+					} catch {}
+					publicUrls[appName] = `https://${frontendHost}`;
+					logger$1.log(`      ℹ Domain already configured: https://${frontendHost}`);
 				}
+				results.push({
+					appName,
+					type: app.type,
+					success: true,
+					applicationId: application.applicationId,
+					imageRef
+				});
+				logger$1.log(`      ✓ ${appName} deployed successfully`);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : "Unknown error";
 				logger$1.log(`      ✗ Failed to deploy ${appName}: ${message}`);
@@ -4890,6 +5432,23 @@ async function workspaceDeployCommand(workspace, options) {
 			}
 		}
 	}
+	logger$1.log("\n📋 Saving deploy state...");
+	await writeStageState(workspace.root, stage, state);
+	logger$1.log(`   ✓ State saved to .gkm/deploy-${stage}.json`);
+	const dnsConfig = workspace.deploy.dns;
+	if (dnsConfig && appHostnames.size > 0) {
+		const dnsResult = await orchestrateDns(appHostnames, dnsConfig, creds.endpoint);
+		if (dnsResult?.success && appDomainIds.size > 0) {
+			logger$1.log("\n🔒 Validating domains for SSL certificates...");
+			for (const [appName, domainId] of appDomainIds) try {
+				await api.validateDomain(domainId);
+				logger$1.log(`   ✓ ${appName}: SSL validation triggered`);
+			} catch (validationError) {
+				const message = validationError instanceof Error ? validationError.message : "Unknown error";
+				logger$1.log(`   ⚠ ${appName}: SSL validation failed - ${message}`);
+			}
+		}
+	}
 	const successCount = results.filter((r) => r.success).length;
 	const failedCount = results.filter((r) => !r.success).length;
 	logger$1.log(`\n${"─".repeat(50)}`);