@geekmidas/cli 0.13.0 → 0.15.0

package/dist/index.cjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env -S npx tsx
 const require_chunk = require('./chunk-CUT6urMc.cjs');
 const require_config = require('./config-AmInkU7k.cjs');
-const require_openapi = require('./openapi-Bt_1FDpT.cjs');
-const require_openapi_react_query = require('./openapi-react-query-B-sNWHFU.cjs');
-const require_storage = require('./storage-Bj1E26lU.cjs');
+const require_openapi = require('./openapi-C89hhkZC.cjs');
+const require_dokploy_api = require('./dokploy-api-C7F9VykY.cjs');
+const require_openapi_react_query = require('./openapi-react-query-iKjfLzff.cjs');
+const require_storage = require('./storage-Bn3K9Ccu.cjs');
 const node_fs = require_chunk.__toESM(require("node:fs"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const commander = require_chunk.__toESM(require("commander"));
@@ -24,7 +25,7 @@ const node_crypto = require_chunk.__toESM(require("node:crypto"));
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.13.0";
+var version = "0.15.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -170,7 +171,8 @@ async function getDokployCredentials(options) {
 	if (!credentials.dokploy) return null;
 	return {
 		token: credentials.dokploy.token,
-		endpoint: credentials.dokploy.endpoint
+		endpoint: credentials.dokploy.endpoint,
+		registryId: credentials.dokploy.registryId
 	};
 }
 /**
@@ -193,6 +195,22 @@ async function getDokployToken(options) {
 	if (stored) return stored.token;
 	return null;
 }
+/**
+* Store Dokploy registry ID
+*/
+async function storeDokployRegistryId(registryId, options) {
+	const credentials = await readCredentials(options);
+	if (!credentials.dokploy) throw new Error("Dokploy credentials not found. Run \"gkm login --service dokploy\" first.");
+	credentials.dokploy.registryId = registryId;
+	await writeCredentials(credentials, options);
+}
+/**
+* Get Dokploy registry ID from stored credentials
+*/
+async function getDokployRegistryId(options) {
+	const stored = await getDokployCredentials(options);
+	return stored?.registryId ?? void 0;
+}
 
 //#endregion
 //#region src/auth/index.ts
@@ -201,52 +219,61 @@ const logger$9 = console;
 * Validate Dokploy token by making a test API call
 */
 async function validateDokployToken(endpoint, token) {
-	try {
-		const response = await fetch(`${endpoint}/api/project.all`, {
-			method: "GET",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${token}`
-			}
-		});
-		return response.ok;
-	} catch {
-		return false;
-	}
+	const { DokployApi: DokployApi$1 } = await Promise.resolve().then(() => require("./dokploy-api-B7KxOQr3.cjs"));
+	const api = new DokployApi$1({
+		baseUrl: endpoint,
+		token
+	});
+	return api.validateToken();
 }
 /**
 * Prompt for input (handles both TTY and non-TTY)
 */
-async function prompt(message, hidden = false) {
+async function prompt$1(message, hidden = false) {
 	if (!process.stdin.isTTY) throw new Error("Interactive input required. Please provide --token option.");
-	const rl = node_readline_promises.createInterface({
-		input: node_process.stdin,
-		output: node_process.stdout
-	});
-	try {
-		if (hidden) {
-			process.stdout.write(message);
-			return new Promise((resolve$1) => {
-				let value = "";
-				const onData = (char) => {
-					const c = char.toString();
-					if (c === "\n" || c === "\r") {
-						process.stdin.removeListener("data", onData);
-						process.stdin.setRawMode(false);
-						process.stdout.write("\n");
-						resolve$1(value);
-					} else if (c === "") process.exit(1);
-					else if (c === "" || c === "\b") {
-						if (value.length > 0) value = value.slice(0, -1);
-					} else value += c;
-				};
-				process.stdin.setRawMode(true);
-				process.stdin.resume();
-				process.stdin.on("data", onData);
-			});
-		} else return await rl.question(message);
-	} finally {
-		rl.close();
+	if (hidden) {
+		process.stdout.write(message);
+		return new Promise((resolve$1, reject) => {
+			let value = "";
+			const cleanup = () => {
+				process.stdin.setRawMode(false);
+				process.stdin.pause();
+				process.stdin.removeListener("data", onData);
+				process.stdin.removeListener("error", onError);
+			};
+			const onError = (err) => {
+				cleanup();
+				reject(err);
+			};
+			const onData = (char) => {
+				const c = char.toString();
+				if (c === "\n" || c === "\r") {
+					cleanup();
+					process.stdout.write("\n");
+					resolve$1(value);
+				} else if (c === "") {
+					cleanup();
+					process.stdout.write("\n");
+					process.exit(1);
+				} else if (c === "" || c === "\b") {
+					if (value.length > 0) value = value.slice(0, -1);
+				} else value += c;
+			};
+			process.stdin.setRawMode(true);
+			process.stdin.resume();
+			process.stdin.on("data", onData);
+			process.stdin.on("error", onError);
+		});
+	} else {
+		const rl = node_readline_promises.createInterface({
+			input: node_process.stdin,
+			output: node_process.stdout
+		});
+		try {
+			return await rl.question(message);
+		} finally {
+			rl.close();
+		}
 	}
 }
 /**
@@ -257,7 +284,7 @@ async function loginCommand(options) {
 	if (service === "dokploy") {
 		logger$9.log("\n🔐 Logging in to Dokploy...\n");
 		let endpoint = providedEndpoint;
-		if (!endpoint) endpoint = await prompt("Dokploy URL (e.g., https://dokploy.example.com): ");
+		if (!endpoint) endpoint = await prompt$1("Dokploy URL (e.g., https://dokploy.example.com): ");
 		endpoint = endpoint.replace(/\/$/, "");
 		try {
 			new URL(endpoint);
@@ -268,7 +295,7 @@ async function loginCommand(options) {
 		let token = providedToken;
 		if (!token) {
 			logger$9.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
-			token = await prompt("API Token: ", true);
+			token = await prompt$1("API Token: ", true);
 		}
 		if (!token) {
 			logger$9.error("Token is required");
@@ -1057,9 +1084,9 @@ var DevServer = class {
 	}
 	async createServerEntry() {
 		const { writeFile: writeFile$8 } = await import("node:fs/promises");
-		const { relative: relative$5, dirname: dirname$5 } = await import("node:path");
+		const { relative: relative$6, dirname: dirname$6 } = await import("node:path");
 		const serverPath = (0, node_path.join)(process.cwd(), ".gkm", this.provider, "server.ts");
-		const relativeAppPath = relative$5(dirname$5(serverPath), (0, node_path.join)(dirname$5(serverPath), "app.js"));
+		const relativeAppPath = relative$6(dirname$6(serverPath), (0, node_path.join)(dirname$6(serverPath), "app.js"));
 		const serveCode = this.runtime === "bun" ? `Bun.serve({
       port,
       fetch: app.fetch,
@@ -1189,6 +1216,16 @@ async function buildCommand(options) {
 	if (studio) logger$6.log(`🗄️  Studio enabled at ${studio.path}`);
 	const hooks = normalizeHooksConfig(config.hooks);
 	if (hooks) logger$6.log(`🪝 Server hooks enabled`);
+	const services = config.docker?.compose?.services;
+	const dockerServices = services ? Array.isArray(services) ? {
+		postgres: services.includes("postgres"),
+		redis: services.includes("redis"),
+		rabbitmq: services.includes("rabbitmq")
+	} : {
+		postgres: Boolean(services.postgres),
+		redis: Boolean(services.redis),
+		rabbitmq: Boolean(services.rabbitmq)
+	} : void 0;
 	const buildContext = {
 		envParserPath,
 		envParserImportPattern,
@@ -1197,7 +1234,8 @@ async function buildCommand(options) {
 		telescope,
 		studio,
 		hooks,
-		production
+		production,
+		dockerServices
 	};
 	const endpointGenerator = new require_openapi.EndpointGenerator();
 	const functionGenerator = new FunctionGenerator();
@@ -1255,13 +1293,14 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 		let masterKey;
 		if (context.production?.bundle && !skipBundle) {
 			logger$6.log(`\n📦 Bundling production server...`);
-			const { bundleServer } = await Promise.resolve().then(() => require("./bundler-B1qy9b-j.cjs"));
+			const { bundleServer } = await Promise.resolve().then(() => require("./bundler-Nuew7Xcn.cjs"));
 			const allConstructs = [
 				...endpoints.map((e) => e.construct),
 				...functions.map((f) => f.construct),
 				...crons.map((c) => c.construct),
 				...subscribers.map((s) => s.construct)
 			];
+			const dockerServices = context.dockerServices;
 			const bundleResult = await bundleServer({
 				entryPoint: (0, node_path.join)(outputDir, "server.ts"),
 				outputDir: (0, node_path.join)(outputDir, "dist"),
@@ -1269,7 +1308,8 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 				sourcemap: false,
 				external: context.production.external,
 				stage,
-				constructs: allConstructs
+				constructs: allConstructs,
+				dockerServices
 			});
 			masterKey = bundleResult.masterKey;
 			logger$6.log(`✅ Bundle complete: .gkm/server/dist/server.mjs`);
@@ -1284,366 +1324,1008 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 }
 
 //#endregion
-//#region src/deploy/docker.ts
-const logger$5 = console;
-/**
-* Get the full image reference
-*/
-function getImageRef(registry, imageName, tag) {
-	if (registry) return `${registry}/${imageName}:${tag}`;
-	return `${imageName}:${tag}`;
+//#region src/docker/compose.ts
+/** Default Docker images for services */
+const DEFAULT_SERVICE_IMAGES = {
+	postgres: "postgres",
+	redis: "redis",
+	rabbitmq: "rabbitmq"
+};
+/** Default Docker image versions for services */
+const DEFAULT_SERVICE_VERSIONS = {
+	postgres: "16-alpine",
+	redis: "7-alpine",
+	rabbitmq: "3-management-alpine"
+};
+/** Get the default full image reference for a service */
+function getDefaultImage(serviceName) {
+	return `${DEFAULT_SERVICE_IMAGES[serviceName]}:${DEFAULT_SERVICE_VERSIONS[serviceName]}`;
 }
-/**
-* Build Docker image
-*/
-async function buildImage(imageRef) {
-	logger$5.log(`\n🔨 Building Docker image: ${imageRef}`);
-	try {
-		(0, node_child_process.execSync)(`DOCKER_BUILDKIT=1 docker build -f .gkm/docker/Dockerfile -t ${imageRef} .`, {
-			cwd: process.cwd(),
-			stdio: "inherit",
-			env: {
-				...process.env,
-				DOCKER_BUILDKIT: "1"
+/** Normalize services config to a consistent format - returns Map of service name to full image reference */
+function normalizeServices(services) {
+	const result = /* @__PURE__ */ new Map();
+	if (Array.isArray(services)) for (const name$1 of services) result.set(name$1, getDefaultImage(name$1));
+	else for (const [name$1, config] of Object.entries(services)) {
+		const serviceName = name$1;
+		if (config === true) result.set(serviceName, getDefaultImage(serviceName));
+		else if (config && typeof config === "object") {
+			const serviceConfig = config;
+			if (serviceConfig.image) result.set(serviceName, serviceConfig.image);
+			else {
+				const version$1 = serviceConfig.version ?? DEFAULT_SERVICE_VERSIONS[serviceName];
+				result.set(serviceName, `${DEFAULT_SERVICE_IMAGES[serviceName]}:${version$1}`);
 			}
-		});
-		logger$5.log(`✅ Image built: ${imageRef}`);
-	} catch (error) {
-		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
 	}
+	return result;
 }
 /**
-* Push Docker image to registry
+* Generate docker-compose.yml for production deployment
 */
-async function pushImage(imageRef) {
-	logger$5.log(`\n☁️  Pushing image: ${imageRef}`);
-	try {
-		(0, node_child_process.execSync)(`docker push ${imageRef}`, {
-			cwd: process.cwd(),
-			stdio: "inherit"
-		});
-		logger$5.log(`✅ Image pushed: ${imageRef}`);
-	} catch (error) {
-		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+function generateDockerCompose(options) {
+	const { imageName, registry, port, healthCheckPath, services } = options;
+	const serviceMap = normalizeServices(services);
+	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : "";
+	let yaml = `version: '3.8'
+
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: .gkm/docker/Dockerfile
+    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
+    container_name: ${imageName}
+    restart: unless-stopped
+    ports:
+      - "\${PORT:-${port}}:${port}"
+    environment:
+      - NODE_ENV=production
+`;
+	if (serviceMap.has("postgres")) yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}
+`;
+	if (serviceMap.has("redis")) yaml += `      - REDIS_URL=\${REDIS_URL:-redis://redis:6379}
+`;
+	if (serviceMap.has("rabbitmq")) yaml += `      - RABBITMQ_URL=\${RABBITMQ_URL:-amqp://rabbitmq:5672}
+`;
+	yaml += `    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+`;
+	if (serviceMap.size > 0) {
+		yaml += `    depends_on:
+`;
+		for (const serviceName of serviceMap.keys()) yaml += `      ${serviceName}:
+        condition: service_healthy
+`;
 	}
+	yaml += `    networks:
+      - app-network
+`;
+	const postgresImage = serviceMap.get("postgres");
+	if (postgresImage) yaml += `
+  postgres:
+    image: ${postgresImage}
+    container_name: postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: \${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-app}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	const redisImage = serviceMap.get("redis");
+	if (redisImage) yaml += `
+  redis:
+    image: ${redisImage}
+    container_name: redis
+    restart: unless-stopped
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	const rabbitmqImage = serviceMap.get("rabbitmq");
+	if (rabbitmqImage) yaml += `
+  rabbitmq:
+    image: ${rabbitmqImage}
+    container_name: rabbitmq
+    restart: unless-stopped
+    environment:
+      RABBITMQ_DEFAULT_USER: \${RABBITMQ_USER:-guest}
+      RABBITMQ_DEFAULT_PASS: \${RABBITMQ_PASSWORD:-guest}
+    ports:
+      - "15672:15672"  # Management UI
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+    healthcheck:
+      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	yaml += `
+volumes:
+`;
+	if (serviceMap.has("postgres")) yaml += `  postgres_data:
+`;
+	if (serviceMap.has("redis")) yaml += `  redis_data:
+`;
+	if (serviceMap.has("rabbitmq")) yaml += `  rabbitmq_data:
+`;
+	yaml += `
+networks:
+  app-network:
+    driver: bridge
+`;
+	return yaml;
 }
 /**
-* Deploy using Docker (build and optionally push image)
+* Generate a minimal docker-compose.yml for API only
 */
-async function deployDocker(options) {
-	const { stage, tag, skipPush, masterKey, config } = options;
-	const imageName = config.imageName ?? "app";
-	const imageRef = getImageRef(config.registry, imageName, tag);
-	await buildImage(imageRef);
-	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$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$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,
-		masterKey
-	};
+function generateMinimalDockerCompose(options) {
+	const { imageName, registry, port, healthCheckPath } = options;
+	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : "";
+	return `version: '3.8'
+
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: .gkm/docker/Dockerfile
+    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
+    container_name: ${imageName}
+    restart: unless-stopped
+    ports:
+      - "\${PORT:-${port}}:${port}"
+    environment:
+      - NODE_ENV=production
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+    networks:
+      - app-network
+
+networks:
+  app-network:
+    driver: bridge
+`;
 }
+
+//#endregion
+//#region src/docker/templates.ts
+const LOCKFILES = [
+	["pnpm-lock.yaml", "pnpm"],
+	["bun.lockb", "bun"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"]
+];
 /**
-* Resolve Docker deploy config from gkm config
+* Detect package manager from lockfiles
+* Walks up the directory tree to find lockfile (for monorepos)
 */
-function resolveDockerConfig$1(config) {
-	return {
-		registry: config.docker?.registry,
-		imageName: config.docker?.imageName
-	};
+function detectPackageManager$1(cwd = process.cwd()) {
+	let dir = cwd;
+	const root = (0, node_path.parse)(dir).root;
+	while (dir !== root) {
+		for (const [lockfile, pm] of LOCKFILES) if ((0, node_fs.existsSync)((0, node_path.join)(dir, lockfile))) return pm;
+		dir = (0, node_path.dirname)(dir);
+	}
+	for (const [lockfile, pm] of LOCKFILES) if ((0, node_fs.existsSync)((0, node_path.join)(root, lockfile))) return pm;
+	return "pnpm";
 }
-
-//#endregion
-//#region src/deploy/dokploy.ts
-const logger$4 = console;
 /**
-* Get the Dokploy API token from stored credentials or environment
+* Find the lockfile path by walking up the directory tree
+* Returns the full path to the lockfile, or null if not found
 */
-async function getApiToken$1() {
-	const token = await getDokployToken();
-	if (!token) throw new Error("Dokploy credentials not found.\nRun \"gkm login --service dokploy\" to authenticate, or set DOKPLOY_API_TOKEN.");
-	return token;
+function findLockfilePath(cwd = process.cwd()) {
+	let dir = cwd;
+	const root = (0, node_path.parse)(dir).root;
+	while (dir !== root) {
+		for (const [lockfile] of LOCKFILES) {
+			const lockfilePath = (0, node_path.join)(dir, lockfile);
+			if ((0, node_fs.existsSync)(lockfilePath)) return lockfilePath;
+		}
+		dir = (0, node_path.dirname)(dir);
+	}
+	for (const [lockfile] of LOCKFILES) {
+		const lockfilePath = (0, node_path.join)(root, lockfile);
+		if ((0, node_fs.existsSync)(lockfilePath)) return lockfilePath;
+	}
+	return null;
 }
 /**
-* Make a request to the Dokploy API
+* Check if we're in a monorepo (lockfile is in a parent directory)
 */
-async function dokployRequest$1(endpoint, baseUrl, token, body) {
-	const url = `${baseUrl}/api/${endpoint}`;
-	const response = await fetch(url, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${token}`
-		},
-		body: JSON.stringify(body)
-	});
-	if (!response.ok) {
-		let errorMessage = `Dokploy API error: ${response.status} ${response.statusText}`;
-		try {
-			const errorBody = await response.json();
-			if (errorBody.message) errorMessage = `Dokploy API error: ${errorBody.message}`;
-			if (errorBody.issues?.length) errorMessage += `\n  Issues: ${errorBody.issues.map((i) => i.message).join(", ")}`;
-		} catch {}
-		throw new Error(errorMessage);
-	}
-	return response.json();
+function isMonorepo(cwd = process.cwd()) {
+	const lockfilePath = findLockfilePath(cwd);
+	if (!lockfilePath) return false;
+	const lockfileDir = (0, node_path.dirname)(lockfilePath);
+	return lockfileDir !== cwd;
 }
 /**
-* Update application environment variables
+* Check if turbo.json exists (walks up directory tree)
 */
-async function updateEnvironment(baseUrl, token, applicationId, envVars) {
-	logger$4.log("  Updating environment variables...");
-	const envString = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-	await dokployRequest$1("application.update", baseUrl, token, {
-		applicationId,
-		env: envString
-	});
-	logger$4.log("  ✓ Environment variables updated");
+function hasTurboConfig(cwd = process.cwd()) {
+	let dir = cwd;
+	const root = (0, node_path.parse)(dir).root;
+	while (dir !== root) {
+		if ((0, node_fs.existsSync)((0, node_path.join)(dir, "turbo.json"))) return true;
+		dir = (0, node_path.dirname)(dir);
+	}
+	return (0, node_fs.existsSync)((0, node_path.join)(root, "turbo.json"));
 }
 /**
-* Trigger application deployment
+* Get install command for turbo builds (without frozen lockfile)
+* Turbo prune creates a subset that may not perfectly match the lockfile
 */
-async function triggerDeploy(baseUrl, token, applicationId) {
-	logger$4.log("  Triggering deployment...");
-	await dokployRequest$1("application.deploy", baseUrl, token, { applicationId });
-	logger$4.log("  ✓ Deployment triggered");
+function getTurboInstallCmd(pm) {
+	const commands = {
+		pnpm: "pnpm install",
+		npm: "npm install",
+		yarn: "yarn install",
+		bun: "bun install"
+	};
+	return commands[pm];
 }
 /**
-* Deploy to Dokploy
+* Get package manager specific commands and paths
 */
-async function deployDokploy(options) {
-	const { stage, imageRef, masterKey, config } = options;
-	logger$4.log(`\n🎯 Deploying to Dokploy...`);
-	logger$4.log(`   Endpoint: ${config.endpoint}`);
-	logger$4.log(`   Application: ${config.applicationId}`);
-	const token = await getApiToken$1();
-	const envVars = {};
-	if (masterKey) envVars.GKM_MASTER_KEY = masterKey;
-	if (Object.keys(envVars).length > 0) await updateEnvironment(config.endpoint, token, config.applicationId, envVars);
-	await triggerDeploy(config.endpoint, token, config.applicationId);
-	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$4.log(`\n🔗 View deployment: ${deploymentUrl}`);
-	return {
-		imageRef,
-		masterKey,
-		url: deploymentUrl
+function getPmConfig(pm) {
+	const configs = {
+		pnpm: {
+			install: "corepack enable && corepack prepare pnpm@latest --activate",
+			lockfile: "pnpm-lock.yaml",
+			fetch: "pnpm fetch",
+			installCmd: "pnpm install --frozen-lockfile --offline",
+			cacheTarget: "/root/.local/share/pnpm/store",
+			cacheId: "pnpm",
+			run: "pnpm",
+			dlx: "pnpm dlx",
+			addGlobal: "pnpm add -g"
+		},
+		npm: {
+			install: "",
+			lockfile: "package-lock.json",
+			fetch: "",
+			installCmd: "npm ci",
+			cacheTarget: "/root/.npm",
+			cacheId: "npm",
+			run: "npm run",
+			dlx: "npx",
+			addGlobal: "npm install -g"
+		},
+		yarn: {
+			install: "corepack enable && corepack prepare yarn@stable --activate",
+			lockfile: "yarn.lock",
+			fetch: "",
+			installCmd: "yarn install --frozen-lockfile",
+			cacheTarget: "/root/.yarn/cache",
+			cacheId: "yarn",
+			run: "yarn",
+			dlx: "yarn dlx",
+			addGlobal: "yarn global add"
+		},
+		bun: {
+			install: "npm install -g bun",
+			lockfile: "bun.lockb",
+			fetch: "",
+			installCmd: "bun install --frozen-lockfile",
+			cacheTarget: "/root/.bun/install/cache",
+			cacheId: "bun",
+			run: "bun run",
+			dlx: "bunx",
+			addGlobal: "bun add -g"
+		}
 	};
+	return configs[pm];
 }
 /**
-* Validate Dokploy configuration
+* Generate a multi-stage Dockerfile for building from source
+* Optimized for build speed with:
+* - BuildKit cache mounts for package manager store
+* - pnpm fetch for better layer caching (when using pnpm)
+* - Optional turbo prune for monorepos
 */
-function validateDokployConfig(config) {
-	if (!config) return false;
-	const required = [
-		"endpoint",
-		"projectId",
-		"applicationId"
-	];
-	const missing = required.filter((key) => !config[key]);
-	if (missing.length > 0) throw new Error(`Missing Dokploy configuration: ${missing.join(", ")}\nConfigure in gkm.config.ts:
-  providers: {
-    dokploy: {
-      endpoint: 'https://dokploy.example.com',
-      projectId: 'proj_xxx',
-      applicationId: 'app_xxx',
-    },
-  }`);
-	return true;
-}
+function generateMultiStageDockerfile(options) {
+	const { baseImage, port, healthCheckPath, turbo, turboPackage, packageManager } = options;
+	if (turbo) return generateTurboDockerfile({
+		...options,
+		turboPackage: turboPackage ?? "api"
+	});
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `\n# Install ${packageManager}\nRUN ${pm.install}\n` : "";
+	const hasFetch = packageManager === "pnpm";
+	const depsStage = hasFetch ? `# Copy lockfile first for better caching
+COPY ${pm.lockfile} ./
 
-//#endregion
-//#region src/deploy/index.ts
-const logger$3 = console;
+# Fetch dependencies (downloads to virtual store, cached separately)
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${pm.fetch}
+
+# Copy package.json after fetch
+COPY package.json ./
+
+# Install from cache (fast - no network needed)
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${pm.installCmd}` : `# Copy package files
+COPY package.json ${pm.lockfile} ./
+
+# Install dependencies with cache
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${pm.installCmd}`;
+	return `# syntax=docker/dockerfile:1
+# Stage 1: Dependencies
+FROM ${baseImage} AS deps
+
+WORKDIR /app
+${installPm}
+${depsStage}
+
+# Stage 2: Build
+FROM deps AS builder
+
+WORKDIR /app
+
+# Copy source (deps already installed)
+COPY . .
+
+# Build production server using CLI from npm
+RUN ${pm.dlx} @geekmidas/cli build --provider server --production
+
+# Stage 3: Production
+FROM ${baseImage} AS runner
+
+WORKDIR /app
+
+# Install tini for proper signal handling as PID 1
+RUN apk add --no-cache tini
+
+# Create non-root user
+RUN addgroup --system --gid 1001 nodejs && \\
+    adduser --system --uid 1001 hono
+
+# Copy bundled server
+COPY --from=builder --chown=hono:nodejs /app/.gkm/server/dist/server.mjs ./
+
+# Environment
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
+
+# Switch to non-root user
+USER hono
+
+EXPOSE ${port}
+
+# Use tini as entrypoint to handle PID 1 responsibilities
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["node", "server.mjs"]
+`;
+}
 /**
-* Generate image tag from stage and timestamp
+* Generate a Dockerfile optimized for Turbo monorepos
+* Uses turbo prune to create minimal Docker context
 */
-function generateTag(stage) {
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-	return `${stage}-${timestamp}`;
+function generateTurboDockerfile(options) {
+	const { baseImage, port, healthCheckPath, turboPackage, packageManager } = options;
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `RUN ${pm.install}` : "";
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
+	const turboCmd = packageManager === "pnpm" ? "pnpm dlx turbo" : "npx turbo";
+	return `# syntax=docker/dockerfile:1
+# Stage 1: Prune monorepo
+FROM ${baseImage} AS pruner
+
+WORKDIR /app
+
+${installPm}
+
+COPY . .
+
+# Prune to only include necessary packages
+RUN ${turboCmd} prune ${turboPackage} --docker
+
+# Stage 2: Install dependencies
+FROM ${baseImage} AS deps
+
+WORKDIR /app
+
+${installPm}
+
+# Copy pruned lockfile and package.jsons
+COPY --from=pruner /app/out/${pm.lockfile} ./
+COPY --from=pruner /app/out/json/ ./
+
+# Install dependencies (no frozen-lockfile since turbo prune creates a subset)
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
+
+# Stage 3: Build
+FROM deps AS builder
+
+WORKDIR /app
+
+# Copy pruned source
+COPY --from=pruner /app/out/full/ ./
+
+# Build production server using CLI from npm
+RUN ${pm.dlx} @geekmidas/cli build --provider server --production
+
+# Stage 4: Production
+FROM ${baseImage} AS runner
+
+WORKDIR /app
+
+RUN apk add --no-cache tini
+
+RUN addgroup --system --gid 1001 nodejs && \\
+    adduser --system --uid 1001 hono
+
+COPY --from=builder --chown=hono:nodejs /app/.gkm/server/dist/server.mjs ./
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
+
+USER hono
+
+EXPOSE ${port}
+
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["node", "server.mjs"]
+`;
 }
 /**
-* Main deploy command
+* Generate a slim Dockerfile for pre-built bundles
 */
-async function deployCommand(options) {
-	const { provider, stage, tag, skipPush, skipBuild } = options;
-	logger$3.log(`\n🚀 Deploying to ${provider}...`);
-	logger$3.log(`   Stage: ${stage}`);
-	const config = await require_config.loadConfig();
-	const imageTag = tag ?? generateTag(stage);
-	logger$3.log(`   Tag: ${imageTag}`);
-	let masterKey;
-	if (!skipBuild) {
-		logger$3.log(`\n📦 Building for production...`);
-		const buildResult = await buildCommand({
-			provider: "server",
-			production: true,
-			stage
-		});
-		masterKey = buildResult.masterKey;
-	} else logger$3.log(`\n⏭️  Skipping build (--skip-build)`);
-	const dockerConfig = resolveDockerConfig$1(config);
-	const imageName = dockerConfig.imageName ?? "app";
-	const registry = dockerConfig.registry;
-	const imageRef = registry ? `${registry}/${imageName}:${imageTag}` : `${imageName}:${imageTag}`;
-	let result;
-	switch (provider) {
-		case "docker": {
-			result = await deployDocker({
-				stage,
-				tag: imageTag,
-				skipPush,
-				masterKey,
-				config: dockerConfig
-			});
-			break;
-		}
-		case "dokploy": {
-			const dokployConfigRaw = config.providers?.dokploy;
-			if (typeof dokployConfigRaw === "boolean" || !dokployConfigRaw) throw new Error("Dokploy provider requires configuration.\nConfigure in gkm.config.ts:\n  providers: {\n    dokploy: {\n      endpoint: 'https://dokploy.example.com',\n      projectId: 'proj_xxx',\n      applicationId: 'app_xxx',\n    },\n  }");
-			validateDokployConfig(dokployConfigRaw);
-			const dokployConfig = dokployConfigRaw;
-			await deployDocker({
-				stage,
-				tag: imageTag,
-				skipPush: false,
-				masterKey,
-				config: {
-					registry: dokployConfig.registry ?? dockerConfig.registry,
-					imageName: dockerConfig.imageName
-				}
-			});
-			result = await deployDokploy({
-				stage,
-				tag: imageTag,
-				imageRef,
-				masterKey,
-				config: dokployConfig
-			});
-			break;
-		}
-		case "aws-lambda": {
-			logger$3.log("\n⚠️  AWS Lambda deployment is not yet implemented.");
-			logger$3.log("   Use SST or AWS CDK for Lambda deployments.");
-			result = {
-				imageRef,
-				masterKey
-			};
-			break;
-		}
-		default: throw new Error(`Unknown deploy provider: ${provider}\nSupported providers: docker, dokploy, aws-lambda`);
-	}
-	logger$3.log("\n✅ Deployment complete!");
-	return result;
-}
+function generateSlimDockerfile(options) {
+	const { baseImage, port, healthCheckPath } = options;
+	return `# Slim Dockerfile for pre-built production bundle
+FROM ${baseImage}
 
-//#endregion
-//#region src/deploy/init.ts
-const logger$2 = console;
+WORKDIR /app
+
+# Install tini for proper signal handling as PID 1
+# Handles SIGTERM propagation and zombie process reaping
+RUN apk add --no-cache tini
+
+# Create non-root user
+RUN addgroup --system --gid 1001 nodejs && \\
+    adduser --system --uid 1001 hono
+
+# Copy pre-built bundle
+COPY .gkm/server/dist/server.mjs ./
+
+# Environment
+ENV NODE_ENV=production
+ENV PORT=${port}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
+
+# Switch to non-root user
+USER hono
+
+EXPOSE ${port}
+
+# Use tini as entrypoint to handle PID 1 responsibilities
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["node", "server.mjs"]
+`;
+}
 /**
-* Get the Dokploy API token from stored credentials or environment
+* Generate .dockerignore file
 */
-async function getApiToken() {
-	const token = await getDokployToken();
-	if (!token) throw new Error("Dokploy credentials not found.\nRun \"gkm login --service dokploy\" to authenticate, or set DOKPLOY_API_TOKEN.");
-	return token;
+function generateDockerignore() {
+	return `# Dependencies
+node_modules
+.pnpm-store
+
+# Build output (except what we need)
+.gkm/aws*
+.gkm/server/*.ts
+!.gkm/server/dist
+
+# IDE and editor
+.idea
+.vscode
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# Test files
+**/*.test.ts
+**/*.spec.ts
+**/__tests__
+coverage
+
+# Documentation
+docs
+*.md
+!README.md
+
+# Environment files (handle secrets separately)
+.env
+.env.*
+!.env.example
+
+# Docker files (don't copy recursively)
+Dockerfile*
+docker-compose*
+.dockerignore
+`;
 }
 /**
-* Make a request to the Dokploy API
+* Generate docker-entrypoint.sh for custom startup logic
 */
-async function dokployRequest(method, endpoint, baseUrl, token, body) {
-	const url = `${baseUrl}/api/${endpoint}`;
-	const response = await fetch(url, {
-		method,
-		headers: {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${token}`
-		},
-		body: body ? JSON.stringify(body) : void 0
-	});
-	if (!response.ok) {
-		let errorMessage = `Dokploy API error: ${response.status} ${response.statusText}`;
-		try {
-			const errorBody = await response.json();
-			if (errorBody.message) errorMessage = `Dokploy API error: ${errorBody.message}`;
-		} catch {}
-		throw new Error(errorMessage);
-	}
-	const text = await response.text();
-	if (!text) return {};
-	return JSON.parse(text);
+function generateDockerEntrypoint() {
+	return `#!/bin/sh
+set -e
+
+# Run any custom startup scripts here
+# Example: wait for database
+# until nc -z $DB_HOST $DB_PORT; do
+#   echo "Waiting for database..."
+#   sleep 1
+# done
+
+# Execute the main command
+exec "$@"
+`;
 }
 /**
-* Get all projects from Dokploy
+* Resolve Docker configuration from GkmConfig with defaults
 */
-async function getProjects(baseUrl, token) {
-	return dokployRequest("GET", "project.all", baseUrl, token);
+function resolveDockerConfig$1(config) {
+	const docker = config.docker ?? {};
+	let defaultImageName = "api";
+	try {
+		const pkg = require(`${process.cwd()}/package.json`);
+		if (pkg.name) defaultImageName = pkg.name.replace(/^@[^/]+\//, "");
+	} catch {}
+	return {
+		registry: docker.registry ?? "",
+		imageName: docker.imageName ?? defaultImageName,
+		baseImage: docker.baseImage ?? "node:22-alpine",
+		port: docker.port ?? 3e3,
+		compose: docker.compose
+	};
 }
+
+//#endregion
+//#region src/docker/index.ts
+const logger$5 = console;
 /**
-* Create a new project in Dokploy
+* Docker command implementation
+* Generates Dockerfile, docker-compose.yml, and related files
+*
+* Default: Multi-stage Dockerfile that builds from source inside Docker
+* --slim: Slim Dockerfile that copies pre-built bundle (requires prior build)
 */
-async function createProject(baseUrl, token, name$1, description$1) {
-	return dokployRequest("POST", "project.create", baseUrl, token, {
-		name: name$1,
-		description: description$1 || `Created by gkm CLI`
-	});
+async function dockerCommand(options) {
+	const config = await require_config.loadConfig();
+	const dockerConfig = resolveDockerConfig$1(config);
+	const serverConfig = typeof config.providers?.server === "object" ? config.providers.server : void 0;
+	const healthCheckPath = serverConfig?.production?.healthCheck ?? "/health";
+	const useSlim = options.slim === true;
+	if (useSlim) {
+		const distDir = (0, node_path.join)(process.cwd(), ".gkm", "server", "dist");
+		const hasBuild = (0, node_fs.existsSync)((0, node_path.join)(distDir, "server.mjs"));
+		if (!hasBuild) throw new Error("Slim Dockerfile requires a pre-built bundle. Run `gkm build --provider server --production` first, or omit --slim to use multi-stage build.");
+	}
+	const dockerDir = (0, node_path.join)(process.cwd(), ".gkm", "docker");
+	await (0, node_fs_promises.mkdir)(dockerDir, { recursive: true });
+	const packageManager = detectPackageManager$1();
+	const inMonorepo = isMonorepo();
+	const hasTurbo = hasTurboConfig();
+	let useTurbo = options.turbo ?? false;
+	if (inMonorepo && !useSlim) if (hasTurbo) {
+		useTurbo = true;
+		logger$5.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 = require(`${process.cwd()}/package.json`);
+		if (pkg.name) {
+			turboPackage = pkg.name;
+			logger$5.log(`   Turbo package: ${turboPackage}`);
+		}
+	} catch {}
+	const templateOptions = {
+		imageName: dockerConfig.imageName,
+		baseImage: dockerConfig.baseImage,
+		port: dockerConfig.port,
+		healthCheckPath,
+		prebuilt: useSlim,
+		turbo: useTurbo,
+		turboPackage,
+		packageManager
+	};
+	const dockerfile = useSlim ? generateSlimDockerfile(templateOptions) : generateMultiStageDockerfile(templateOptions);
+	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})`);
+	const composeOptions = {
+		imageName: dockerConfig.imageName,
+		registry: options.registry ?? dockerConfig.registry,
+		port: dockerConfig.port,
+		healthCheckPath,
+		services: dockerConfig.compose?.services ?? {}
+	};
+	const hasServices = Array.isArray(composeOptions.services) ? composeOptions.services.length > 0 : Object.keys(composeOptions.services).length > 0;
+	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");
+	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)");
+	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");
+	const result = {
+		dockerfile: dockerfilePath,
+		dockerCompose: composePath,
+		dockerignore: dockerignorePath,
+		entrypoint: entrypointPath
+	};
+	if (options.build) await buildDockerImage(dockerConfig.imageName, options);
+	if (options.push) await pushDockerImage(dockerConfig.imageName, options);
+	return result;
 }
 /**
-* Get project by ID to get environment info
+* Ensure lockfile exists in the build context
+* For monorepos, copies from workspace root if needed
+* Returns cleanup function if file was copied
 */
-async function getProject(baseUrl, token, projectId) {
-	return dokployRequest("POST", "project.one", baseUrl, token, { projectId });
+function ensureLockfile(cwd) {
+	const lockfilePath = findLockfilePath(cwd);
+	if (!lockfilePath) {
+		logger$5.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...`);
+	(0, node_fs.copyFileSync)(lockfilePath, localLockfile);
+	return () => {
+		try {
+			(0, node_fs.unlinkSync)(localLockfile);
+		} catch {}
+	};
 }
 /**
-* Create a new application in Dokploy
+* Build Docker image
+* Uses BuildKit for cache mount support
 */
-async function createApplication(baseUrl, token, name$1, projectId) {
-	const project = await getProject(baseUrl, token, projectId);
-	let environmentId;
-	const firstEnv = project.environments?.[0];
-	if (firstEnv) environmentId = firstEnv.environmentId;
-	else {
-		const env = await dokployRequest("POST", "environment.create", baseUrl, token, {
-			projectId,
-			name: "production",
-			description: "Production environment"
+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}`);
+	const cwd = process.cwd();
+	const cleanup = ensureLockfile(cwd);
+	try {
+		(0, node_child_process.execSync)(`DOCKER_BUILDKIT=1 docker build -f .gkm/docker/Dockerfile -t ${fullImageName} .`, {
+			cwd,
+			stdio: "inherit",
+			env: {
+				...process.env,
+				DOCKER_BUILDKIT: "1"
+			}
 		});
-		environmentId = env.environmentId;
+		logger$5.log(`✅ Docker image built: ${fullImageName}`);
+	} catch (error) {
+		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+	} finally {
+		cleanup?.();
 	}
-	return dokployRequest("POST", "application.create", baseUrl, token, {
-		name: name$1,
-		projectId,
-		environmentId
-	});
 }
 /**
-* Configure application for Docker registry deployment
+* Push Docker image to registry
 */
-async function configureApplicationRegistry(baseUrl, token, applicationId, registryId) {
-	await dokployRequest("POST", "application.update", baseUrl, token, {
-		applicationId,
-		registryId
+async function pushDockerImage(imageName, options) {
+	const tag = options.tag ?? "latest";
+	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}`);
+	try {
+		(0, node_child_process.execSync)(`docker push ${fullImageName}`, {
+			cwd: process.cwd(),
+			stdio: "inherit"
+		});
+		logger$5.log(`✅ Docker image pushed: ${fullImageName}`);
+	} catch (error) {
+		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+
+//#endregion
+//#region src/deploy/docker.ts
+/**
+* Get app name from package.json in the current working directory
+* Used for Dokploy app/project naming
+*/
+function getAppNameFromCwd() {
+	const packageJsonPath = (0, node_path.join)(process.cwd(), "package.json");
+	if (!(0, node_fs.existsSync)(packageJsonPath)) return void 0;
+	try {
+		const pkg = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf-8"));
+		if (pkg.name) return pkg.name.replace(/^@[^/]+\//, "");
+	} catch {}
+	return void 0;
+}
+/**
+* Get app name from package.json adjacent to the lockfile (project root)
+* Used for Docker image naming
+*/
+function getAppNameFromPackageJson() {
+	const cwd = process.cwd();
+	const lockfilePath = findLockfilePath(cwd);
+	if (!lockfilePath) return void 0;
+	const projectRoot = (0, node_path.dirname)(lockfilePath);
+	const packageJsonPath = (0, node_path.join)(projectRoot, "package.json");
+	if (!(0, node_fs.existsSync)(packageJsonPath)) return void 0;
+	try {
+		const pkg = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf-8"));
+		if (pkg.name) return pkg.name.replace(/^@[^/]+\//, "");
+	} catch {}
+	return void 0;
+}
+const logger$4 = console;
+/**
+* Get the full image reference
+*/
+function getImageRef(registry, imageName, tag) {
+	if (registry) return `${registry}/${imageName}:${tag}`;
+	return `${imageName}:${tag}`;
+}
+/**
+* Build Docker image
+*/
+async function buildImage(imageRef) {
+	logger$4.log(`\n🔨 Building Docker image: ${imageRef}`);
+	const cwd = process.cwd();
+	const inMonorepo = isMonorepo(cwd);
+	if (inMonorepo) logger$4.log("   Generating Dockerfile for monorepo (turbo prune)...");
+	else logger$4.log("   Generating Dockerfile...");
+	await dockerCommand({});
+	let buildCwd = cwd;
+	let dockerfilePath = ".gkm/docker/Dockerfile";
+	if (inMonorepo) {
+		const lockfilePath = findLockfilePath(cwd);
+		if (lockfilePath) {
+			const monorepoRoot = (0, node_path.dirname)(lockfilePath);
+			const appRelPath = (0, node_path.relative)(monorepoRoot, cwd);
+			dockerfilePath = (0, node_path.join)(appRelPath, ".gkm/docker/Dockerfile");
+			buildCwd = monorepoRoot;
+			logger$4.log(`   Building from monorepo root: ${monorepoRoot}`);
+		}
+	}
+	try {
+		(0, node_child_process.execSync)(`DOCKER_BUILDKIT=1 docker build --platform linux/amd64 -f ${dockerfilePath} -t ${imageRef} .`, {
+			cwd: buildCwd,
+			stdio: "inherit",
+			env: {
+				...process.env,
+				DOCKER_BUILDKIT: "1"
+			}
+		});
+		logger$4.log(`✅ Image built: ${imageRef}`);
+	} catch (error) {
+		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Push Docker image to registry
+*/
+async function pushImage(imageRef) {
+	logger$4.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}`);
+	} catch (error) {
+		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Deploy using Docker (build and optionally push image)
+*/
+async function deployDocker(options) {
+	const { stage, tag, skipPush, masterKey, config } = options;
+	const imageName = config.imageName;
+	const imageRef = getImageRef(config.registry, imageName, tag);
+	await buildImage(imageRef);
+	if (!skipPush) if (!config.registry) logger$4.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}`);
+	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}`);
+	}
+	return {
+		imageRef,
+		masterKey
+	};
+}
+/**
+* Resolve Docker deploy config from gkm config
+* - imageName: from config, or cwd package.json, or 'app' (for Docker image)
+* - projectName: from root package.json, or 'app' (for Dokploy project)
+* - appName: from cwd package.json, or projectName (for Dokploy app within project)
+*/
+function resolveDockerConfig(config) {
+	const projectName = getAppNameFromPackageJson() ?? "app";
+	const appName = getAppNameFromCwd() ?? projectName;
+	const imageName = config.docker?.imageName ?? appName;
+	return {
+		registry: config.docker?.registry,
+		imageName,
+		projectName,
+		appName
+	};
+}
+
+//#endregion
+//#region src/deploy/dokploy.ts
+const logger$3 = console;
+/**
+* Get the Dokploy API token from stored credentials or environment
+*/
+async function getApiToken$1() {
+	const token = await getDokployToken();
+	if (!token) throw new Error("Dokploy credentials not found.\nRun \"gkm login --service dokploy\" to authenticate, or set DOKPLOY_API_TOKEN.");
+	return token;
+}
+/**
+* Create a Dokploy API client
+*/
+async function createApi$1(endpoint) {
+	const token = await getApiToken$1();
+	return new require_dokploy_api.DokployApi({
+		baseUrl: endpoint,
+		token
 	});
 }
 /**
-* Get available registries
+* Deploy to Dokploy
+*/
+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}`);
+	const api = await createApi$1(config.endpoint);
+	logger$3.log(`  Configuring Docker image: ${imageRef}`);
+	const registryOptions = {};
+	if (config.registryId) {
+		registryOptions.registryId = config.registryId;
+		logger$3.log(`  Using Dokploy registry: ${config.registryId}`);
+	} else {
+		const storedRegistryId = await getDokployRegistryId();
+		if (storedRegistryId) {
+			registryOptions.registryId = storedRegistryId;
+			logger$3.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}`);
+		} else {
+			const username = process.env.DOCKER_REGISTRY_USERNAME;
+			const password = process.env.DOCKER_REGISTRY_PASSWORD;
+			const registryUrl = process.env.DOCKER_REGISTRY_URL || config.registry;
+			if (username && password && registryUrl) {
+				registryOptions.username = username;
+				registryOptions.password = password;
+				registryOptions.registryUrl = registryUrl;
+				logger$3.log(`  Using registry credentials from environment`);
+			}
+		}
+	}
+	await api.saveDockerProvider(config.applicationId, imageRef, registryOptions);
+	logger$3.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...");
+		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$3.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`);
+	const deploymentUrl = `${config.endpoint}/project/${config.projectId}`;
+	logger$3.log(`\n🔗 View deployment: ${deploymentUrl}`);
+	return {
+		imageRef,
+		masterKey,
+		url: deploymentUrl
+	};
+}
+
+//#endregion
+//#region src/deploy/init.ts
+const logger$2 = console;
+/**
+* Get the Dokploy API token from stored credentials or environment
+*/
+async function getApiToken() {
+	const token = await getDokployToken();
+	if (!token) throw new Error("Dokploy credentials not found.\nRun \"gkm login --service dokploy\" to authenticate, or set DOKPLOY_API_TOKEN.");
+	return token;
+}
+/**
+* Get Dokploy endpoint from options or stored credentials
 */
-async function getRegistries(baseUrl, token) {
-	return dokployRequest("GET", "registry.all", baseUrl, token);
+async function getEndpoint(providedEndpoint) {
+	if (providedEndpoint) return providedEndpoint;
+	const stored = await getDokployCredentials();
+	if (stored) return stored.endpoint;
+	throw new Error("Dokploy endpoint not specified.\nEither run \"gkm login --service dokploy\" first, or provide --endpoint.");
+}
+/**
+* Create a Dokploy API client
+*/
+async function createApi(endpoint) {
+	const token = await getApiToken();
+	return new require_dokploy_api.DokployApi({
+		baseUrl: endpoint,
+		token
+	});
 }
 /**
 * Update gkm.config.ts with Dokploy configuration
@@ -1666,25 +2348,18 @@ async function updateConfig(config, cwd = process.cwd()) {
 		logger$2.log("\n  Dokploy config already exists in gkm.config.ts");
 		logger$2.log("  Updating with new values...");
 	}
-	let newContent;
-	if (content.includes("providers:")) if (content.includes("dokploy:")) newContent = content.replace(/dokploy:\s*\{[^}]*\}/, `dokploy: {
-			endpoint: '${config.endpoint}',
-			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		}`);
-	else newContent = content.replace(/providers:\s*\{/, `providers: {
-		dokploy: {
+	const registryLine = config.registryId ? `\n\t\t\tregistryId: '${config.registryId}',` : "";
+	const dokployConfigStr = `dokploy: {
 			endpoint: '${config.endpoint}',
 			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		},`);
+			applicationId: '${config.applicationId}',${registryLine}
+		}`;
+	let newContent;
+	if (content.includes("providers:")) if (content.includes("dokploy:")) newContent = content.replace(/dokploy:\s*\{[^}]*\}/s, dokployConfigStr);
+	else newContent = content.replace(/providers:\s*\{/, `providers: {\n\t\t${dokployConfigStr},`);
 	else newContent = content.replace(/}\s*\)\s*;?\s*$/, `
 	providers: {
-		dokploy: {
-			endpoint: '${config.endpoint}',
-			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		},
+		${dokployConfigStr},
 	},
 });`);
 	await (0, node_fs_promises.writeFile)(configPath, newContent);
@@ -1695,42 +2370,46 @@ async function updateConfig(config, cwd = process.cwd()) {
 */
 async function deployInitCommand(options) {
 	const { projectName, appName, projectId: existingProjectId, registryId } = options;
-	let endpoint = options.endpoint;
-	if (!endpoint) {
-		const stored = await getDokployCredentials();
-		if (stored) endpoint = stored.endpoint;
-		else throw new Error("Dokploy endpoint not specified.\nEither run \"gkm login --service dokploy\" first, or provide --endpoint.");
-	}
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
 	logger$2.log(`\n🚀 Initializing Dokploy deployment...`);
 	logger$2.log(`   Endpoint: ${endpoint}`);
-	const token = await getApiToken();
 	let projectId;
 	if (existingProjectId) {
 		projectId = existingProjectId;
 		logger$2.log(`\n📁 Using existing project: ${projectId}`);
 	} else {
 		logger$2.log(`\n📁 Looking for project: ${projectName}`);
-		const projects = await getProjects(endpoint, token);
+		const projects = await api.listProjects();
 		const existingProject = projects.find((p) => p.name.toLowerCase() === projectName.toLowerCase());
 		if (existingProject) {
 			projectId = existingProject.projectId;
 			logger$2.log(`   Found existing project: ${projectId}`);
 		} else {
 			logger$2.log(`   Creating new project...`);
-			const project = await createProject(endpoint, token, projectName);
-			projectId = project.projectId;
+			const result = await api.createProject(projectName);
+			projectId = result.project.projectId;
 			logger$2.log(`   ✓ Created project: ${projectId}`);
 		}
 	}
+	const project = await api.getProject(projectId);
+	let environmentId;
+	const firstEnv = project.environments?.[0];
+	if (firstEnv) environmentId = firstEnv.environmentId;
+	else {
+		logger$2.log(`   Creating production environment...`);
+		const env = await api.createEnvironment(projectId, "production");
+		environmentId = env.environmentId;
+	}
 	logger$2.log(`\n📦 Creating application: ${appName}`);
-	const application = await createApplication(endpoint, token, appName, projectId);
+	const application = await api.createApplication(appName, projectId, environmentId);
 	logger$2.log(`   ✓ Created application: ${application.applicationId}`);
 	if (registryId) {
 		logger$2.log(`\n🔧 Configuring registry: ${registryId}`);
-		await configureApplicationRegistry(endpoint, token, application.applicationId, registryId);
+		await api.updateApplication(application.applicationId, { registryId });
 		logger$2.log(`   ✓ Registry configured`);
 	} else try {
-		const registries = await getRegistries(endpoint, token);
+		const registries = await api.listRegistries();
 		if (registries.length > 0) {
 			logger$2.log(`\n📋 Available registries:`);
 			for (const reg of registries) logger$2.log(`   - ${reg.registryName}: ${reg.registryUrl} (${reg.registryId})`);
@@ -1754,705 +2433,448 @@ async function deployInitCommand(options) {
 	return config;
 }
 /**
-* List available Dokploy resources
-*/
-async function deployListCommand(options) {
-	let endpoint = options.endpoint;
-	if (!endpoint) {
-		const stored = await getDokployCredentials();
-		if (stored) endpoint = stored.endpoint;
-		else throw new Error("Dokploy endpoint not specified.\nEither run \"gkm login --service dokploy\" first, or provide --endpoint.");
-	}
-	const { resource } = options;
-	const token = await getApiToken();
-	if (resource === "projects") {
-		logger$2.log(`\n📁 Projects in ${endpoint}:`);
-		const projects = await getProjects(endpoint, token);
-		if (projects.length === 0) {
-			logger$2.log("   No projects found");
-			return;
-		}
-		for (const project of projects) {
-			logger$2.log(`\n   ${project.name} (${project.projectId})`);
-			if (project.description) logger$2.log(`     ${project.description}`);
-		}
-	} else if (resource === "registries") {
-		logger$2.log(`\n🐳 Registries in ${endpoint}:`);
-		const registries = await getRegistries(endpoint, token);
-		if (registries.length === 0) {
-			logger$2.log("   No registries configured");
-			logger$2.log("   Add a registry in Dokploy: Settings > Docker Registry");
-			return;
-		}
-		for (const registry of registries) {
-			logger$2.log(`\n   ${registry.registryName} (${registry.registryId})`);
-			logger$2.log(`     URL: ${registry.registryUrl}`);
-			logger$2.log(`     Username: ${registry.username}`);
-			if (registry.imagePrefix) logger$2.log(`     Prefix: ${registry.imagePrefix}`);
-		}
-	}
-}
-
-//#endregion
-//#region src/docker/compose.ts
-/** Default Docker images for services */
-const DEFAULT_SERVICE_IMAGES = {
-	postgres: "postgres",
-	redis: "redis",
-	rabbitmq: "rabbitmq"
-};
-/** Default Docker image versions for services */
-const DEFAULT_SERVICE_VERSIONS = {
-	postgres: "16-alpine",
-	redis: "7-alpine",
-	rabbitmq: "3-management-alpine"
-};
-/** Get the default full image reference for a service */
-function getDefaultImage(serviceName) {
-	return `${DEFAULT_SERVICE_IMAGES[serviceName]}:${DEFAULT_SERVICE_VERSIONS[serviceName]}`;
-}
-/** Normalize services config to a consistent format - returns Map of service name to full image reference */
-function normalizeServices(services) {
-	const result = /* @__PURE__ */ new Map();
-	if (Array.isArray(services)) for (const name$1 of services) result.set(name$1, getDefaultImage(name$1));
-	else for (const [name$1, config] of Object.entries(services)) {
-		const serviceName = name$1;
-		if (config === true) result.set(serviceName, getDefaultImage(serviceName));
-		else if (config && typeof config === "object") {
-			const serviceConfig = config;
-			if (serviceConfig.image) result.set(serviceName, serviceConfig.image);
-			else {
-				const version$1 = serviceConfig.version ?? DEFAULT_SERVICE_VERSIONS[serviceName];
-				result.set(serviceName, `${DEFAULT_SERVICE_IMAGES[serviceName]}:${version$1}`);
-			}
-		}
-	}
-	return result;
-}
-/**
-* Generate docker-compose.yml for production deployment
-*/
-function generateDockerCompose(options) {
-	const { imageName, registry, port, healthCheckPath, services } = options;
-	const serviceMap = normalizeServices(services);
-	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : "";
-	let yaml = `version: '3.8'
-
-services:
-  api:
-    build:
-      context: ../..
-      dockerfile: .gkm/docker/Dockerfile
-    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
-    container_name: ${imageName}
-    restart: unless-stopped
-    ports:
-      - "\${PORT:-${port}}:${port}"
-    environment:
-      - NODE_ENV=production
-`;
-	if (serviceMap.has("postgres")) yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}
-`;
-	if (serviceMap.has("redis")) yaml += `      - REDIS_URL=\${REDIS_URL:-redis://redis:6379}
-`;
-	if (serviceMap.has("rabbitmq")) yaml += `      - RABBITMQ_URL=\${RABBITMQ_URL:-amqp://rabbitmq:5672}
-`;
-	yaml += `    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-`;
-	if (serviceMap.size > 0) {
-		yaml += `    depends_on:
-`;
-		for (const serviceName of serviceMap.keys()) yaml += `      ${serviceName}:
-        condition: service_healthy
-`;
-	}
-	yaml += `    networks:
-      - app-network
-`;
-	const postgresImage = serviceMap.get("postgres");
-	if (postgresImage) yaml += `
-  postgres:
-    image: ${postgresImage}
-    container_name: postgres
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: \${POSTGRES_USER:-postgres}
-      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
-      POSTGRES_DB: \${POSTGRES_DB:-app}
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-    networks:
-      - app-network
-`;
-	const redisImage = serviceMap.get("redis");
-	if (redisImage) yaml += `
-  redis:
-    image: ${redisImage}
-    container_name: redis
-    restart: unless-stopped
-    volumes:
-      - redis_data:/data
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-    networks:
-      - app-network
-`;
-	const rabbitmqImage = serviceMap.get("rabbitmq");
-	if (rabbitmqImage) yaml += `
-  rabbitmq:
-    image: ${rabbitmqImage}
-    container_name: rabbitmq
-    restart: unless-stopped
-    environment:
-      RABBITMQ_DEFAULT_USER: \${RABBITMQ_USER:-guest}
-      RABBITMQ_DEFAULT_PASS: \${RABBITMQ_PASSWORD:-guest}
-    ports:
-      - "15672:15672"  # Management UI
-    volumes:
-      - rabbitmq_data:/var/lib/rabbitmq
-    healthcheck:
-      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    networks:
-      - app-network
-`;
-	yaml += `
-volumes:
-`;
-	if (serviceMap.has("postgres")) yaml += `  postgres_data:
-`;
-	if (serviceMap.has("redis")) yaml += `  redis_data:
-`;
-	if (serviceMap.has("rabbitmq")) yaml += `  rabbitmq_data:
-`;
-	yaml += `
-networks:
-  app-network:
-    driver: bridge
-`;
-	return yaml;
-}
-/**
-* Generate a minimal docker-compose.yml for API only
-*/
-function generateMinimalDockerCompose(options) {
-	const { imageName, registry, port, healthCheckPath } = options;
-	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : "";
-	return `version: '3.8'
-
-services:
-  api:
-    build:
-      context: ../..
-      dockerfile: .gkm/docker/Dockerfile
-    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
-    container_name: ${imageName}
-    restart: unless-stopped
-    ports:
-      - "\${PORT:-${port}}:${port}"
-    environment:
-      - NODE_ENV=production
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-    networks:
-      - app-network
-
-networks:
-  app-network:
-    driver: bridge
-`;
-}
-
-//#endregion
-//#region src/docker/templates.ts
-/**
-* Detect package manager from lockfiles
-* Walks up the directory tree to find lockfile (for monorepos)
-*/
-function detectPackageManager$1(cwd = process.cwd()) {
-	const lockfiles = [
-		["pnpm-lock.yaml", "pnpm"],
-		["bun.lockb", "bun"],
-		["yarn.lock", "yarn"],
-		["package-lock.json", "npm"]
-	];
-	let dir = cwd;
-	const root = (0, node_path.parse)(dir).root;
-	while (dir !== root) {
-		for (const [lockfile, pm] of lockfiles) if ((0, node_fs.existsSync)((0, node_path.join)(dir, lockfile))) return pm;
-		dir = (0, node_path.dirname)(dir);
-	}
-	for (const [lockfile, pm] of lockfiles) if ((0, node_fs.existsSync)((0, node_path.join)(root, lockfile))) return pm;
-	return "pnpm";
-}
-/**
-* Get package manager specific commands and paths
-*/
-function getPmConfig(pm) {
-	const configs = {
-		pnpm: {
-			install: "corepack enable && corepack prepare pnpm@latest --activate",
-			lockfile: "pnpm-lock.yaml",
-			fetch: "pnpm fetch",
-			installCmd: "pnpm install --frozen-lockfile --offline",
-			cacheTarget: "/root/.local/share/pnpm/store",
-			cacheId: "pnpm",
-			run: "pnpm",
-			addGlobal: "pnpm add -g"
-		},
-		npm: {
-			install: "",
-			lockfile: "package-lock.json",
-			fetch: "",
-			installCmd: "npm ci",
-			cacheTarget: "/root/.npm",
-			cacheId: "npm",
-			run: "npm run",
-			addGlobal: "npm install -g"
-		},
-		yarn: {
-			install: "corepack enable && corepack prepare yarn@stable --activate",
-			lockfile: "yarn.lock",
-			fetch: "",
-			installCmd: "yarn install --frozen-lockfile",
-			cacheTarget: "/root/.yarn/cache",
-			cacheId: "yarn",
-			run: "yarn",
-			addGlobal: "yarn global add"
-		},
-		bun: {
-			install: "npm install -g bun",
-			lockfile: "bun.lockb",
-			fetch: "",
-			installCmd: "bun install --frozen-lockfile",
-			cacheTarget: "/root/.bun/install/cache",
-			cacheId: "bun",
-			run: "bun run",
-			addGlobal: "bun add -g"
-		}
-	};
-	return configs[pm];
-}
-/**
-* Generate a multi-stage Dockerfile for building from source
-* Optimized for build speed with:
-* - BuildKit cache mounts for package manager store
-* - pnpm fetch for better layer caching (when using pnpm)
-* - Optional turbo prune for monorepos
-*/
-function generateMultiStageDockerfile(options) {
-	const { baseImage, port, healthCheckPath, turbo, turboPackage, packageManager } = options;
-	if (turbo) return generateTurboDockerfile({
-		...options,
-		turboPackage: turboPackage ?? "api"
-	});
-	const pm = getPmConfig(packageManager);
-	const installPm = pm.install ? `\n# Install ${packageManager}\nRUN ${pm.install}\n` : "";
-	const hasFetch = packageManager === "pnpm";
-	const depsStage = hasFetch ? `# Copy lockfile first for better caching
-COPY ${pm.lockfile} ./
-
-# Fetch dependencies (downloads to virtual store, cached separately)
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.fetch}
-
-# Copy package.json after fetch
-COPY package.json ./
-
-# Install from cache (fast - no network needed)
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}` : `# Copy package files
-COPY package.json ${pm.lockfile} ./
-
-# Install dependencies with cache
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}`;
-	return `# syntax=docker/dockerfile:1
-# Stage 1: Dependencies
-FROM ${baseImage} AS deps
-
-WORKDIR /app
-${installPm}
-${depsStage}
-
-# Stage 2: Build
-FROM deps AS builder
-
-WORKDIR /app
-
-# Copy source (deps already installed)
-COPY . .
-
-# Build production server
-RUN ${pm.run} gkm build --provider server --production
-
-# Stage 3: Production
-FROM ${baseImage} AS runner
-
-WORKDIR /app
-
-# Install tini for proper signal handling as PID 1
-RUN apk add --no-cache tini
-
-# Create non-root user
-RUN addgroup --system --gid 1001 nodejs && \\
-    adduser --system --uid 1001 hono
-
-# Copy bundled server
-COPY --from=builder --chown=hono:nodejs /app/.gkm/server/dist/server.mjs ./
-
-# Environment
-ENV NODE_ENV=production
-ENV PORT=${port}
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
-  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
-
-# Switch to non-root user
-USER hono
-
-EXPOSE ${port}
-
-# Use tini as entrypoint to handle PID 1 responsibilities
-ENTRYPOINT ["/sbin/tini", "--"]
-CMD ["node", "server.mjs"]
-`;
-}
-/**
-* Generate a Dockerfile optimized for Turbo monorepos
-* Uses turbo prune to create minimal Docker context
-*/
-function generateTurboDockerfile(options) {
-	const { baseImage, port, healthCheckPath, turboPackage, packageManager } = options;
-	const pm = getPmConfig(packageManager);
-	const installPm = pm.install ? `RUN ${pm.install}` : "";
-	const hasFetch = packageManager === "pnpm";
-	const depsInstall = hasFetch ? `# Fetch and install from cache
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.fetch}
-
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}` : `# Install dependencies with cache
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}`;
-	return `# syntax=docker/dockerfile:1
-# Stage 1: Prune monorepo
-FROM ${baseImage} AS pruner
-
-WORKDIR /app
-
-${installPm}
-RUN ${pm.addGlobal} turbo
-
-COPY . .
-
-# Prune to only include necessary packages
-RUN turbo prune ${turboPackage} --docker
-
-# Stage 2: Install dependencies
-FROM ${baseImage} AS deps
-
-WORKDIR /app
-
-${installPm}
-
-# Copy pruned lockfile and package.jsons
-COPY --from=pruner /app/out/${pm.lockfile} ./
-COPY --from=pruner /app/out/json/ ./
-
-${depsInstall}
-
-# Stage 3: Build
-FROM deps AS builder
-
-WORKDIR /app
-
-# Copy pruned source
-COPY --from=pruner /app/out/full/ ./
-
-# Build production server
-RUN ${pm.run} gkm build --provider server --production
-
-# Stage 4: Production
-FROM ${baseImage} AS runner
-
-WORKDIR /app
-
-RUN apk add --no-cache tini
-
-RUN addgroup --system --gid 1001 nodejs && \\
-    adduser --system --uid 1001 hono
-
-COPY --from=builder --chown=hono:nodejs /app/.gkm/server/dist/server.mjs ./
-
-ENV NODE_ENV=production
-ENV PORT=${port}
-
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
-  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
-
-USER hono
-
-EXPOSE ${port}
-
-ENTRYPOINT ["/sbin/tini", "--"]
-CMD ["node", "server.mjs"]
-`;
-}
-/**
-* Generate a slim Dockerfile for pre-built bundles
-*/
-function generateSlimDockerfile(options) {
-	const { baseImage, port, healthCheckPath } = options;
-	return `# Slim Dockerfile for pre-built production bundle
-FROM ${baseImage}
-
-WORKDIR /app
-
-# Install tini for proper signal handling as PID 1
-# Handles SIGTERM propagation and zombie process reaping
-RUN apk add --no-cache tini
-
-# Create non-root user
-RUN addgroup --system --gid 1001 nodejs && \\
-    adduser --system --uid 1001 hono
-
-# Copy pre-built bundle
-COPY .gkm/server/dist/server.mjs ./
-
-# Environment
-ENV NODE_ENV=production
-ENV PORT=${port}
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
-  CMD wget -q --spider http://localhost:${port}${healthCheckPath} || exit 1
-
-# Switch to non-root user
-USER hono
-
-EXPOSE ${port}
-
-# Use tini as entrypoint to handle PID 1 responsibilities
-ENTRYPOINT ["/sbin/tini", "--"]
-CMD ["node", "server.mjs"]
-`;
-}
-/**
-* Generate .dockerignore file
-*/
-function generateDockerignore() {
-	return `# Dependencies
-node_modules
-.pnpm-store
-
-# Build output (except what we need)
-.gkm/aws*
-.gkm/server/*.ts
-!.gkm/server/dist
-
-# IDE and editor
-.idea
-.vscode
-*.swp
-*.swo
-
-# Git
-.git
-.gitignore
-
-# Logs
-*.log
-npm-debug.log*
-pnpm-debug.log*
-
-# Test files
-**/*.test.ts
-**/*.spec.ts
-**/__tests__
-coverage
-
-# Documentation
-docs
-*.md
-!README.md
-
-# Environment files (handle secrets separately)
-.env
-.env.*
-!.env.example
-
-# Docker files (don't copy recursively)
-Dockerfile*
-docker-compose*
-.dockerignore
-`;
-}
-/**
-* Generate docker-entrypoint.sh for custom startup logic
-*/
-function generateDockerEntrypoint() {
-	return `#!/bin/sh
-set -e
-
-# Run any custom startup scripts here
-# Example: wait for database
-# until nc -z $DB_HOST $DB_PORT; do
-#   echo "Waiting for database..."
-#   sleep 1
-# done
-
-# Execute the main command
-exec "$@"
-`;
-}
-/**
-* Resolve Docker configuration from GkmConfig with defaults
+* List available Dokploy resources
 */
-function resolveDockerConfig(config) {
-	const docker = config.docker ?? {};
-	let defaultImageName = "api";
-	try {
-		const pkg = require(`${process.cwd()}/package.json`);
-		if (pkg.name) defaultImageName = pkg.name.replace(/^@[^/]+\//, "");
-	} catch {}
-	return {
-		registry: docker.registry ?? "",
-		imageName: docker.imageName ?? defaultImageName,
-		baseImage: docker.baseImage ?? "node:22-alpine",
-		port: docker.port ?? 3e3,
-		compose: docker.compose
-	};
+async function deployListCommand(options) {
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
+	const { resource } = options;
+	if (resource === "projects") {
+		logger$2.log(`\n📁 Projects in ${endpoint}:`);
+		const projects = await api.listProjects();
+		if (projects.length === 0) {
+			logger$2.log("   No projects found");
+			return;
+		}
+		for (const project of projects) {
+			logger$2.log(`\n   ${project.name} (${project.projectId})`);
+			if (project.description) logger$2.log(`     ${project.description}`);
+		}
+	} else if (resource === "registries") {
+		logger$2.log(`\n🐳 Registries in ${endpoint}:`);
+		const registries = await api.listRegistries();
+		if (registries.length === 0) {
+			logger$2.log("   No registries configured");
+			logger$2.log("   Run \"gkm registry:setup\" to configure a registry");
+			return;
+		}
+		const storedRegistryId = await getDokployRegistryId();
+		for (const registry of registries) {
+			const isDefault = registry.registryId === storedRegistryId;
+			const marker = isDefault ? " (default)" : "";
+			logger$2.log(`\n   ${registry.registryName}${marker} (${registry.registryId})`);
+			logger$2.log(`     URL: ${registry.registryUrl}`);
+			logger$2.log(`     Username: ${registry.username}`);
+			if (registry.imagePrefix) logger$2.log(`     Prefix: ${registry.imagePrefix}`);
+		}
+	}
 }
 
 //#endregion
-//#region src/docker/index.ts
+//#region src/deploy/index.ts
 const logger$1 = console;
 /**
-* Docker command implementation
-* Generates Dockerfile, docker-compose.yml, and related files
-*
-* Default: Multi-stage Dockerfile that builds from source inside Docker
-* --slim: Slim Dockerfile that copies pre-built bundle (requires prior build)
+* Prompt for input
 */
-async function dockerCommand(options) {
-	const config = await require_config.loadConfig();
-	const dockerConfig = resolveDockerConfig(config);
-	const serverConfig = typeof config.providers?.server === "object" ? config.providers.server : void 0;
-	const healthCheckPath = serverConfig?.production?.healthCheck ?? "/health";
-	const useSlim = options.slim === true;
-	if (useSlim) {
-		const distDir = (0, node_path.join)(process.cwd(), ".gkm", "server", "dist");
-		const hasBuild = (0, node_fs.existsSync)((0, node_path.join)(distDir, "server.mjs"));
-		if (!hasBuild) throw new Error("Slim Dockerfile requires a pre-built bundle. Run `gkm build --provider server --production` first, or omit --slim to use multi-stage build.");
+async function prompt(message, hidden = false) {
+	if (!process.stdin.isTTY) throw new Error("Interactive input required. Please configure manually.");
+	if (hidden) {
+		process.stdout.write(message);
+		return new Promise((resolve$1) => {
+			let value = "";
+			const onData = (char) => {
+				const c = char.toString();
+				if (c === "\n" || c === "\r") {
+					process.stdin.setRawMode(false);
+					process.stdin.pause();
+					process.stdin.removeListener("data", onData);
+					process.stdout.write("\n");
+					resolve$1(value);
+				} else if (c === "") {
+					process.stdin.setRawMode(false);
+					process.stdin.pause();
+					process.stdout.write("\n");
+					process.exit(1);
+				} else if (c === "" || c === "\b") {
+					if (value.length > 0) value = value.slice(0, -1);
+				} else value += c;
+			};
+			process.stdin.setRawMode(true);
+			process.stdin.resume();
+			process.stdin.on("data", onData);
+		});
 	}
-	const dockerDir = (0, node_path.join)(process.cwd(), ".gkm", "docker");
-	await (0, node_fs_promises.mkdir)(dockerDir, { recursive: true });
-	const packageManager = detectPackageManager$1();
-	const templateOptions = {
-		imageName: dockerConfig.imageName,
-		baseImage: dockerConfig.baseImage,
-		port: dockerConfig.port,
-		healthCheckPath,
-		prebuilt: useSlim,
-		turbo: options.turbo,
-		turboPackage: options.turboPackage ?? dockerConfig.imageName,
-		packageManager
+	const rl = node_readline_promises.createInterface({
+		input: node_process.stdin,
+		output: node_process.stdout
+	});
+	try {
+		return await rl.question(message);
+	} finally {
+		rl.close();
+	}
+}
+/**
+* Provision docker compose services in Dokploy
+* @internal Exported for testing
+*/
+async function provisionServices(api, projectId, environmentId, appName, services, existingUrls) {
+	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`;
+		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");
+			serviceUrls.DATABASE_HOST = postgres.appName;
+			serviceUrls.DATABASE_PORT = "5432";
+			serviceUrls.DATABASE_NAME = postgres.databaseName;
+			serviceUrls.DATABASE_USER = postgres.databaseUser;
+			serviceUrls.DATABASE_PASSWORD = postgres.databasePassword;
+			serviceUrls.DATABASE_URL = `postgresql://${postgres.databaseUser}:${postgres.databasePassword}@${postgres.appName}:5432/${postgres.databaseName}`;
+			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}`);
+		}
+	}
+	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`;
+		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");
+			serviceUrls.REDIS_HOST = redis.appName;
+			serviceUrls.REDIS_PORT = "6379";
+			if (redis.databasePassword) serviceUrls.REDIS_PASSWORD = redis.databasePassword;
+			const password = redis.databasePassword ? `:${redis.databasePassword}@` : "";
+			serviceUrls.REDIS_URL = `redis://${password}${redis.appName}:6379`;
+			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}`);
+		}
+	}
+	return Object.keys(serviceUrls).length > 0 ? serviceUrls : void 0;
+}
+/**
+* Ensure Dokploy is fully configured, recovering/creating resources as needed
+*/
+async function ensureDokploySetup(config, dockerConfig, stage, services) {
+	logger$1.log("\n🔧 Checking Dokploy setup...");
+	const { readStageSecrets: readStageSecrets$1 } = await Promise.resolve().then(() => require("./storage-UfyTn7Zm.cjs"));
+	const existingSecrets = await readStageSecrets$1(stage);
+	const existingUrls = {
+		DATABASE_URL: existingSecrets?.urls?.DATABASE_URL,
+		REDIS_URL: existingSecrets?.urls?.REDIS_URL
 	};
-	const dockerfile = useSlim ? generateSlimDockerfile(templateOptions) : generateMultiStageDockerfile(templateOptions);
-	const dockerMode = useSlim ? "slim" : options.turbo ? "turbo" : "multi-stage";
-	const dockerfilePath = (0, node_path.join)(dockerDir, "Dockerfile");
-	await (0, node_fs_promises.writeFile)(dockerfilePath, dockerfile);
-	logger$1.log(`Generated: .gkm/docker/Dockerfile (${dockerMode}, ${packageManager})`);
-	const composeOptions = {
-		imageName: dockerConfig.imageName,
-		registry: options.registry ?? dockerConfig.registry,
-		port: dockerConfig.port,
-		healthCheckPath,
-		services: dockerConfig.compose?.services ?? {}
+	let creds = await getDokployCredentials();
+	if (!creds) {
+		logger$1.log("\n📋 Dokploy credentials not found. Let's set them up.");
+		const endpoint = await prompt("Dokploy URL (e.g., https://dokploy.example.com): ");
+		const normalizedEndpoint = endpoint.replace(/\/$/, "");
+		try {
+			new URL(normalizedEndpoint);
+		} catch {
+			throw new Error("Invalid URL format");
+		}
+		logger$1.log(`\nGenerate a token at: ${normalizedEndpoint}/settings/profile\n`);
+		const token = await prompt("API Token: ", true);
+		logger$1.log("\nValidating credentials...");
+		const isValid = await validateDokployToken(normalizedEndpoint, token);
+		if (!isValid) throw new Error("Invalid credentials. Please check your token.");
+		await storeDokployCredentials(token, normalizedEndpoint);
+		creds = {
+			token,
+			endpoint: normalizedEndpoint
+		};
+		logger$1.log("✓ Credentials saved");
+	}
+	const api = new require_dokploy_api.DokployApi({
+		baseUrl: creds.endpoint,
+		token: creds.token
+	});
+	const existingConfig = config.providers?.dokploy;
+	if (existingConfig && typeof existingConfig !== "boolean" && existingConfig.applicationId && existingConfig.projectId) {
+		logger$1.log("✓ Dokploy config found in gkm.config.ts");
+		try {
+			const projectDetails = await api.getProject(existingConfig.projectId);
+			logger$1.log("✓ Project verified");
+			const storedRegistryId = existingConfig.registryId ?? await getDokployRegistryId();
+			const environments = projectDetails.environments ?? [];
+			let environment = environments.find((e) => e.name.toLowerCase() === stage.toLowerCase());
+			if (!environment) {
+				logger$1.log(`   Creating "${stage}" environment...`);
+				environment = await api.createEnvironment(existingConfig.projectId, stage);
+				logger$1.log(`   ✓ Created environment: ${environment.environmentId}`);
+			}
+			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);
+			return {
+				config: {
+					endpoint: existingConfig.endpoint,
+					projectId: existingConfig.projectId,
+					applicationId: existingConfig.applicationId,
+					registry: existingConfig.registry,
+					registryId: storedRegistryId ?? void 0
+				},
+				serviceUrls: serviceUrls$1
+			};
+		} catch {
+			logger$1.log("⚠ Project not found, will recover...");
+		}
+	}
+	logger$1.log("\n📁 Looking for project...");
+	const projectName = dockerConfig.projectName;
+	const projects = await api.listProjects();
+	let project = projects.find((p) => p.name.toLowerCase() === projectName.toLowerCase());
+	let environmentId;
+	if (project) {
+		logger$1.log(`   Found existing project: ${project.name} (${project.projectId})`);
+		const projectDetails = await api.getProject(project.projectId);
+		const environments = projectDetails.environments ?? [];
+		const matchingEnv = environments.find((e) => e.name.toLowerCase() === stage.toLowerCase());
+		if (matchingEnv) {
+			environmentId = matchingEnv.environmentId;
+			logger$1.log(`   Using environment: ${matchingEnv.name}`);
+		} else {
+			logger$1.log(`   Creating "${stage}" environment...`);
+			const env = await api.createEnvironment(project.projectId, stage);
+			environmentId = env.environmentId;
+			logger$1.log(`   ✓ Created environment: ${stage}`);
+		}
+	} else {
+		logger$1.log(`   Creating project: ${projectName}`);
+		const result = await api.createProject(projectName);
+		project = result.project;
+		if (result.environment.name.toLowerCase() !== stage.toLowerCase()) {
+			logger$1.log(`   Creating "${stage}" environment...`);
+			const env = await api.createEnvironment(project.projectId, stage);
+			environmentId = env.environmentId;
+		} else environmentId = result.environment.environmentId;
+		logger$1.log(`   ✓ Created project: ${project.projectId}`);
+		logger$1.log(`   ✓ Using environment: ${stage}`);
+	}
+	logger$1.log("\n📦 Looking for application...");
+	const appName = dockerConfig.appName;
+	let applicationId;
+	if (existingConfig && typeof existingConfig !== "boolean" && existingConfig.applicationId) {
+		applicationId = existingConfig.applicationId;
+		logger$1.log(`   Using application from config: ${applicationId}`);
+	} else {
+		logger$1.log(`   Creating application: ${appName}`);
+		const app = await api.createApplication(appName, project.projectId, environmentId);
+		applicationId = app.applicationId;
+		logger$1.log(`   ✓ Created application: ${applicationId}`);
+	}
+	logger$1.log("\n🐳 Checking registry...");
+	let registryId = await getDokployRegistryId();
+	if (registryId) try {
+		const registry = await api.getRegistry(registryId);
+		logger$1.log(`   Using registry: ${registry.registryName}`);
+	} catch {
+		logger$1.log("   ⚠ Stored registry not found, clearing...");
+		registryId = void 0;
+		await storeDokployRegistryId("");
+	}
+	if (!registryId) {
+		const registries = await api.listRegistries();
+		if (registries.length === 0) if (dockerConfig.registry) {
+			logger$1.log("   No registries found in Dokploy. Let's create one.");
+			logger$1.log(`   Registry URL: ${dockerConfig.registry}`);
+			const username = await prompt("Registry username: ");
+			const password = await prompt("Registry password/token: ", true);
+			const registry = await api.createRegistry("Default Registry", dockerConfig.registry, username, password);
+			registryId = registry.registryId;
+			await storeDokployRegistryId(registryId);
+			logger$1.log(`   ✓ Registry created: ${registryId}`);
+		} else logger$1.log("   ⚠ No registry configured. Set docker.registry in gkm.config.ts");
+		else {
+			logger$1.log("   Available registries:");
+			registries.forEach((reg, i) => {
+				logger$1.log(`     ${i + 1}. ${reg.registryName} (${reg.registryUrl})`);
+			});
+			if (dockerConfig.registry) logger$1.log(`     ${registries.length + 1}. Create new registry`);
+			const maxOption = dockerConfig.registry ? registries.length + 1 : registries.length;
+			const selection = await prompt(`   Select registry (1-${maxOption}): `);
+			const index = parseInt(selection, 10) - 1;
+			if (index >= 0 && index < registries.length) {
+				registryId = registries[index].registryId;
+				await storeDokployRegistryId(registryId);
+				logger$1.log(`   ✓ Selected: ${registries[index].registryName}`);
+			} else if (dockerConfig.registry && index === registries.length) {
+				logger$1.log(`\n   Creating new registry...`);
+				logger$1.log(`   Registry URL: ${dockerConfig.registry}`);
+				const username = await prompt("   Registry username: ");
+				const password = await prompt("   Registry password/token: ", true);
+				const registry = await api.createRegistry(dockerConfig.registry.replace(/^https?:\/\//, ""), dockerConfig.registry, username, password);
+				registryId = registry.registryId;
+				await storeDokployRegistryId(registryId);
+				logger$1.log(`   ✓ Registry created: ${registryId}`);
+			} else logger$1.log("   ⚠ Invalid selection, skipping registry setup");
+		}
+	}
+	const dokployConfig = {
+		endpoint: creds.endpoint,
+		projectId: project.projectId,
+		applicationId,
+		registryId: registryId ?? void 0
 	};
-	const hasServices = Array.isArray(composeOptions.services) ? composeOptions.services.length > 0 : Object.keys(composeOptions.services).length > 0;
-	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$1.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$1.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$1.log("Generated: .gkm/docker/docker-entrypoint.sh");
-	const result = {
-		dockerfile: dockerfilePath,
-		dockerCompose: composePath,
-		dockerignore: dockerignorePath,
-		entrypoint: entrypointPath
+	await updateConfig(dokployConfig);
+	logger$1.log("\n✅ Dokploy setup complete!");
+	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);
+	return {
+		config: dokployConfig,
+		serviceUrls
 	};
-	if (options.build) await buildDockerImage(dockerConfig.imageName, options);
-	if (options.push) await pushDockerImage(dockerConfig.imageName, options);
-	return result;
 }
 /**
-* Build Docker image
-* Uses BuildKit for cache mount support
+* Generate image tag from stage and timestamp
 */
-async function buildDockerImage(imageName, options) {
-	const tag = options.tag ?? "latest";
-	const registry = options.registry;
-	const fullImageName = registry ? `${registry}/${imageName}:${tag}` : `${imageName}:${tag}`;
-	logger$1.log(`\n🐳 Building Docker image: ${fullImageName}`);
-	try {
-		(0, node_child_process.execSync)(`DOCKER_BUILDKIT=1 docker build -f .gkm/docker/Dockerfile -t ${fullImageName} .`, {
-			cwd: process.cwd(),
-			stdio: "inherit",
-			env: {
-				...process.env,
-				DOCKER_BUILDKIT: "1"
-			}
-		});
-		logger$1.log(`✅ Docker image built: ${fullImageName}`);
-	} catch (error) {
-		throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
+function generateTag(stage) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+	return `${stage}-${timestamp}`;
 }
 /**
-* Push Docker image to registry
+* Main deploy command
 */
-async function pushDockerImage(imageName, options) {
-	const tag = options.tag ?? "latest";
-	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$1.log(`\n🚀 Pushing Docker image: ${fullImageName}`);
-	try {
-		(0, node_child_process.execSync)(`docker push ${fullImageName}`, {
-			cwd: process.cwd(),
-			stdio: "inherit"
+async function deployCommand(options) {
+	const { provider, stage, tag, skipPush, skipBuild } = options;
+	logger$1.log(`\n🚀 Deploying to ${provider}...`);
+	logger$1.log(`   Stage: ${stage}`);
+	const config = await require_config.loadConfig();
+	const imageTag = tag ?? generateTag(stage);
+	logger$1.log(`   Tag: ${imageTag}`);
+	const dockerConfig = resolveDockerConfig(config);
+	const imageName = dockerConfig.imageName;
+	const registry = dockerConfig.registry;
+	const imageRef = registry ? `${registry}/${imageName}:${imageTag}` : `${imageName}:${imageTag}`;
+	let dokployConfig;
+	let finalRegistry = registry;
+	if (provider === "dokploy") {
+		const composeServices = config.docker?.compose?.services;
+		logger$1.log(`\n🔍 Docker compose config: ${JSON.stringify(config.docker?.compose)}`);
+		const dockerServices = composeServices ? Array.isArray(composeServices) ? {
+			postgres: composeServices.includes("postgres"),
+			redis: composeServices.includes("redis"),
+			rabbitmq: composeServices.includes("rabbitmq")
+		} : {
+			postgres: Boolean(composeServices.postgres),
+			redis: Boolean(composeServices.redis),
+			rabbitmq: Boolean(composeServices.rabbitmq)
+		} : void 0;
+		const setupResult = await ensureDokploySetup(config, dockerConfig, stage, dockerServices);
+		dokployConfig = setupResult.config;
+		finalRegistry = dokployConfig.registry ?? dockerConfig.registry;
+		if (setupResult.serviceUrls) {
+			const { readStageSecrets: readStageSecrets$1, writeStageSecrets: writeStageSecrets$1, initStageSecrets } = await Promise.resolve().then(() => require("./storage-UfyTn7Zm.cjs"));
+			let secrets = await readStageSecrets$1(stage);
+			if (!secrets) {
+				logger$1.log(`   Creating secrets file for stage "${stage}"...`);
+				secrets = initStageSecrets(stage);
+			}
+			let updated = false;
+			const urlFields = [
+				"DATABASE_URL",
+				"REDIS_URL",
+				"RABBITMQ_URL"
+			];
+			for (const [key, value] of Object.entries(setupResult.serviceUrls)) {
+				if (!value) continue;
+				if (urlFields.includes(key)) {
+					const urlKey = key;
+					if (!secrets.urls[urlKey]) {
+						secrets.urls[urlKey] = value;
+						logger$1.log(`   Saved ${key} to secrets.urls`);
+						updated = true;
+					}
+				} else if (!secrets.custom[key]) {
+					secrets.custom[key] = value;
+					logger$1.log(`   Saved ${key} to secrets.custom`);
+					updated = true;
+				}
+			}
+			if (updated) await writeStageSecrets$1(secrets);
+		}
+	}
+	let masterKey;
+	if (!skipBuild) {
+		logger$1.log(`\n📦 Building for production...`);
+		const buildResult = await buildCommand({
+			provider: "server",
+			production: true,
+			stage
 		});
-		logger$1.log(`✅ Docker image pushed: ${fullImageName}`);
-	} catch (error) {
-		throw new Error(`Failed to push Docker image: ${error instanceof Error ? error.message : "Unknown error"}`);
+		masterKey = buildResult.masterKey;
+	} else logger$1.log(`\n⏭️  Skipping build (--skip-build)`);
+	let result;
+	switch (provider) {
+		case "docker": {
+			result = await deployDocker({
+				stage,
+				tag: imageTag,
+				skipPush,
+				masterKey,
+				config: dockerConfig
+			});
+			break;
+		}
+		case "dokploy": {
+			if (!dokployConfig) throw new Error("Dokploy config not initialized");
+			const finalImageRef = finalRegistry ? `${finalRegistry}/${imageName}:${imageTag}` : `${imageName}:${imageTag}`;
+			await deployDocker({
+				stage,
+				tag: imageTag,
+				skipPush: false,
+				masterKey,
+				config: {
+					registry: finalRegistry,
+					imageName: dockerConfig.imageName
+				}
+			});
+			result = await deployDokploy({
+				stage,
+				tag: imageTag,
+				imageRef: finalImageRef,
+				masterKey,
+				config: dokployConfig
+			});
+			break;
+		}
+		case "aws-lambda": {
+			logger$1.log("\n⚠️  AWS Lambda deployment is not yet implemented.");
+			logger$1.log("   Use SST or AWS CDK for Lambda deployments.");
+			result = {
+				imageRef,
+				masterKey
+			};
+			break;
+		}
+		default: throw new Error(`Unknown deploy provider: ${provider}\nSupported providers: docker, dokploy, aws-lambda`);
 	}
+	logger$1.log("\n✅ Deployment complete!");
+	return result;
 }
 
 //#endregion
@@ -4083,11 +4505,11 @@ async function initCommand(projectName, options = {}) {
 	};
 	const targetDir = (0, node_path.join)(cwd, name$1);
 	const template = getTemplate(templateOptions.template);
-	const isMonorepo = templateOptions.monorepo;
+	const isMonorepo$1 = templateOptions.monorepo;
 	const apiPath = templateOptions.apiPath;
 	await (0, node_fs_promises.mkdir)(targetDir, { recursive: true });
-	const appDir = isMonorepo ? (0, node_path.join)(targetDir, apiPath) : targetDir;
-	if (isMonorepo) await (0, node_fs_promises.mkdir)(appDir, { recursive: true });
+	const appDir = isMonorepo$1 ? (0, node_path.join)(targetDir, apiPath) : targetDir;
+	if (isMonorepo$1) await (0, node_fs_promises.mkdir)(appDir, { recursive: true });
 	const appFiles = [
 		...generatePackageJson(templateOptions, template),
 		...generateConfigFiles(templateOptions, template),
@@ -4103,7 +4525,7 @@ async function initCommand(projectName, options = {}) {
 	}
 	for (const { path, content } of appFiles) {
 		const fullPath = (0, node_path.join)(appDir, path);
-		const _displayPath = isMonorepo ? `${apiPath}/${path}` : path;
+		const _displayPath = isMonorepo$1 ? `${apiPath}/${path}` : path;
 		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(fullPath), { recursive: true });
 		await (0, node_fs_promises.writeFile)(fullPath, content);
 	}
@@ -4436,7 +4858,8 @@ program.command("init").description("Scaffold a new project").argument("[name]",
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await initCommand(name$1, options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4468,7 +4891,8 @@ program.command("build").description("Build handlers from endpoints, functions,
 			skipBundle: options.skipBundle || false,
 			stage: options.stage
 		});
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4481,7 +4905,8 @@ program.command("dev").description("Start development server with automatic relo
 			portExplicit: !!options.port,
 			enableOpenApi: options.enableOpenapi ?? true
 		});
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4505,7 +4930,8 @@ program.command("openapi").description("Generate OpenAPI specification from endp
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await require_openapi.openapiCommand({});
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4514,7 +4940,8 @@ program.command("generate:react-query").description("Generate React Query hooks
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await require_openapi_react_query.generateReactQueryCommand(options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4523,7 +4950,8 @@ program.command("docker").description("Generate Docker deployment files").option
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await dockerCommand(options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4551,7 +4979,8 @@ program.command("prepack").description("Generate Docker files for production dep
 			const registry = options.registry;
 			const _imageRef = registry ? `${registry}/api:${tag}` : `api:${tag}`;
 		}
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4560,7 +4989,8 @@ program.command("secrets:init").description("Initialize secrets for a deployment
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await secretsInitCommand(options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4569,7 +4999,8 @@ program.command("secrets:set").description("Set a custom secret for a stage").ar
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await secretsSetCommand(key, value, options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4578,7 +5009,8 @@ program.command("secrets:show").description("Show secrets for a stage").required
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await secretsShowCommand(options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4587,7 +5019,8 @@ program.command("secrets:rotate").description("Rotate service passwords").requir
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await secretsRotateCommand(options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4596,7 +5029,8 @@ program.command("secrets:import").description("Import secrets from a JSON file")
 		const globalOptions = program.opts();
 		if (globalOptions.cwd) process.chdir(globalOptions.cwd);
 		await secretsImportCommand(file, options);
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Command failed");
 		process.exit(1);
 	}
 });
@@ -4620,7 +5054,8 @@ program.command("deploy").description("Deploy application to a provider").requir
 			skipPush: options.skipPush,
 			skipBuild: options.skipBuild
 		});
-	} catch (_error) {
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "Deploy failed");
 		process.exit(1);
 	}
 });