@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/deploy/dokploy.ts

@@ -1,177 +0,0 @@
-import { getDokployRegistryId, getDokployToken } from '../auth';
-import { DokployApi } from './dokploy-api';
-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;
-}
-
-/**
- * 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;
-}
-
-/**
- * Create a Dokploy API client
- */
-async function createApi(endpoint: string): Promise<DokployApi> {
-	const token = await getApiToken();
-	return new DokployApi({ baseUrl: endpoint, token });
-}
-
-/**
- * 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 api = await createApi(config.endpoint);
-
-	// Configure Docker provider with the image
-	logger.log(`  Configuring Docker image: ${imageRef}`);
-
-	// Determine registry credentials
-	const registryOptions: {
-		registryId?: string;
-		username?: string;
-		password?: string;
-		registryUrl?: string;
-	} = {};
-
-	if (config.registryId) {
-		// Use registry ID from config
-		registryOptions.registryId = config.registryId;
-		logger.log(`  Using Dokploy registry: ${config.registryId}`);
-	} else {
-		// Try stored registry ID from credentials
-		const storedRegistryId = await getDokployRegistryId();
-		if (storedRegistryId) {
-			registryOptions.registryId = storedRegistryId;
-			logger.log(`  Using stored Dokploy registry: ${storedRegistryId}`);
-		} else if (config.registryCredentials) {
-			// Use explicit credentials from config
-			registryOptions.username = config.registryCredentials.username;
-			registryOptions.password = config.registryCredentials.password;
-			registryOptions.registryUrl = config.registryCredentials.registryUrl;
-			logger.log(
-				`  Using registry credentials for: ${config.registryCredentials.registryUrl}`,
-			);
-		} else {
-			// Try environment variables
-			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.log(`  Using registry credentials from environment`);
-			}
-		}
-	}
-
-	await api.saveDockerProvider(config.applicationId, imageRef, registryOptions);
-	logger.log('  ✓ Docker provider configured');
-
-	// 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) {
-		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 api.saveApplicationEnv(config.applicationId, envString);
-		logger.log('  ✓ Environment variables updated');
-	}
-
-	// Trigger deployment
-	logger.log('  Triggering deployment...');
-	await api.deployApplication(config.applicationId);
-	logger.log('  ✓ Deployment triggered');
-
-	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/domain.ts

@@ -1,134 +0,0 @@
-import { getPublicEnvPrefix } from '../workspace/index.js';
-import type {
-	DokployWorkspaceConfig,
-	NormalizedAppConfig,
-} from '../workspace/types.js';
-
-/**
- * Resolve the hostname for an app based on stage configuration.
- *
- * Domain resolution priority:
- * 1. Explicit app.domain override (string or stage-specific)
- * 2. Default pattern based on app type:
- *    - Main frontend app gets base domain (e.g., 'myapp.com')
- *    - Other apps get prefixed domain (e.g., 'api.myapp.com')
- *
- * @param appName - The name of the app
- * @param app - The normalized app configuration
- * @param stage - The deployment stage (e.g., 'production', 'development')
- * @param dokployConfig - Dokploy workspace configuration with domain mappings
- * @param isMainFrontend - Whether this is the main frontend app
- * @returns The resolved hostname for the app
- * @throws Error if no domain configuration is found for the stage
- */
-export function resolveHost(
-	appName: string,
-	app: NormalizedAppConfig,
-	stage: string,
-	dokployConfig: DokployWorkspaceConfig | undefined,
-	isMainFrontend: boolean,
-): string {
-	// 1. Check for explicit app domain override
-	if (app.domain) {
-		if (typeof app.domain === 'string') {
-			return app.domain;
-		}
-		if (app.domain[stage]) {
-			return app.domain[stage]!;
-		}
-	}
-
-	// 2. Get base domain for this stage
-	const baseDomain = dokployConfig?.domains?.[stage];
-	if (!baseDomain) {
-		throw new Error(
-			`No domain configured for stage "${stage}". ` +
-				`Add deploy.dokploy.domains.${stage} to gkm.config.ts`,
-		);
-	}
-
-	// 3. Main frontend app gets base domain, others get prefix
-	if (isMainFrontend) {
-		return baseDomain;
-	}
-
-	return `${appName}.${baseDomain}`;
-}
-
-/**
- * Determine if an app is the "main" frontend (gets base domain).
- *
- * An app is considered the main frontend if:
- * 1. It's named 'web' and is a frontend type
- * 2. It's the first frontend app in the apps list
- *
- * @param appName - The name of the app to check
- * @param app - The app configuration
- * @param allApps - All apps in the workspace
- * @returns True if this is the main frontend app
- */
-export function isMainFrontendApp(
-	appName: string,
-	app: NormalizedAppConfig,
-	allApps: Record<string, NormalizedAppConfig>,
-): boolean {
-	if (app.type !== 'web') {
-		return false;
-	}
-
-	// App named 'web' is always main
-	if (appName === 'web') {
-		return true;
-	}
-
-	// Otherwise, check if this is the first frontend
-	for (const [name, a] of Object.entries(allApps)) {
-		if (a.type === 'web') {
-			return name === appName;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Generate public URL build args for a web/mobile app based on its dependencies.
- *
- * The prefix is chosen by the app's framework (NEXT_PUBLIC_, VITE_,
- * EXPO_PUBLIC_, or none for Remix). Apps without a public prefix get no
- * build args — they should fetch URLs at runtime instead.
- *
- * @param app - The web/mobile app configuration
- * @param deployedUrls - Map of app name to deployed public URL
- * @returns Array of build args like 'NEXT_PUBLIC_API_URL=https://api.example.com'
- */
-export function generatePublicUrlBuildArgs(
-	app: NormalizedAppConfig,
-	deployedUrls: Record<string, string>,
-): string[] {
-	const prefix = getPublicEnvPrefix(app);
-	if (!prefix) return [];
-
-	const buildArgs: string[] = [];
-	for (const dep of app.dependencies) {
-		const publicUrl = deployedUrls[dep];
-		if (publicUrl) {
-			buildArgs.push(`${prefix}${dep.toUpperCase()}_URL=${publicUrl}`);
-		}
-	}
-
-	return buildArgs;
-}
-
-/**
- * Get public URL arg names from app dependencies.
- *
- * @param app - The web/mobile app configuration
- * @returns Array of arg names like 'NEXT_PUBLIC_API_URL', or [] for frameworks
- *   without a public prefix (e.g. Remix).
- */
-export function getPublicUrlArgNames(app: NormalizedAppConfig): string[] {
-	const prefix = getPublicEnvPrefix(app);
-	if (!prefix) return [];
-	return app.dependencies.map((dep) => `${prefix}${dep.toUpperCase()}_URL`);
-}

package/src/deploy/env-resolver.ts

@@ -1,305 +0,0 @@
-/**
- * Environment Variable Resolution for Dokploy Deployments
- *
- * Resolves sniffed environment variables to actual values during deployment.
- * Auto-supports common variables like DATABASE_URL, REDIS_URL, BETTER_AUTH_*,
- * and falls back to user-provided secrets.
- */
-
-import { randomBytes } from 'node:crypto';
-import type { StageSecrets } from '../secrets/types';
-import { stripPublicPrefix } from '../workspace/publicEnv';
-import type { NormalizedAppConfig } from '../workspace/types';
-import {
-	type AppDbCredentials,
-	type DokployStageState,
-	getGeneratedSecret,
-	setGeneratedSecret,
-} from './state';
-
-/**
- * Context needed for environment variable resolution
- */
-export interface EnvResolverContext {
-	/** The app being deployed */
-	app: NormalizedAppConfig;
-	/** The app name */
-	appName: string;
-	/** Deployment stage (production, staging, development) */
-	stage: string;
-	/** Deploy state (for persisting generated secrets) */
-	state: DokployStageState;
-	/** Per-app database credentials (if postgres is enabled) */
-	appCredentials?: AppDbCredentials;
-	/** Postgres connection info (internal hostname) */
-	postgres?: {
-		host: string;
-		port: number;
-		database: string;
-	};
-	/** Redis connection info (internal hostname) */
-	redis?: {
-		host: string;
-		port: number;
-		password?: string;
-	};
-	/** Public hostname for this app */
-	appHostname: string;
-	/** All frontend app URLs (for BETTER_AUTH_TRUSTED_ORIGINS) */
-	frontendUrls: string[];
-	/** User-provided secrets from secrets store */
-	userSecrets?: StageSecrets;
-	/** Master key for runtime decryption (optional) */
-	masterKey?: string;
-	/** URLs of deployed dependency apps (e.g., { auth: 'https://auth.example.com' }) */
-	dependencyUrls?: Record<string, string>;
-}
-
-/**
- * Result of environment variable resolution
- */
-export interface EnvResolutionResult {
-	/** Successfully resolved environment variables */
-	resolved: Record<string, string>;
-	/** Environment variable names that could not be resolved */
-	missing: string[];
-}
-
-/**
- * Auto-supported environment variable names
- */
-export const AUTO_SUPPORTED_VARS = [
-	'PORT',
-	'NODE_ENV',
-	'STAGE',
-	'DATABASE_URL',
-	'REDIS_URL',
-	'BETTER_AUTH_URL',
-	'BETTER_AUTH_SECRET',
-	'BETTER_AUTH_TRUSTED_ORIGINS',
-	'GKM_MASTER_KEY',
-] as const;
-
-export type AutoSupportedVar = (typeof AUTO_SUPPORTED_VARS)[number];
-
-/**
- * Check if a variable name is auto-supported
- */
-export function isAutoSupportedVar(
-	varName: string,
-): varName is AutoSupportedVar {
-	return AUTO_SUPPORTED_VARS.includes(varName as AutoSupportedVar);
-}
-
-/**
- * Generate a secure random secret (64 hex characters = 32 bytes)
- */
-export function generateSecret(): string {
-	return randomBytes(32).toString('hex');
-}
-
-/**
- * Get or generate a secret for an app.
- * If the secret already exists in state, returns it.
- * Otherwise generates a new one and stores it.
- */
-export function getOrGenerateSecret(
-	state: DokployStageState,
-	appName: string,
-	secretName: string,
-): string {
-	// Check if already generated
-	const existing = getGeneratedSecret(state, appName, secretName);
-	if (existing) {
-		return existing;
-	}
-
-	// Generate new secret
-	const generated = generateSecret();
-
-	// Store in state for persistence
-	setGeneratedSecret(state, appName, secretName, generated);
-
-	return generated;
-}
-
-/**
- * Build a DATABASE_URL for an app with per-app credentials
- */
-export function buildDatabaseUrl(
-	credentials: AppDbCredentials,
-	postgres: { host: string; port: number; database: string },
-): string {
-	const { dbUser, dbPassword } = credentials;
-	const { host, port, database } = postgres;
-	return `postgresql://${encodeURIComponent(dbUser)}:${encodeURIComponent(dbPassword)}@${host}:${port}/${database}`;
-}
-
-/**
- * Build a REDIS_URL
- */
-export function buildRedisUrl(redis: {
-	host: string;
-	port: number;
-	password?: string;
-}): string {
-	const { host, port, password } = redis;
-	if (password) {
-		return `redis://:${encodeURIComponent(password)}@${host}:${port}`;
-	}
-	return `redis://${host}:${port}`;
-}
-
-/**
- * Resolve a single environment variable
- */
-export function resolveEnvVar(
-	varName: string,
-	context: EnvResolverContext,
-): string | undefined {
-	// Auto-supported variables
-	switch (varName) {
-		case 'PORT':
-			return String(context.app.port);
-
-		case 'NODE_ENV':
-			// Always 'production' for deployed apps (gkm dev handles development mode)
-			return 'production';
-
-		case 'STAGE':
-			return context.stage;
-
-		case 'DATABASE_URL':
-			if (context.appCredentials && context.postgres) {
-				return buildDatabaseUrl(context.appCredentials, context.postgres);
-			}
-			// Fall through to check user secrets
-			break;
-
-		case 'REDIS_URL':
-			if (context.redis) {
-				return buildRedisUrl(context.redis);
-			}
-			// Fall through to check user secrets
-			break;
-
-		case 'BETTER_AUTH_URL':
-			return `https://${context.appHostname}`;
-
-		case 'BETTER_AUTH_SECRET':
-			return getOrGenerateSecret(
-				context.state,
-				context.appName,
-				'BETTER_AUTH_SECRET',
-			);
-
-		case 'BETTER_AUTH_TRUSTED_ORIGINS':
-			if (context.frontendUrls.length > 0) {
-				return context.frontendUrls.join(',');
-			}
-			// Fall through to check user secrets
-			break;
-
-		case 'GKM_MASTER_KEY':
-			if (context.masterKey) {
-				return context.masterKey;
-			}
-			// Fall through to check user secrets
-			break;
-	}
-
-	// Check dependency URLs (e.g., AUTH_URL -> dependencyUrls.auth)
-	// Also supports any known public prefix (NEXT_PUBLIC_, VITE_, ...) so
-	// VITE_AUTH_URL and NEXT_PUBLIC_AUTH_URL both resolve to dependencyUrls.auth.
-	if (context.dependencyUrls && varName.endsWith('_URL')) {
-		const stripped = stripPublicPrefix(varName) ?? varName;
-		const depName = stripped.slice(0, -4).toLowerCase();
-
-		if (context.dependencyUrls[depName]) {
-			return context.dependencyUrls[depName];
-		}
-	}
-
-	// Check user-provided secrets
-	if (context.userSecrets) {
-		// Check custom secrets first
-		if (context.userSecrets.custom[varName]) {
-			return context.userSecrets.custom[varName];
-		}
-
-		// Check URLs (DATABASE_URL, REDIS_URL, RABBITMQ_URL)
-		if (varName in context.userSecrets.urls) {
-			return context.userSecrets.urls[
-				varName as keyof typeof context.userSecrets.urls
-			];
-		}
-
-		// Check service-specific vars
-		if (
-			varName === 'POSTGRES_PASSWORD' &&
-			context.userSecrets.services.postgres
-		) {
-			return context.userSecrets.services.postgres.password;
-		}
-		if (varName === 'REDIS_PASSWORD' && context.userSecrets.services.redis) {
-			return context.userSecrets.services.redis.password;
-		}
-	}
-
-	return undefined;
-}
-
-/**
- * Resolve all environment variables for an app
- */
-export function resolveEnvVars(
-	requiredVars: string[],
-	context: EnvResolverContext,
-): EnvResolutionResult {
-	const resolved: Record<string, string> = {};
-	const missing: string[] = [];
-
-	for (const varName of requiredVars) {
-		const value = resolveEnvVar(varName, context);
-		if (value !== undefined) {
-			resolved[varName] = value;
-		} else {
-			missing.push(varName);
-		}
-	}
-
-	return { resolved, missing };
-}
-
-/**
- * Format missing variables error message
- */
-export function formatMissingVarsError(
-	appName: string,
-	missing: string[],
-	stage: string,
-): string {
-	const varList = missing.map((v) => `  - ${v}`).join('\n');
-	return (
-		`Deployment failed: ${appName} is missing required environment variables:\n` +
-		`${varList}\n\n` +
-		`Add them with:\n` +
-		`  gkm secrets:set <VAR_NAME> <value> --stage ${stage}\n\n` +
-		`Or add them to the app's requiredEnv in gkm.config.ts to have them auto-resolved.`
-	);
-}
-
-/**
- * Validate that all required environment variables can be resolved
- */
-export function validateEnvVars(
-	requiredVars: string[],
-	context: EnvResolverContext,
-): { valid: boolean; missing: string[]; resolved: Record<string, string> } {
-	const { resolved, missing } = resolveEnvVars(requiredVars, context);
-	return {
-		valid: missing.length === 0,
-		missing,
-		resolved,
-	};
-}