@geekmidas/cli 1.10.8 → 1.10.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.8",
+  "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/constructs": "~3.0.2",
-    "@geekmidas/envkit": "~1.0.3",
-    "@geekmidas/errors": "~1.0.0",
     "@geekmidas/logger": "~1.0.0",
-    "@geekmidas/schema": "~1.0.0"
+    "@geekmidas/envkit": "~1.0.3",
+    "@geekmidas/constructs": "~3.0.2",
+    "@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

@@ -22,6 +22,7 @@ import {
 	normalizeStudioConfig,
 	normalizeTelescopeConfig,
 	parseComposePortMappings,
+	parseComposeServiceNames,
 	replacePortInUrl,
 	rewriteUrlsWithPorts,
 	savePortState,
@@ -1707,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({

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(
@@ -1124,10 +1136,28 @@ export function buildDockerComposeEnv(
 	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.
- * Passes both port mappings and secrets to docker-compose so that
- * variables like POSTGRES_USER/POSTGRES_PASSWORD are available.
+ * 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(
@@ -1135,22 +1165,17 @@ export async function startWorkspaceServices(
 	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;
@@ -1159,15 +1184,6 @@ 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, passing secrets so that
 		// POSTGRES_USER, POSTGRES_PASSWORD, etc. are interpolated correctly
 		execSync(`docker compose up -d ${servicesToStart.join(' ')}`, {

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: {},
@@ -685,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',
@@ -698,6 +787,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: ['api', 'auth'],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -715,6 +805,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -734,6 +825,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -751,6 +843,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: [],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -778,6 +871,7 @@ describe('generateWorkspaceCompose', () => {
 						path: 'apps/api',
 						port: 3000,
 						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 			});
@@ -894,6 +988,7 @@ describe('generateWorkspaceCompose', () => {
 						port: 3001,
 						dependencies: [],
 						framework: 'nextjs',
+						resolvedDeployTarget: 'dokploy',
 					},
 				},
 				services: { db: true },
@@ -931,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', () => {

package/src/docker/compose.ts

@@ -13,6 +13,7 @@ export const DEFAULT_SERVICE_IMAGES: Record<ComposeServiceName, string> = {
 	postgres: 'postgres',
 	redis: 'redis',
 	rabbitmq: 'rabbitmq',
+	minio: 'minio/minio',
 };
 
 /** Default Docker image versions for services */
@@ -20,6 +21,7 @@ export const DEFAULT_SERVICE_VERSIONS: Record<ComposeServiceName, string> = {
 	postgres: '18-alpine',
 	redis: '7-alpine',
 	rabbitmq: '3-management-alpine',
+	minio: 'latest',
 };
 
 export interface ComposeOptions {
@@ -121,6 +123,16 @@ services:
 `;
 	}
 
+	if (serviceMap.has('minio')) {
+		yaml += `      - S3_ENDPOINT=\${S3_ENDPOINT:-http://minio:9000}
+      - S3_ACCESS_KEY_ID=\${MINIO_ACCESS_KEY:-app}
+      - S3_SECRET_ACCESS_KEY=\${MINIO_SECRET_KEY:-app}
+      - S3_BUCKET=\${MINIO_BUCKET:-app}
+      - S3_REGION=\${S3_REGION:-eu-west-1}
+      - S3_FORCE_PATH_STYLE=true
+`;
+	}
+
 	yaml += `    healthcheck:
       test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
       interval: 30s
@@ -210,6 +222,32 @@ services:
 `;
 	}
 
+	const minioImage = serviceMap.get('minio');
+	if (minioImage) {
+		yaml += `
+  minio:
+    image: ${minioImage}
+    container_name: minio
+    restart: unless-stopped
+    entrypoint: sh
+    command: -c 'mkdir -p /data/\${MINIO_BUCKET:-app} && /usr/bin/docker-entrypoint.sh server --console-address ":9001" /data'
+    environment:
+      MINIO_ROOT_USER: \${MINIO_ACCESS_KEY:-app}
+      MINIO_ROOT_PASSWORD: \${MINIO_SECRET_KEY:-app}
+    ports:
+      - "9001:9001"  # Console UI
+    volumes:
+      - minio_data:/data
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	}
+
 	// Add volumes
 	yaml += `
 volumes:
@@ -230,6 +268,11 @@ volumes:
 `;
 	}
 
+	if (serviceMap.has('minio')) {
+		yaml += `  minio_data:
+`;
+	}
+
 	// Add networks
 	yaml += `
 networks:
@@ -305,10 +348,12 @@ export function generateWorkspaceCompose(
 	const hasPostgres = services.db !== undefined && services.db !== false;
 	const hasRedis = services.cache !== undefined && services.cache !== false;
 	const hasMail = services.mail !== undefined && services.mail !== false;
+	const hasMinio = services.storage !== undefined && services.storage !== false;
 
 	// Get image versions from config
 	const postgresImage = getInfraServiceImage('postgres', services.db);
 	const redisImage = getInfraServiceImage('redis', services.cache);
+	const minioImage = getInfraServiceImage('minio', services.storage);
 
 	let yaml = `# Docker Compose for ${workspace.name} workspace
 # Use "gkm dev" or "gkm test" to start services.
@@ -323,6 +368,7 @@ services:
 			registry,
 			hasPostgres,
 			hasRedis,
+			hasMinio,
 		});
 	}
 
@@ -381,6 +427,31 @@ services:
 `;
 	}
 
+	if (hasMinio) {
+		yaml += `
+  minio:
+    image: ${minioImage}
+    container_name: ${workspace.name}-minio
+    restart: unless-stopped
+    entrypoint: sh
+    command: -c 'mkdir -p /data/\${MINIO_BUCKET:-app} && /usr/bin/docker-entrypoint.sh server --console-address ":9001" /data'
+    environment:
+      MINIO_ROOT_USER: \${MINIO_ACCESS_KEY:-app}
+      MINIO_ROOT_PASSWORD: \${MINIO_SECRET_KEY:-app}
+    ports:
+      - "9001:9001"  # Console UI
+    volumes:
+      - minio_data:/data
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - workspace-network
+`;
+	}
+
 	// Add volumes section
 	yaml += `
 volumes:
@@ -396,6 +467,11 @@ volumes:
 `;
 	}
 
+	if (hasMinio) {
+		yaml += `  minio_data:
+`;
+	}
+
 	// Add networks section
 	yaml += `
 networks:
@@ -410,12 +486,13 @@ networks:
  * Get infrastructure service image with version.
  */
 function getInfraServiceImage(
-	serviceName: 'postgres' | 'redis',
+	serviceName: 'postgres' | 'redis' | 'minio',
 	config: boolean | { version?: string; image?: string } | undefined,
 ): string {
-	const defaults: Record<'postgres' | 'redis', string> = {
+	const defaults: Record<'postgres' | 'redis' | 'minio', string> = {
 		postgres: 'postgres:18-alpine',
 		redis: 'redis:7-alpine',
+		minio: 'minio/minio:latest',
 	};
 
 	if (!config || config === true) {
@@ -427,8 +504,12 @@ function getInfraServiceImage(
 			return config.image;
 		}
 		if (config.version) {
-			const baseImage = serviceName === 'postgres' ? 'postgres' : 'redis';
-			return `${baseImage}:${config.version}`;
+			const baseImages: Record<'postgres' | 'redis' | 'minio', string> = {
+				postgres: 'postgres',
+				redis: 'redis',
+				minio: 'minio/minio',
+			};
+			return `${baseImages[serviceName]}:${config.version}`;
 		}
 	}
 
@@ -446,9 +527,10 @@ function generateAppService(
 		registry?: string;
 		hasPostgres: boolean;
 		hasRedis: boolean;
+		hasMinio: boolean;
 	},
 ): string {
-	const { registry, hasPostgres, hasRedis } = options;
+	const { registry, hasPostgres, hasRedis, hasMinio } = options;
 	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : '';
 
 	// Health check path - frontends use /, backends use /health
@@ -490,6 +572,15 @@ function generateAppService(
 		}
 		if (hasRedis) {
 			yaml += `      - REDIS_URL=\${REDIS_URL:-redis://redis:6379}
+`;
+		}
+		if (hasMinio) {
+			yaml += `      - S3_ENDPOINT=\${S3_ENDPOINT:-http://minio:9000}
+      - S3_ACCESS_KEY_ID=\${MINIO_ACCESS_KEY:-app}
+      - S3_SECRET_ACCESS_KEY=\${MINIO_SECRET_KEY:-app}
+      - S3_BUCKET=\${MINIO_BUCKET:-app}
+      - S3_REGION=\${S3_REGION:-eu-west-1}
+      - S3_FORCE_PATH_STYLE=true
 `;
 		}
 	}
@@ -506,6 +597,7 @@ function generateAppService(
 	if (app.type === 'backend') {
 		if (hasPostgres) dependencies.push('postgres');
 		if (hasRedis) dependencies.push('redis');
+		if (hasMinio) dependencies.push('minio');
 	}
 
 	if (dependencies.length > 0) {

package/src/init/index.ts

@@ -330,6 +330,7 @@ export async function initCommand(
 	const secretServices: ComposeServiceName[] = [];
 	if (services.db) secretServices.push('postgres');
 	if (services.cache) secretServices.push('redis');
+	if (services.storage) secretServices.push('minio');
 
 	const devSecrets = createStageSecrets('development', secretServices, {
 		projectName: name,

package/src/init/versions.ts

@@ -45,7 +45,7 @@ export const GEEKMIDAS_VERSIONS = {
 	'@geekmidas/storage': '~2.0.0',
 	'@geekmidas/studio': '~1.0.0',
 	'@geekmidas/telescope': '~1.0.0',
-	'@geekmidas/testkit': '~1.0.2',
+	'@geekmidas/testkit': '~1.0.5',
 	'@geekmidas/cli': CLI_VERSION,
 } as const;