@geekmidas/cli 0.10.0 → 0.13.0

package/src/deploy/docker.ts

@@ -0,0 +1,128 @@
+import { execSync } from 'node:child_process';
+import type { GkmConfig } from '../types';
+import type { DeployResult, DockerDeployConfig } from './types';
+
+const logger = console;
+
+export interface DockerDeployOptions {
+	/** Deployment stage */
+	stage: string;
+	/** Image tag */
+	tag: string;
+	/** Skip pushing to registry */
+	skipPush?: boolean;
+	/** Master key from build */
+	masterKey?: string;
+	/** Docker config from gkm.config */
+	config: DockerDeployConfig;
+}
+
+/**
+ * Get the full image reference
+ */
+export function getImageRef(
+	registry: string | undefined,
+	imageName: string,
+	tag: string,
+): string {
+	if (registry) {
+		return `${registry}/${imageName}:${tag}`;
+	}
+	return `${imageName}:${tag}`;
+}
+
+/**
+ * Build Docker image
+ */
+async function buildImage(imageRef: string): Promise<void> {
+	logger.log(`\n🔨 Building Docker image: ${imageRef}`);
+
+	try {
+		execSync(
+			`DOCKER_BUILDKIT=1 docker build -f .gkm/docker/Dockerfile -t ${imageRef} .`,
+			{
+				cwd: process.cwd(),
+				stdio: 'inherit',
+				env: { ...process.env, DOCKER_BUILDKIT: '1' },
+			},
+		);
+		logger.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: string): Promise<void> {
+	logger.log(`\n☁️  Pushing image: ${imageRef}`);
+
+	try {
+		execSync(`docker push ${imageRef}`, {
+			cwd: process.cwd(),
+			stdio: 'inherit',
+		});
+		logger.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)
+ */
+export async function deployDocker(
+	options: DockerDeployOptions,
+): Promise<DeployResult> {
+	const { stage, tag, skipPush, masterKey, config } = options;
+
+	const imageName = config.imageName ?? 'app';
+	const imageRef = getImageRef(config.registry, imageName, tag);
+
+	// Build image
+	await buildImage(imageRef);
+
+	// Push to registry if not skipped
+	if (!skipPush) {
+		if (!config.registry) {
+			logger.warn(
+				'\n⚠️  No registry configured. Use --skip-push or configure docker.registry in gkm.config.ts',
+			);
+		} else {
+			await pushImage(imageRef);
+		}
+	}
+
+	// Output deployment info
+	logger.log('\n✅ Docker deployment ready!');
+	logger.log(`\n📋 Deployment details:`);
+	logger.log(`   Image: ${imageRef}`);
+	logger.log(`   Stage: ${stage}`);
+
+	if (masterKey) {
+		logger.log(`\n🔐 Deploy with this environment variable:`);
+		logger.log(`   GKM_MASTER_KEY=${masterKey}`);
+		logger.log('\n   Example docker run:');
+		logger.log(`   docker run -e GKM_MASTER_KEY=${masterKey} ${imageRef}`);
+	}
+
+	return {
+		imageRef,
+		masterKey,
+	};
+}
+
+/**
+ * Resolve Docker deploy config from gkm config
+ */
+export function resolveDockerConfig(config: GkmConfig): DockerDeployConfig {
+	return {
+		registry: config.docker?.registry,
+		imageName: config.docker?.imageName,
+	};
+}

package/src/deploy/dokploy.ts

@@ -0,0 +1,204 @@
+import { getDokployToken } from '../auth';
+import type { DeployResult, DokployDeployConfig } from './types';
+
+const logger = console;
+
+export interface DokployDeployOptions {
+	/** Deployment stage */
+	stage: string;
+	/** Image tag */
+	tag: string;
+	/** Image reference */
+	imageRef: string;
+	/** Master key from build */
+	masterKey?: string;
+	/** Dokploy config from gkm.config */
+	config: DokployDeployConfig;
+}
+
+interface DokployErrorResponse {
+	message: string;
+	code?: string;
+	issues?: Array<{ message: string }>;
+}
+
+/**
+ * Get the Dokploy API token from stored credentials or environment
+ */
+async function getApiToken(): Promise<string> {
+	const token = await getDokployToken();
+	if (!token) {
+		throw new Error(
+			'Dokploy credentials not found.\n' +
+				'Run "gkm login --service dokploy" to authenticate, or set DOKPLOY_API_TOKEN.',
+		);
+	}
+	return token;
+}
+
+/**
+ * Make a request to the Dokploy API
+ */
+async function dokployRequest<T>(
+	endpoint: string,
+	baseUrl: string,
+	token: string,
+	body: Record<string, unknown>,
+): Promise<T> {
+	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()) as DokployErrorResponse;
+			if (errorBody.message) {
+				errorMessage = `Dokploy API error: ${errorBody.message}`;
+			}
+			if (errorBody.issues?.length) {
+				errorMessage += `\n  Issues: ${errorBody.issues.map((i) => i.message).join(', ')}`;
+			}
+		} catch {
+			// Ignore JSON parse errors
+		}
+
+		throw new Error(errorMessage);
+	}
+
+	return response.json() as Promise<T>;
+}
+
+/**
+ * Update application environment variables
+ */
+async function updateEnvironment(
+	baseUrl: string,
+	token: string,
+	applicationId: string,
+	envVars: Record<string, string>,
+): Promise<void> {
+	logger.log('  Updating environment variables...');
+
+	// Convert env vars to the format Dokploy expects (KEY=VALUE per line)
+	const envString = Object.entries(envVars)
+		.map(([key, value]) => `${key}=${value}`)
+		.join('\n');
+
+	await dokployRequest('application.update', baseUrl, token, {
+		applicationId,
+		env: envString,
+	});
+
+	logger.log('  ✓ Environment variables updated');
+}
+
+/**
+ * Trigger application deployment
+ */
+async function triggerDeploy(
+	baseUrl: string,
+	token: string,
+	applicationId: string,
+): Promise<void> {
+	logger.log('  Triggering deployment...');
+
+	await dokployRequest('application.deploy', baseUrl, token, {
+		applicationId,
+	});
+
+	logger.log('  ✓ Deployment triggered');
+}
+
+/**
+ * Deploy to Dokploy
+ */
+export async function deployDokploy(
+	options: DokployDeployOptions,
+): Promise<DeployResult> {
+	const { stage, imageRef, masterKey, config } = options;
+
+	logger.log(`\n🎯 Deploying to Dokploy...`);
+	logger.log(`   Endpoint: ${config.endpoint}`);
+	logger.log(`   Application: ${config.applicationId}`);
+
+	const token = await getApiToken();
+
+	// Prepare environment variables
+	const envVars: Record<string, string> = {};
+
+	if (masterKey) {
+		envVars.GKM_MASTER_KEY = masterKey;
+	}
+
+	// Update environment if we have variables to set
+	if (Object.keys(envVars).length > 0) {
+		await updateEnvironment(
+			config.endpoint,
+			token,
+			config.applicationId,
+			envVars,
+		);
+	}
+
+	// Trigger deployment
+	await triggerDeploy(config.endpoint, token, config.applicationId);
+
+	logger.log('\n✅ Dokploy deployment initiated!');
+	logger.log(`\n📋 Deployment details:`);
+	logger.log(`   Image: ${imageRef}`);
+	logger.log(`   Stage: ${stage}`);
+	logger.log(`   Application ID: ${config.applicationId}`);
+
+	if (masterKey) {
+		logger.log(`\n🔐 GKM_MASTER_KEY has been set in Dokploy environment`);
+	}
+
+	// Construct the probable deployment URL
+	const deploymentUrl = `${config.endpoint}/project/${config.projectId}`;
+	logger.log(`\n🔗 View deployment: ${deploymentUrl}`);
+
+	return {
+		imageRef,
+		masterKey,
+		url: deploymentUrl,
+	};
+}
+
+/**
+ * Validate Dokploy configuration
+ */
+export function validateDokployConfig(
+	config: Partial<DokployDeployConfig> | undefined,
+): config is DokployDeployConfig {
+	if (!config) {
+		return false;
+	}
+
+	const required = ['endpoint', 'projectId', 'applicationId'] as const;
+	const missing = required.filter((key) => !config[key]);
+
+	if (missing.length > 0) {
+		throw new Error(
+			`Missing Dokploy configuration: ${missing.join(', ')}\n` +
+				'Configure in gkm.config.ts:\n' +
+				'  providers: {\n' +
+				'    dokploy: {\n' +
+				"      endpoint: 'https://dokploy.example.com',\n" +
+				"      projectId: 'proj_xxx',\n" +
+				"      applicationId: 'app_xxx',\n" +
+				'    },\n' +
+				'  }',
+		);
+	}
+
+	return true;
+}

package/src/deploy/index.ts

@@ -0,0 +1,136 @@
+import { buildCommand } from '../build/index';
+import { loadConfig } from '../config';
+import { deployDocker, resolveDockerConfig } from './docker';
+import { deployDokploy, validateDokployConfig } from './dokploy';
+import type { DeployOptions, DeployProvider, DeployResult } from './types';
+
+const logger = console;
+
+/**
+ * Generate image tag from stage and timestamp
+ */
+function generateTag(stage: string): string {
+	const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+	return `${stage}-${timestamp}`;
+}
+
+/**
+ * Main deploy command
+ */
+export async function deployCommand(
+	options: DeployOptions,
+): Promise<DeployResult> {
+	const { provider, stage, tag, skipPush, skipBuild } = options;
+
+	logger.log(`\n🚀 Deploying to ${provider}...`);
+	logger.log(`   Stage: ${stage}`);
+
+	// Load config
+	const config = await loadConfig();
+
+	// Generate tag if not provided
+	const imageTag = tag ?? generateTag(stage);
+	logger.log(`   Tag: ${imageTag}`);
+
+	// Build for production with secrets injection (unless skipped)
+	let masterKey: string | undefined;
+	if (!skipBuild) {
+		logger.log(`\n📦 Building for production...`);
+		const buildResult = await buildCommand({
+			provider: 'server',
+			production: true,
+			stage,
+		});
+		masterKey = buildResult.masterKey;
+	} else {
+		logger.log(`\n⏭️  Skipping build (--skip-build)`);
+	}
+
+	// Resolve docker config for image reference
+	const dockerConfig = resolveDockerConfig(config);
+	const imageName = dockerConfig.imageName ?? 'app';
+	const registry = dockerConfig.registry;
+	const imageRef = registry
+		? `${registry}/${imageName}:${imageTag}`
+		: `${imageName}:${imageTag}`;
+
+	// Deploy based on provider
+	let result: DeployResult;
+
+	switch (provider) {
+		case 'docker': {
+			result = await deployDocker({
+				stage,
+				tag: imageTag,
+				skipPush,
+				masterKey,
+				config: dockerConfig,
+			});
+			break;
+		}
+
+		case 'dokploy': {
+			// Validate Dokploy config
+			const dokployConfigRaw = config.providers?.dokploy;
+			if (typeof dokployConfigRaw === 'boolean' || !dokployConfigRaw) {
+				throw new Error(
+					'Dokploy provider requires configuration.\n' +
+						'Configure in gkm.config.ts:\n' +
+						'  providers: {\n' +
+						'    dokploy: {\n' +
+						"      endpoint: 'https://dokploy.example.com',\n" +
+						"      projectId: 'proj_xxx',\n" +
+						"      applicationId: 'app_xxx',\n" +
+						'    },\n' +
+						'  }',
+				);
+			}
+
+			// Validate required fields (throws if missing)
+			validateDokployConfig(dokployConfigRaw);
+			const dokployConfig = dokployConfigRaw;
+
+			// First build and push the Docker image
+			await deployDocker({
+				stage,
+				tag: imageTag,
+				skipPush: false, // Dokploy needs the image in registry
+				masterKey,
+				config: {
+					registry: dokployConfig.registry ?? dockerConfig.registry,
+					imageName: dockerConfig.imageName,
+				},
+			});
+
+			// Then trigger Dokploy deployment
+			result = await deployDokploy({
+				stage,
+				tag: imageTag,
+				imageRef,
+				masterKey,
+				config: dokployConfig,
+			});
+			break;
+		}
+
+		case 'aws-lambda': {
+			logger.log('\n⚠️  AWS Lambda deployment is not yet implemented.');
+			logger.log('   Use SST or AWS CDK for Lambda deployments.');
+			result = { imageRef, masterKey };
+			break;
+		}
+
+		default: {
+			throw new Error(
+				`Unknown deploy provider: ${provider}\n` +
+					'Supported providers: docker, dokploy, aws-lambda',
+			);
+		}
+	}
+
+	logger.log('\n✅ Deployment complete!');
+
+	return result;
+}
+
+export type { DeployOptions, DeployProvider, DeployResult };