@geekmidas/cli 0.13.0 → 0.14.0

package/src/deploy/init.ts

@@ -1,7 +1,13 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getDokployCredentials, getDokployToken } from '../auth';
+import {
+	getDokployCredentials,
+	getDokployRegistryId,
+	getDokployToken,
+	storeDokployRegistryId,
+} from '../auth';
+import { DokployApi } from './dokploy-api';
 import type { DokployDeployConfig } from './types';
 
 const logger = console;
@@ -15,37 +21,23 @@ export interface DeployInitOptions {
 	appName: string;
 	/** Use existing project ID instead of creating/finding */
 	projectId?: string;
-	/** Registry ID in Dokploy (optional) */
+	/** Registry ID in Dokploy (optional, uses stored if available) */
 	registryId?: string;
 }
 
-interface DokployProject {
-	projectId: string;
-	name: string;
-	description: string | null;
-	createdAt: string;
-	adminId: string;
-	environments?: Array<{
-		environmentId: string;
-		name: string;
-		description: string | null;
-	}>;
-}
-
-interface DokployApplication {
-	applicationId: string;
-	name: string;
-	appName: string;
-	projectId: string;
-	environmentId?: string;
-}
-
-interface DokployRegistry {
-	registryId: string;
+export interface RegistrySetupOptions {
+	/** Dokploy endpoint URL (optional if logged in) */
+	endpoint?: string;
+	/** Registry name (for display in Dokploy) */
 	registryName: string;
+	/** Registry URL (e.g., ghcr.io, docker.io) */
 	registryUrl: string;
+	/** Registry username */
 	username: string;
-	imagePrefix: string | null;
+	/** Registry password or token */
+	password: string;
+	/** Image prefix (optional, e.g., org-name) */
+	imagePrefix?: string;
 }
 
 /**
@@ -63,169 +55,30 @@ async function getApiToken(): Promise<string> {
 }
 
 /**
- * Make a request to the Dokploy API
+ * Get Dokploy endpoint from options or stored credentials
  */
-async function dokployRequest<T>(
-	method: 'GET' | 'POST',
-	endpoint: string,
-	baseUrl: string,
-	token: string,
-	body?: Record<string, unknown>,
-): Promise<T> {
-	const url = `${baseUrl}/api/${endpoint}`;
-
-	const response = await fetch(url, {
-		method,
-		headers: {
-			'Content-Type': 'application/json',
-			Authorization: `Bearer ${token}`,
-		},
-		body: body ? JSON.stringify(body) : undefined,
-	});
-
-	if (!response.ok) {
-		let errorMessage = `Dokploy API error: ${response.status} ${response.statusText}`;
-
-		try {
-			const errorBody = (await response.json()) as { message?: string };
-			if (errorBody.message) {
-				errorMessage = `Dokploy API error: ${errorBody.message}`;
-			}
-		} catch {
-			// Ignore JSON parse errors
-		}
-
-		throw new Error(errorMessage);
-	}
-
-	// Handle empty responses
-	const text = await response.text();
-	if (!text) {
-		return {} as T;
+async function getEndpoint(providedEndpoint?: string): Promise<string> {
+	if (providedEndpoint) {
+		return providedEndpoint;
 	}
 
-	return JSON.parse(text) as T;
-}
-
-/**
- * Get all projects from Dokploy
- */
-async function getProjects(
-	baseUrl: string,
-	token: string,
-): Promise<DokployProject[]> {
-	return dokployRequest<DokployProject[]>('GET', 'project.all', baseUrl, token);
-}
-
-/**
- * Create a new project in Dokploy
- */
-async function createProject(
-	baseUrl: string,
-	token: string,
-	name: string,
-	description?: string,
-): Promise<DokployProject> {
-	return dokployRequest<DokployProject>(
-		'POST',
-		'project.create',
-		baseUrl,
-		token,
-		{
-			name,
-			description: description || `Created by gkm CLI`,
-		},
-	);
-}
-
-/**
- * Get project by ID to get environment info
- */
-async function getProject(
-	baseUrl: string,
-	token: string,
-	projectId: string,
-): Promise<DokployProject> {
-	return dokployRequest<DokployProject>('POST', 'project.one', baseUrl, token, {
-		projectId,
-	});
-}
-
-/**
- * Create a new application in Dokploy
- */
-async function createApplication(
-	baseUrl: string,
-	token: string,
-	name: string,
-	projectId: string,
-): Promise<DokployApplication> {
-	// First get the project to find its environment ID
-	const project = await getProject(baseUrl, token, projectId);
-
-	// Use the first environment or create one
-	let environmentId: string;
-
-	const firstEnv = project.environments?.[0];
-	if (firstEnv) {
-		environmentId = firstEnv.environmentId;
-	} else {
-		// Create a default environment
-		const env = await dokployRequest<{ environmentId: string }>(
-			'POST',
-			'environment.create',
-			baseUrl,
-			token,
-			{
-				projectId,
-				name: 'production',
-				description: 'Production environment',
-			},
-		);
-		environmentId = env.environmentId;
+	const stored = await getDokployCredentials();
+	if (stored) {
+		return stored.endpoint;
 	}
 
-	return dokployRequest<DokployApplication>(
-		'POST',
-		'application.create',
-		baseUrl,
-		token,
-		{
-			name,
-			projectId,
-			environmentId,
-		},
+	throw new Error(
+		'Dokploy endpoint not specified.\n' +
+			'Either run "gkm login --service dokploy" first, or provide --endpoint.',
 	);
 }
 
 /**
- * Configure application for Docker registry deployment
+ * Create a Dokploy API client
  */
-async function configureApplicationRegistry(
-	baseUrl: string,
-	token: string,
-	applicationId: string,
-	registryId: string,
-): Promise<void> {
-	await dokployRequest('POST', 'application.update', baseUrl, token, {
-		applicationId,
-		registryId,
-	});
-}
-
-/**
- * Get available registries
- */
-async function getRegistries(
-	baseUrl: string,
-	token: string,
-): Promise<DokployRegistry[]> {
-	return dokployRequest<DokployRegistry[]>(
-		'GET',
-		'registry.all',
-		baseUrl,
-		token,
-	);
+async function createApi(endpoint: string): Promise<DokployApi> {
+	const token = await getApiToken();
+	return new DokployApi({ baseUrl: endpoint, token });
 }
 
 /**
@@ -259,31 +112,29 @@ export async function updateConfig(
 		logger.log('  Updating with new values...');
 	}
 
+	// Build the dokploy config string
+	const registryLine = config.registryId
+		? `\n\t\t\tregistryId: '${config.registryId}',`
+		: '';
+	const dokployConfigStr = `dokploy: {
+			endpoint: '${config.endpoint}',
+			projectId: '${config.projectId}',
+			applicationId: '${config.applicationId}',${registryLine}
+		}`;
+
 	// Try to add or update the dokploy config
 	let newContent: string;
 
 	if (content.includes('providers:')) {
 		// Add dokploy to existing providers
 		if (content.includes('dokploy:')) {
-			// Update existing dokploy config
-			newContent = content.replace(
-				/dokploy:\s*\{[^}]*\}/,
-				`dokploy: {
-			endpoint: '${config.endpoint}',
-			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		}`,
-			);
+			// Update existing dokploy config (handle multi-line with registryId)
+			newContent = content.replace(/dokploy:\s*\{[^}]*\}/s, dokployConfigStr);
 		} else {
 			// Add dokploy to providers
 			newContent = content.replace(
 				/providers:\s*\{/,
-				`providers: {
-		dokploy: {
-			endpoint: '${config.endpoint}',
-			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		},`,
+				`providers: {\n\t\t${dokployConfigStr},`,
 			);
 		}
 	} else {
@@ -292,11 +143,7 @@ export async function updateConfig(
 			/}\s*\)\s*;?\s*$/,
 			`
 	providers: {
-		dokploy: {
-			endpoint: '${config.endpoint}',
-			projectId: '${config.projectId}',
-			applicationId: '${config.applicationId}',
-		},
+		${dokployConfigStr},
 	},
 });`,
 		);
@@ -319,25 +166,12 @@ export async function deployInitCommand(
 		registryId,
 	} = options;
 
-	// Get endpoint from options or stored credentials
-	let endpoint = options.endpoint;
-	if (!endpoint) {
-		const stored = await getDokployCredentials();
-		if (stored) {
-			endpoint = stored.endpoint;
-		} else {
-			throw new Error(
-				'Dokploy endpoint not specified.\n' +
-					'Either run "gkm login --service dokploy" first, or provide --endpoint.',
-			);
-		}
-	}
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
 
 	logger.log(`\n🚀 Initializing Dokploy deployment...`);
 	logger.log(`   Endpoint: ${endpoint}`);
 
-	const token = await getApiToken();
-
 	// Step 1: Find or create project
 	let projectId: string;
 
@@ -347,7 +181,7 @@ export async function deployInitCommand(
 	} else {
 		logger.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(),
 		);
@@ -357,36 +191,44 @@ export async function deployInitCommand(
 			logger.log(`   Found existing project: ${projectId}`);
 		} else {
 			logger.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.log(`   ✓ Created project: ${projectId}`);
 		}
 	}
 
-	// Step 2: Create application
+	// Step 2: Get project to find environment
+	const project = await api.getProject(projectId);
+	let environmentId: string;
+
+	const firstEnv = project.environments?.[0];
+	if (firstEnv) {
+		environmentId = firstEnv.environmentId;
+	} else {
+		// Create a default environment
+		logger.log(`   Creating production environment...`);
+		const env = await api.createEnvironment(projectId, 'production');
+		environmentId = env.environmentId;
+	}
+
+	// Step 3: Create application
 	logger.log(`\n📦 Creating application: ${appName}`);
-	const application = await createApplication(
-		endpoint,
-		token,
+	const application = await api.createApplication(
 		appName,
 		projectId,
+		environmentId,
 	);
 	logger.log(`   ✓ Created application: ${application.applicationId}`);
 
-	// Step 3: Configure registry if provided
+	// Step 4: Configure registry if provided
 	if (registryId) {
 		logger.log(`\n🔧 Configuring registry: ${registryId}`);
-		await configureApplicationRegistry(
-			endpoint,
-			token,
-			application.applicationId,
-			registryId,
-		);
+		await api.updateApplication(application.applicationId, { registryId });
 		logger.log(`   ✓ Registry configured`);
 	} else {
 		// List available registries
 		try {
-			const registries = await getRegistries(endpoint, token);
+			const registries = await api.listRegistries();
 			if (registries.length > 0) {
 				logger.log(`\n📋 Available registries:`);
 				for (const reg of registries) {
@@ -401,14 +243,14 @@ export async function deployInitCommand(
 		}
 	}
 
-	// Step 4: Build config
+	// Step 5: Build config
 	const config: DokployDeployConfig = {
 		endpoint,
 		projectId,
 		applicationId: application.applicationId,
 	};
 
-	// Step 5: Update gkm.config.ts
+	// Step 6: Update gkm.config.ts
 	await updateConfig(config);
 
 	logger.log(`\n✅ Dokploy deployment initialized!`);
@@ -430,26 +272,14 @@ export async function deployListCommand(options: {
 	endpoint?: string;
 	resource: 'projects' | 'registries';
 }): Promise<void> {
-	// Get endpoint from options or stored credentials
-	let endpoint = options.endpoint;
-	if (!endpoint) {
-		const stored = await getDokployCredentials();
-		if (stored) {
-			endpoint = stored.endpoint;
-		} else {
-			throw new Error(
-				'Dokploy endpoint not specified.\n' +
-					'Either run "gkm login --service dokploy" first, or provide --endpoint.',
-			);
-		}
-	}
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
 
 	const { resource } = options;
-	const token = await getApiToken();
 
 	if (resource === 'projects') {
 		logger.log(`\n📁 Projects in ${endpoint}:`);
-		const projects = await getProjects(endpoint, token);
+		const projects = await api.listProjects();
 
 		if (projects.length === 0) {
 			logger.log('   No projects found');
@@ -464,16 +294,22 @@ export async function deployListCommand(options: {
 		}
 	} else if (resource === 'registries') {
 		logger.log(`\n🐳 Registries in ${endpoint}:`);
-		const registries = await getRegistries(endpoint, token);
+		const registries = await api.listRegistries();
 
 		if (registries.length === 0) {
 			logger.log('   No registries configured');
-			logger.log('   Add a registry in Dokploy: Settings > Docker Registry');
+			logger.log('   Run "gkm registry:setup" to configure a registry');
 			return;
 		}
 
+		const storedRegistryId = await getDokployRegistryId();
+
 		for (const registry of registries) {
-			logger.log(`\n   ${registry.registryName} (${registry.registryId})`);
+			const isDefault = registry.registryId === storedRegistryId;
+			const marker = isDefault ? ' (default)' : '';
+			logger.log(
+				`\n   ${registry.registryName}${marker} (${registry.registryId})`,
+			);
 			logger.log(`     URL: ${registry.registryUrl}`);
 			logger.log(`     Username: ${registry.username}`);
 			if (registry.imagePrefix) {
@@ -482,3 +318,110 @@ export async function deployListCommand(options: {
 		}
 	}
 }
+
+/**
+ * Setup a Docker registry in Dokploy
+ */
+export async function registrySetupCommand(
+	options: RegistrySetupOptions,
+): Promise<string> {
+	const { registryName, registryUrl, username, password, imagePrefix } =
+		options;
+
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
+
+	logger.log(`\n🐳 Setting up Docker registry in Dokploy...`);
+	logger.log(`   Endpoint: ${endpoint}`);
+
+	// Check if registry with same URL already exists
+	const existingRegistries = await api.listRegistries();
+	const existing = existingRegistries.find(
+		(r) =>
+			r.registryUrl === registryUrl ||
+			r.registryName.toLowerCase() === registryName.toLowerCase(),
+	);
+
+	let registryId: string;
+
+	if (existing) {
+		logger.log(`\n📋 Found existing registry: ${existing.registryName}`);
+		logger.log(`   Updating credentials...`);
+
+		await api.updateRegistry(existing.registryId, {
+			registryName,
+			username,
+			password,
+			imagePrefix,
+		});
+
+		registryId = existing.registryId;
+		logger.log(`   ✓ Registry updated: ${registryId}`);
+	} else {
+		logger.log(`\n📦 Creating registry: ${registryName}`);
+
+		const registry = await api.createRegistry(
+			registryName,
+			registryUrl,
+			username,
+			password,
+			{ imagePrefix },
+		);
+
+		registryId = registry.registryId;
+		logger.log(`   ✓ Registry created: ${registryId}`);
+	}
+
+	// Store registry ID in credentials
+	await storeDokployRegistryId(registryId);
+	logger.log(`\n💾 Saved registry ID to ~/.gkm/credentials.json`);
+
+	logger.log(`\n✅ Registry setup complete!`);
+	logger.log(`\n📋 Registry Details:`);
+	logger.log(`   ID: ${registryId}`);
+	logger.log(`   Name: ${registryName}`);
+	logger.log(`   URL: ${registryUrl}`);
+	logger.log(`   Username: ${username}`);
+	if (imagePrefix) {
+		logger.log(`   Prefix: ${imagePrefix}`);
+	}
+
+	logger.log(
+		`\n📝 The registry ID is now stored and will be used automatically`,
+	);
+	logger.log(`   when deploying with "gkm deploy --provider dokploy"`);
+
+	return registryId;
+}
+
+/**
+ * Use an existing registry (set as default)
+ */
+export async function registryUseCommand(options: {
+	endpoint?: string;
+	registryId: string;
+}): Promise<void> {
+	const { registryId } = options;
+
+	const endpoint = await getEndpoint(options.endpoint);
+	const api = await createApi(endpoint);
+
+	logger.log(`\n🔧 Setting default registry...`);
+
+	// Verify the registry exists
+	try {
+		const registry = await api.getRegistry(registryId);
+		logger.log(`   Found registry: ${registry.registryName}`);
+	} catch {
+		throw new Error(
+			`Registry not found: ${registryId}\n` +
+				'Run "gkm deploy:list registries" to see available registries.',
+		);
+	}
+
+	// Store registry ID in credentials
+	await storeDokployRegistryId(registryId);
+
+	logger.log(`\n✅ Default registry set: ${registryId}`);
+	logger.log(`   This registry will be used for future deployments.`);
+}

package/src/deploy/types.ts

@@ -43,6 +43,24 @@ export interface DokployDeployConfig {
 	projectId: string;
 	/** Application ID in Dokploy */
 	applicationId: string;
-	/** Container registry (inherits from docker if not set) */
+	/** Container registry URL (inherits from docker if not set) */
 	registry?: string;
+	/**
+	 * Registry ID in Dokploy (recommended for private registries).
+	 * Configure your registry in Dokploy Settings > Docker Registry first.
+	 */
+	registryId?: string;
+	/**
+	 * Docker registry credentials (alternative to registryId).
+	 * Only needed if not using Dokploy's registry feature.
+	 * Can also use env vars: DOCKER_REGISTRY_USERNAME, DOCKER_REGISTRY_PASSWORD
+	 */
+	registryCredentials?: {
+		/** Registry URL (e.g., ghcr.io, docker.io) */
+		registryUrl: string;
+		/** Registry username */
+		username: string;
+		/** Registry password or token */
+		password: string;
+	};
 }

package/src/dev/__tests__/index.spec.ts

@@ -4,6 +4,9 @@ import { afterEach, describe, expect, it } from 'vitest';
 import {
 	findAvailablePort,
 	isPortAvailable,
+	normalizeHooksConfig,
+	normalizeProductionConfig,
+	normalizeStudioConfig,
 	normalizeTelescopeConfig,
 } from '../index';
 
@@ -301,3 +304,95 @@ describe('normalizeTelescopeConfig', () => {
 		});
 	});
 });
+
+describe('normalizeStudioConfig', () => {
+	it('should return undefined when config is false', () => {
+		const result = normalizeStudioConfig(false);
+		expect(result).toBeUndefined();
+	});
+
+	it('should return default config when config is true', () => {
+		const result = normalizeStudioConfig(true);
+		expect(result).toEqual({
+			enabled: true,
+			path: '/__studio',
+			schema: 'public',
+		});
+	});
+
+	it('should return default config when config is undefined', () => {
+		const result = normalizeStudioConfig(undefined);
+		expect(result).toEqual({
+			enabled: true,
+			path: '/__studio',
+			schema: 'public',
+		});
+	});
+
+	it('should return undefined when config.enabled is false', () => {
+		const result = normalizeStudioConfig({ enabled: false });
+		expect(result).toBeUndefined();
+	});
+
+	it('should merge custom config with defaults', () => {
+		const result = normalizeStudioConfig({
+			path: '/__db',
+			schema: 'custom_schema',
+		});
+		expect(result).toEqual({
+			enabled: true,
+			path: '/__db',
+			schema: 'custom_schema',
+		});
+	});
+});
+
+describe('normalizeHooksConfig', () => {
+	it('should return undefined when no hooks configured', () => {
+		const result = normalizeHooksConfig(undefined);
+		expect(result).toBeUndefined();
+	});
+
+	it('should return undefined when server hook not configured', () => {
+		const result = normalizeHooksConfig({});
+		expect(result).toBeUndefined();
+	});
+
+	it('should return path when server hook is configured', () => {
+		const result = normalizeHooksConfig({ server: './src/hooks' });
+		expect(result).toBeDefined();
+		expect(result?.serverHooksPath).toContain('src/hooks.ts');
+	});
+
+	it('should handle .ts extension in path', () => {
+		const result = normalizeHooksConfig({ server: './src/hooks.ts' });
+		expect(result).toBeDefined();
+		expect(result?.serverHooksPath).toContain('src/hooks.ts');
+	});
+});
+
+describe('normalizeProductionConfig', () => {
+	it('should return undefined when cliProduction is false', () => {
+		const result = normalizeProductionConfig(false);
+		expect(result).toBeUndefined();
+	});
+
+	it('should return undefined when cliProduction is false even with config', () => {
+		const result = normalizeProductionConfig(false, { bundle: true });
+		expect(result).toBeUndefined();
+	});
+
+	it('should return default config when cliProduction is true', () => {
+		const result = normalizeProductionConfig(true);
+		expect(result).toBeDefined();
+		expect(result?.enabled).toBe(true);
+		expect(result?.bundle).toBe(true);
+	});
+
+	it('should merge custom config with defaults', () => {
+		const result = normalizeProductionConfig(true, { bundle: false });
+		expect(result).toBeDefined();
+		expect(result?.enabled).toBe(true);
+		expect(result?.bundle).toBe(false);
+	});
+});