@geekmidas/cli 1.10.7 → 1.10.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.7",
+  "version": "1.10.9",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -56,11 +56,11 @@
     "prompts": "~2.4.2",
     "tsx": "~4.20.3",
     "yaml": "~2.8.2",
-    "@geekmidas/errors": "~1.0.0",
-    "@geekmidas/envkit": "~1.0.3",
     "@geekmidas/logger": "~1.0.0",
+    "@geekmidas/envkit": "~1.0.3",
     "@geekmidas/constructs": "~3.0.2",
-    "@geekmidas/schema": "~1.0.0"
+    "@geekmidas/schema": "~1.0.0",
+    "@geekmidas/errors": "~1.0.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",
@@ -70,7 +70,7 @@
     "typescript": "^5.8.2",
     "vitest": "^3.2.4",
     "zod": "~4.1.13",
-    "@geekmidas/testkit": "1.0.2"
+    "@geekmidas/testkit": "1.0.5"
   },
   "peerDependencies": {
     "@geekmidas/telescope": "~1.0.0"

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

@@ -9,6 +9,7 @@ import type {
 	NormalizedWorkspace,
 } from '../../workspace/index.js';
 import {
+	buildDockerComposeEnv,
 	checkPortConflicts,
 	findAvailablePort,
 	generateAllDependencyEnvVars,
@@ -21,6 +22,7 @@ import {
 	normalizeStudioConfig,
 	normalizeTelescopeConfig,
 	parseComposePortMappings,
+	parseComposeServiceNames,
 	replacePortInUrl,
 	rewriteUrlsWithPorts,
 	savePortState,
@@ -1706,6 +1708,78 @@ services:
 	});
 });
 
+describe('parseComposeServiceNames', () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `gkm-test-service-names-${Date.now()}`);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
+
+	it('should return all service names from docker-compose.yml', () => {
+		const composePath = join(testDir, 'docker-compose.yml');
+		writeFileSync(
+			composePath,
+			`services:
+  postgres:
+    image: postgres:18-alpine
+  redis:
+    image: redis:7-alpine
+  minio:
+    image: minio/minio:latest
+`,
+		);
+
+		const names = parseComposeServiceNames(composePath);
+		expect(names).toEqual(['postgres', 'redis', 'minio']);
+	});
+
+	it('should return empty array when file does not exist', () => {
+		const names = parseComposeServiceNames(join(testDir, 'missing.yml'));
+		expect(names).toEqual([]);
+	});
+
+	it('should return empty array when no services defined', () => {
+		const composePath = join(testDir, 'docker-compose.yml');
+		writeFileSync(composePath, 'version: "3.8"\n');
+
+		const names = parseComposeServiceNames(composePath);
+		expect(names).toEqual([]);
+	});
+
+	it('should include app and infrastructure services', () => {
+		const composePath = join(testDir, 'docker-compose.yml');
+		writeFileSync(
+			composePath,
+			`services:
+  api:
+    build: .
+  web:
+    build: .
+  postgres:
+    image: postgres:18-alpine
+  redis:
+    image: redis:7-alpine
+  custom-service:
+    image: custom:latest
+`,
+		);
+
+		const names = parseComposeServiceNames(composePath);
+		expect(names).toEqual([
+			'api',
+			'web',
+			'postgres',
+			'redis',
+			'custom-service',
+		]);
+	});
+});
+
 describe('generateServerEntryContent', () => {
 	it('should use dynamic import for createApp when secrets are provided', () => {
 		const content = generateServerEntryContent({
@@ -1753,3 +1827,71 @@ describe('generateServerEntryContent', () => {
 		expect(content).toContain("await import('./custom-app.js')");
 	});
 });
+
+describe('buildDockerComposeEnv', () => {
+	it('should include secrets in the env passed to docker compose', () => {
+		const secretsEnv = {
+			POSTGRES_USER: 'app',
+			POSTGRES_PASSWORD: 'supersecret',
+			POSTGRES_DB: 'myproject_dev',
+		};
+		const portEnv = { POSTGRES_HOST_PORT: '5434' };
+
+		const env = buildDockerComposeEnv(secretsEnv, portEnv);
+
+		expect(env.POSTGRES_USER).toBe('app');
+		expect(env.POSTGRES_PASSWORD).toBe('supersecret');
+		expect(env.POSTGRES_DB).toBe('myproject_dev');
+		expect(env.POSTGRES_HOST_PORT).toBe('5434');
+	});
+
+	it('should include multiple service secrets', () => {
+		const secretsEnv = {
+			POSTGRES_USER: 'app',
+			POSTGRES_PASSWORD: 'dbpass',
+			REDIS_PASSWORD: 'redispass',
+		};
+
+		const env = buildDockerComposeEnv(secretsEnv, {});
+
+		expect(env.POSTGRES_USER).toBe('app');
+		expect(env.POSTGRES_PASSWORD).toBe('dbpass');
+		expect(env.REDIS_PASSWORD).toBe('redispass');
+	});
+
+	it('should let port env override secrets env for same key', () => {
+		const secretsEnv = { POSTGRES_HOST_PORT: '5432' };
+		const portEnv = { POSTGRES_HOST_PORT: '5434' };
+
+		const env = buildDockerComposeEnv(secretsEnv, portEnv);
+
+		expect(env.POSTGRES_HOST_PORT).toBe('5434');
+	});
+
+	it('should work without secrets env', () => {
+		const env = buildDockerComposeEnv(undefined, {
+			POSTGRES_HOST_PORT: '5434',
+		});
+
+		expect(env.POSTGRES_HOST_PORT).toBe('5434');
+	});
+
+	it('should work without any arguments', () => {
+		const env = buildDockerComposeEnv();
+
+		// Should at least have process.env
+		expect(env.PATH).toBeDefined();
+	});
+
+	it('should include process.env as base', () => {
+		const env = buildDockerComposeEnv(
+			{ POSTGRES_USER: 'app' },
+			{ POSTGRES_HOST_PORT: '5434' },
+		);
+
+		// process.env values should be present
+		expect(env.PATH).toBeDefined();
+		// Custom values should override
+		expect(env.POSTGRES_USER).toBe('app');
+	});
+});

package/src/dev/index.ts

@@ -274,6 +274,8 @@ export async function resolveServicePorts(
 	const savedState = await loadPortState(workspaceRoot);
 	const dockerEnv: Record<string, string> = {};
 	const ports: PortState = {};
+	// Track ports assigned in this cycle to avoid duplicates
+	const assignedPorts = new Set<number>();
 
 	logger.log('\n🔌 Resolving service ports...');
 
@@ -287,6 +289,7 @@ export async function resolveServicePorts(
 		if (containerPort !== null) {
 			ports[mapping.envVar] = containerPort;
 			dockerEnv[mapping.envVar] = String(containerPort);
+			assignedPorts.add(containerPort);
 			logger.log(
 				`   🔄 ${mapping.service}:${mapping.containerPort}: reusing existing container on port ${containerPort}`,
 			);
@@ -295,19 +298,28 @@ export async function resolveServicePorts(
 
 		// 2. Check saved port state
 		const savedPort = savedState[mapping.envVar];
-		if (savedPort && (await isPortAvailable(savedPort))) {
+		if (
+			savedPort &&
+			!assignedPorts.has(savedPort) &&
+			(await isPortAvailable(savedPort))
+		) {
 			ports[mapping.envVar] = savedPort;
 			dockerEnv[mapping.envVar] = String(savedPort);
+			assignedPorts.add(savedPort);
 			logger.log(
 				`   💾 ${mapping.service}:${mapping.containerPort}: using saved port ${savedPort}`,
 			);
 			continue;
 		}
 
-		// 3. Find available port
-		const resolvedPort = await findAvailablePort(mapping.defaultPort);
+		// 3. Find available port (skipping ports already assigned this cycle)
+		let resolvedPort = await findAvailablePort(mapping.defaultPort);
+		while (assignedPorts.has(resolvedPort)) {
+			resolvedPort = await findAvailablePort(resolvedPort + 1);
+		}
 		ports[mapping.envVar] = resolvedPort;
 		dockerEnv[mapping.envVar] = String(resolvedPort);
+		assignedPorts.add(resolvedPort);
 
 		if (resolvedPort !== mapping.defaultPort) {
 			logger.log(
@@ -1111,30 +1123,59 @@ export async function loadSecretsForApp(
 	return mapped;
 }
 
+/**
+ * Build the environment variables to pass to `docker compose up`.
+ * Merges process.env, secrets, and port mappings so that Docker Compose
+ * can interpolate variables like ${POSTGRES_USER} correctly.
+ * @internal Exported for testing
+ */
+export function buildDockerComposeEnv(
+	secretsEnv?: Record<string, string>,
+	portEnv?: Record<string, string>,
+): Record<string, string | undefined> {
+	return { ...process.env, ...secretsEnv, ...portEnv };
+}
+
+/**
+ * Parse all service names from a docker-compose.yml file.
+ * @internal Exported for testing
+ */
+export function parseComposeServiceNames(composePath: string): string[] {
+	if (!existsSync(composePath)) {
+		return [];
+	}
+
+	const content = readFileSync(composePath, 'utf-8');
+	const compose = parseYaml(content) as {
+		services?: Record<string, unknown>;
+	};
+
+	return Object.keys(compose?.services ?? {});
+}
+
 /**
  * Start docker-compose services for the workspace.
+ * Parses the docker-compose.yml to discover all services and starts
+ * everything except app services (which are managed by turbo).
+ * This ensures manually added services are always started.
  * @internal Exported for testing
  */
 export async function startWorkspaceServices(
 	workspace: NormalizedWorkspace,
 	portEnv?: Record<string, string>,
+	secretsEnv?: Record<string, string>,
 ): Promise<void> {
-	const services = workspace.services;
-	if (!services.db && !services.cache && !services.mail) {
+	const composeFile = join(workspace.root, 'docker-compose.yml');
+	if (!existsSync(composeFile)) {
 		return;
 	}
 
-	const servicesToStart: string[] = [];
+	// Discover all services from docker-compose.yml
+	const allServices = parseComposeServiceNames(composeFile);
 
-	if (services.db) {
-		servicesToStart.push('postgres');
-	}
-	if (services.cache) {
-		servicesToStart.push('redis');
-	}
-	if (services.mail) {
-		servicesToStart.push('mailpit');
-	}
+	// Exclude app services (managed by turbo, not docker)
+	const appNames = new Set(Object.keys(workspace.apps));
+	const servicesToStart = allServices.filter((name) => !appNames.has(name));
 
 	if (servicesToStart.length === 0) {
 		return;
@@ -1143,20 +1184,12 @@ export async function startWorkspaceServices(
 	logger.log(`🐳 Starting services: ${servicesToStart.join(', ')}`);
 
 	try {
-		// Check if docker-compose.yml exists
-		const composeFile = join(workspace.root, 'docker-compose.yml');
-		if (!existsSync(composeFile)) {
-			logger.warn(
-				'⚠️  No docker-compose.yml found. Services will not be started.',
-			);
-			return;
-		}
-
-		// Start services with docker-compose
+		// Start services with docker-compose, passing secrets so that
+		// POSTGRES_USER, POSTGRES_PASSWORD, etc. are interpolated correctly
 		execSync(`docker compose up -d ${servicesToStart.join(' ')}`, {
 			cwd: workspace.root,
 			stdio: 'inherit',
-			env: { ...process.env, ...portEnv },
+			env: buildDockerComposeEnv(secretsEnv, portEnv),
 		});
 
 		logger.log('✅ Services started');
@@ -1246,14 +1279,15 @@ async function workspaceDevCommand(
 	// Resolve dynamic service ports from docker-compose.yml
 	const resolvedPorts = await resolveServicePorts(workspace.root);
 
-	// Start docker-compose services with resolved ports
-	await startWorkspaceServices(workspace, resolvedPorts.dockerEnv);
+	// Load secrets BEFORE starting Docker so POSTGRES_USER, POSTGRES_PASSWORD,
+	// etc. are available for docker-compose variable interpolation
+	const rawSecrets = await loadDevSecrets(workspace);
 
-	// Load secrets if enabled, then rewrite URLs with resolved ports
-	const secretsEnv = rewriteUrlsWithPorts(
-		await loadDevSecrets(workspace),
-		resolvedPorts,
-	);
+	// Start docker-compose services with resolved ports AND secrets
+	await startWorkspaceServices(workspace, resolvedPorts.dockerEnv, rawSecrets);
+
+	// Rewrite URLs with resolved ports (hostnames and port numbers)
+	const secretsEnv = rewriteUrlsWithPorts(rawSecrets, resolvedPorts);
 	if (Object.keys(secretsEnv).length > 0) {
 		logger.log(`   Loaded ${Object.keys(secretsEnv).length} secret(s)`);
 	}

package/src/docker/__tests__/compose.spec.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import type { ComposeServiceName } from '../../types';
 import type { NormalizedWorkspace } from '../../workspace/types.js';
 import {
 	type ComposeOptions,
@@ -10,7 +11,7 @@ import {
 } from '../compose';
 
 /** Helper to get full default image reference */
-function getDefaultImage(service: 'postgres' | 'redis' | 'rabbitmq'): string {
+function getDefaultImage(service: ComposeServiceName): string {
 	return `${DEFAULT_SERVICE_IMAGES[service]}:${DEFAULT_SERVICE_VERSIONS[service]}`;
 }
 
@@ -344,6 +345,90 @@ describe('generateDockerCompose', () => {
 		});
 	});
 
+	describe('minio service', () => {
+		it('should add S3 environment variables', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('- S3_ENDPOINT=${S3_ENDPOINT:-http://minio:9000}');
+			expect(yaml).toContain('- S3_ACCESS_KEY_ID=${MINIO_ACCESS_KEY:-app}');
+			expect(yaml).toContain('- S3_SECRET_ACCESS_KEY=${MINIO_SECRET_KEY:-app}');
+			expect(yaml).toContain('- S3_BUCKET=${MINIO_BUCKET:-app}');
+			expect(yaml).toContain('- S3_REGION=${S3_REGION:-eu-west-1}');
+			expect(yaml).toContain('- S3_FORCE_PATH_STYLE=true');
+		});
+
+		it('should add minio service definition with default image', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('minio:');
+			expect(yaml).toContain(`image: ${getDefaultImage('minio')}`);
+			expect(yaml).toContain('container_name: minio');
+		});
+
+		it('should use custom minio version', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: { version: 'RELEASE.2024-01-01' } },
+			});
+
+			expect(yaml).toContain('image: minio/minio:RELEASE.2024-01-01');
+		});
+
+		it('should configure minio credentials', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('MINIO_ROOT_USER: ${MINIO_ACCESS_KEY:-app}');
+			expect(yaml).toContain('MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY:-app}');
+		});
+
+		it('should expose console UI port', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('- "9001:9001"');
+		});
+
+		it('should add minio volume', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('- minio_data:/data');
+			expect(yaml).toContain('minio_data:');
+		});
+
+		it('should include minio healthcheck', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('test: ["CMD", "mc", "ready", "local"]');
+		});
+
+		it('should add depends_on for minio', () => {
+			const yaml = generateDockerCompose({
+				...baseOptions,
+				services: { minio: true },
+			});
+
+			expect(yaml).toContain('depends_on:');
+			expect(yaml).toContain('condition: service_healthy');
+		});
+	});
+
 	describe('multiple services', () => {
 		it('should include all services when all specified', () => {
 			const yaml = generateDockerCompose({
@@ -548,6 +633,7 @@ describe('generateWorkspaceCompose', () => {
 					path: 'apps/api',
 					port: 3000,
 					dependencies: [],
+					resolvedDeployTarget: 'dokploy',
 				},
 				web: {
 					type: 'frontend',
@@ -555,6 +641,7 @@ describe('generateWorkspaceCompose', () => {
 					port: 3001,
 					dependencies: ['api'],
 					framework: 'nextjs',
+					resolvedDeployTarget: 'dokploy',
 				},
 			},
 			services: {},
@@ -577,7 +664,12 @@ describe('generateWorkspaceCompose', () => {
 			const workspace = createWorkspace();
 			const yaml = generateWorkspaceCompose(workspace);
 
-			expect(yaml).toContain('# Generated by gkm - do not edit manually');
+			expect(yaml).toContain(
+				'# Use "gkm dev" or "gkm test" to start services.',
+			);
+			expect(yaml).toContain(
+				'# Running "docker compose up" directly will not inject secrets or resolve ports.',
+			);
 		});
 
 		it('should include services section', () => {
@@ -680,12 +772,14 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 					auth: {
 						type: 'backend',
 						path: 'apps/auth',
 						port: 3002,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 					web: {
 						type: 'frontend',
@@ -693,6 +787,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: ['api', 'auth'],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -710,6 +805,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -729,6 +825,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -746,6 +843,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: [],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -773,6 +871,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -889,6 +988,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: [],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 				services: { db: true },
@@ -926,6 +1026,55 @@ describe('generateWorkspaceCompose', () => {
 
 			expect(yaml).toContain('image: redis:6-alpine');
 		});
+
+		it('should add minio service when storage is configured', () => {
+			const workspace = createWorkspace({
+				services: { storage: true },
+			});
+			const yaml = generateWorkspaceCompose(workspace);
+
+			expect(yaml).toContain('minio:');
+			expect(yaml).toContain('image: minio/minio:latest');
+			expect(yaml).toContain('container_name: test-workspace-minio');
+		});
+
+		it('should add S3 env vars for backend apps when minio is enabled', () => {
+			const workspace = createWorkspace({
+				services: { storage: true },
+			});
+			const yaml = generateWorkspaceCompose(workspace);
+
+			expect(yaml).toContain('S3_ENDPOINT=${S3_ENDPOINT:-http://minio:9000}');
+			expect(yaml).toContain('S3_FORCE_PATH_STYLE=true');
+		});
+
+		it('should add minio_data volume when minio is enabled', () => {
+			const workspace = createWorkspace({
+				services: { storage: true },
+			});
+			const yaml = generateWorkspaceCompose(workspace);
+
+			expect(yaml).toContain('minio_data:');
+			expect(yaml).toContain('minio_data:/data');
+		});
+
+		it('should add depends_on minio for backend apps', () => {
+			const workspace = createWorkspace({
+				services: { storage: true },
+			});
+			const yaml = generateWorkspaceCompose(workspace);
+
+			expect(yaml).toMatch(/minio:\s+condition: service_healthy/);
+		});
+
+		it('should support custom minio version', () => {
+			const workspace = createWorkspace({
+				services: { storage: { version: 'RELEASE.2024-01-01' } },
+			});
+			const yaml = generateWorkspaceCompose(workspace);
+
+			expect(yaml).toContain('image: minio/minio:RELEASE.2024-01-01');
+		});
 	});
 
 	describe('registry configuration', () => {