@geekmidas/cli 0.12.0 → 0.14.0

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

@@ -1,12 +1,17 @@
 import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { GkmConfig } from '../../types';
 import {
 	detectPackageManager,
+	findLockfilePath,
 	generateDockerEntrypoint,
 	generateDockerignore,
 	generateMultiStageDockerfile,
 	generateSlimDockerfile,
+	getLockfileName,
+	hasTurboConfig,
+	isMonorepo,
 	resolveDockerConfig,
 } from '../templates';
 
@@ -277,4 +282,143 @@ describe('docker templates', () => {
 			expect(result.port).toBe(3000); // default
 		});
 	});
+
+	describe('findLockfilePath', () => {
+		it('should find pnpm-lock.yaml in current directory', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'pnpm-lock.yaml');
+			});
+
+			expect(findLockfilePath('/test/project')).toBe(
+				join('/test/project', 'pnpm-lock.yaml'),
+			);
+		});
+
+		it('should find lockfile in parent directory (monorepo)', () => {
+			mockExistsSync.mockImplementation((path) => {
+				// Lockfile only exists at monorepo root
+				return path === join('/test', 'pnpm-lock.yaml');
+			});
+
+			expect(findLockfilePath('/test/project/apps/api')).toBe(
+				join('/test', 'pnpm-lock.yaml'),
+			);
+		});
+
+		it('should find yarn.lock when present', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'yarn.lock');
+			});
+
+			expect(findLockfilePath('/test/project')).toBe(
+				join('/test/project', 'yarn.lock'),
+			);
+		});
+
+		it('should find package-lock.json when present', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'package-lock.json');
+			});
+
+			expect(findLockfilePath('/test/project')).toBe(
+				join('/test/project', 'package-lock.json'),
+			);
+		});
+
+		it('should find bun.lockb when present', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'bun.lockb');
+			});
+
+			expect(findLockfilePath('/test/project')).toBe(
+				join('/test/project', 'bun.lockb'),
+			);
+		});
+
+		it('should return null when no lockfile found', () => {
+			mockExistsSync.mockReturnValue(false);
+
+			expect(findLockfilePath('/test/project')).toBeNull();
+		});
+
+		it('should prioritize lockfiles in order: pnpm, bun, yarn, npm', () => {
+			// If multiple lockfiles exist, pnpm should be found first
+			mockExistsSync.mockImplementation((path) => {
+				const pathStr = String(path);
+				return (
+					pathStr.endsWith('pnpm-lock.yaml') ||
+					pathStr.endsWith('package-lock.json')
+				);
+			});
+
+			const result = findLockfilePath('/test/project');
+			expect(result).toContain('pnpm-lock.yaml');
+		});
+	});
+
+	describe('getLockfileName', () => {
+		it('should return pnpm-lock.yaml for pnpm', () => {
+			expect(getLockfileName('pnpm')).toBe('pnpm-lock.yaml');
+		});
+
+		it('should return package-lock.json for npm', () => {
+			expect(getLockfileName('npm')).toBe('package-lock.json');
+		});
+
+		it('should return yarn.lock for yarn', () => {
+			expect(getLockfileName('yarn')).toBe('yarn.lock');
+		});
+
+		it('should return bun.lockb for bun', () => {
+			expect(getLockfileName('bun')).toBe('bun.lockb');
+		});
+	});
+
+	describe('isMonorepo', () => {
+		it('should return false when lockfile is in current directory', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'pnpm-lock.yaml');
+			});
+
+			expect(isMonorepo('/test/project')).toBe(false);
+		});
+
+		it('should return true when lockfile is in parent directory', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test', 'pnpm-lock.yaml');
+			});
+
+			expect(isMonorepo('/test/project/apps/api')).toBe(true);
+		});
+
+		it('should return false when no lockfile found', () => {
+			mockExistsSync.mockReturnValue(false);
+
+			expect(isMonorepo('/test/project')).toBe(false);
+		});
+	});
+
+	describe('hasTurboConfig', () => {
+		it('should return true when turbo.json exists in current directory', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test/project', 'turbo.json');
+			});
+
+			expect(hasTurboConfig('/test/project')).toBe(true);
+		});
+
+		it('should return true when turbo.json exists in parent directory', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return path === join('/test', 'turbo.json');
+			});
+
+			expect(hasTurboConfig('/test/project/apps/api')).toBe(true);
+		});
+
+		it('should return false when turbo.json not found', () => {
+			mockExistsSync.mockReturnValue(false);
+
+			expect(hasTurboConfig('/test/project')).toBe(false);
+		});
+	});
 });

package/src/docker/index.ts

@@ -1,18 +1,28 @@
 import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { copyFileSync, existsSync, unlinkSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import { loadConfig } from '../config';
 import { generateDockerCompose, generateMinimalDockerCompose } from './compose';
 import {
 	detectPackageManager,
+	findLockfilePath,
 	generateDockerEntrypoint,
 	generateDockerignore,
 	generateMultiStageDockerfile,
 	generateSlimDockerfile,
+	hasTurboConfig,
+	isMonorepo,
 	resolveDockerConfig,
 } from './templates';
 
+export {
+	detectPackageManager,
+	findLockfilePath,
+	hasTurboConfig,
+	isMonorepo,
+} from './templates';
+
 const logger = console;
 
 export interface DockerOptions {
@@ -82,6 +92,42 @@ export async function dockerCommand(
 
 	// Detect package manager from lockfiles
 	const packageManager = detectPackageManager();
+	const inMonorepo = isMonorepo();
+	const hasTurbo = hasTurboConfig();
+
+	// Auto-enable turbo for monorepos with turbo.json
+	let useTurbo = options.turbo ?? false;
+	if (inMonorepo && !useSlim) {
+		if (hasTurbo) {
+			useTurbo = true;
+			logger.log('   Detected monorepo with turbo.json - using turbo prune');
+		} else {
+			throw new Error(
+				'Monorepo detected but turbo.json not found.\n\n' +
+					'Docker builds in monorepos require Turborepo for proper dependency isolation.\n\n' +
+					'To fix this:\n' +
+					'  1. Install turbo: pnpm add -Dw turbo\n' +
+					'  2. Create turbo.json in your monorepo root\n' +
+					'  3. Run this command again\n\n' +
+					'See: https://turbo.build/repo/docs/guides/tools/docker',
+			);
+		}
+	}
+
+	// Get the actual package name from package.json for turbo prune
+	let turboPackage = options.turboPackage ?? dockerConfig.imageName;
+	if (useTurbo && !options.turboPackage) {
+		try {
+			// eslint-disable-next-line @typescript-eslint/no-require-imports
+			const pkg = require(`${process.cwd()}/package.json`);
+			if (pkg.name) {
+				turboPackage = pkg.name;
+				logger.log(`   Turbo package: ${turboPackage}`);
+			}
+		} catch {
+			// Fall back to imageName
+		}
+	}
 
 	const templateOptions = {
 		imageName: dockerConfig.imageName,
@@ -89,8 +135,8 @@ export async function dockerCommand(
 		port: dockerConfig.port,
 		healthCheckPath,
 		prebuilt: useSlim,
-		turbo: options.turbo,
-		turboPackage: options.turboPackage ?? dockerConfig.imageName,
+		turbo: useTurbo,
+		turboPackage,
 		packageManager,
 	};
 
@@ -99,7 +145,7 @@ export async function dockerCommand(
 		? generateSlimDockerfile(templateOptions)
 		: generateMultiStageDockerfile(templateOptions);
 
-	const dockerMode = useSlim ? 'slim' : options.turbo ? 'turbo' : 'multi-stage';
+	const dockerMode = useSlim ? 'slim' : useTurbo ? 'turbo' : 'multi-stage';
 
 	const dockerfilePath = join(dockerDir, 'Dockerfile');
 	await writeFile(dockerfilePath, dockerfile);
@@ -161,6 +207,42 @@ export async function dockerCommand(
 	return result;
 }
 
+/**
+ * Ensure lockfile exists in the build context
+ * For monorepos, copies from workspace root if needed
+ * Returns cleanup function if file was copied
+ */
+function ensureLockfile(cwd: string): (() => void) | null {
+	const lockfilePath = findLockfilePath(cwd);
+
+	if (!lockfilePath) {
+		logger.warn(
+			'\n⚠️  No lockfile found. Docker build may fail or use stale dependencies.',
+		);
+		return null;
+	}
+
+	const lockfileName = basename(lockfilePath);
+	const localLockfile = join(cwd, lockfileName);
+
+	// If lockfile exists locally (same directory), nothing to do
+	if (lockfilePath === localLockfile) {
+		return null;
+	}
+
+	logger.log(`   Copying ${lockfileName} from monorepo root...`);
+	copyFileSync(lockfilePath, localLockfile);
+
+	// Return cleanup function
+	return () => {
+		try {
+			unlinkSync(localLockfile);
+		} catch {
+			// Ignore cleanup errors
+		}
+	};
+}
+
 /**
  * Build Docker image
  * Uses BuildKit for cache mount support
@@ -178,12 +260,17 @@ async function buildDockerImage(
 
 	logger.log(`\n🐳 Building Docker image: ${fullImageName}`);
 
+	const cwd = process.cwd();
+
+	// Ensure lockfile exists (copy from monorepo root if needed)
+	const cleanup = ensureLockfile(cwd);
+
 	try {
 		// Use BuildKit for cache mount support (required for --mount=type=cache)
 		execSync(
 			`DOCKER_BUILDKIT=1 docker build -f .gkm/docker/Dockerfile -t ${fullImageName} .`,
 			{
-				cwd: process.cwd(),
+				cwd,
 				stdio: 'inherit',
 				env: { ...process.env, DOCKER_BUILDKIT: '1' },
 			},
@@ -193,6 +280,9 @@ async function buildDockerImage(
 		throw new Error(
 			`Failed to build Docker image: ${error instanceof Error ? error.message : 'Unknown error'}`,
 		);
+	} finally {
+		// Clean up copied lockfile
+		cleanup?.();
 	}
 }
 

package/src/docker/templates.ts

@@ -22,6 +22,13 @@ export interface MultiStageDockerfileOptions extends DockerTemplateOptions {
 	turboPackage?: string;
 }
 
+const LOCKFILES: [string, PackageManager][] = [
+	['pnpm-lock.yaml', 'pnpm'],
+	['bun.lockb', 'bun'],
+	['yarn.lock', 'yarn'],
+	['package-lock.json', 'npm'],
+];
+
 /**
  * Detect package manager from lockfiles
  * Walks up the directory tree to find lockfile (for monorepos)
@@ -29,19 +36,12 @@ export interface MultiStageDockerfileOptions extends DockerTemplateOptions {
 export function detectPackageManager(
 	cwd: string = process.cwd(),
 ): PackageManager {
-	const lockfiles: [string, PackageManager][] = [
-		['pnpm-lock.yaml', 'pnpm'],
-		['bun.lockb', 'bun'],
-		['yarn.lock', 'yarn'],
-		['package-lock.json', 'npm'],
-	];
-
 	let dir = cwd;
 	const root = parse(dir).root;
 
 	// Walk up the directory tree
 	while (dir !== root) {
-		for (const [lockfile, pm] of lockfiles) {
+		for (const [lockfile, pm] of LOCKFILES) {
 			if (existsSync(join(dir, lockfile))) {
 				return pm;
 			}
@@ -50,7 +50,7 @@ export function detectPackageManager(
 	}
 
 	// Check root directory
-	for (const [lockfile, pm] of lockfiles) {
+	for (const [lockfile, pm] of LOCKFILES) {
 		if (existsSync(join(root, lockfile))) {
 			return pm;
 		}
@@ -59,6 +59,94 @@ export function detectPackageManager(
 	return 'pnpm'; // default
 }
 
+/**
+ * Find the lockfile path by walking up the directory tree
+ * Returns the full path to the lockfile, or null if not found
+ */
+export function findLockfilePath(cwd: string = process.cwd()): string | null {
+	let dir = cwd;
+	const root = parse(dir).root;
+
+	// Walk up the directory tree
+	while (dir !== root) {
+		for (const [lockfile] of LOCKFILES) {
+			const lockfilePath = join(dir, lockfile);
+			if (existsSync(lockfilePath)) {
+				return lockfilePath;
+			}
+		}
+		dir = dirname(dir);
+	}
+
+	// Check root directory
+	for (const [lockfile] of LOCKFILES) {
+		const lockfilePath = join(root, lockfile);
+		if (existsSync(lockfilePath)) {
+			return lockfilePath;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Get the lockfile name for a package manager
+ */
+export function getLockfileName(pm: PackageManager): string {
+	const lockfileMap: Record<PackageManager, string> = {
+		pnpm: 'pnpm-lock.yaml',
+		npm: 'package-lock.json',
+		yarn: 'yarn.lock',
+		bun: 'bun.lockb',
+	};
+	return lockfileMap[pm];
+}
+
+/**
+ * Check if we're in a monorepo (lockfile is in a parent directory)
+ */
+export function isMonorepo(cwd: string = process.cwd()): boolean {
+	const lockfilePath = findLockfilePath(cwd);
+	if (!lockfilePath) {
+		return false;
+	}
+
+	// Check if lockfile is in a parent directory (not in cwd)
+	const lockfileDir = dirname(lockfilePath);
+	return lockfileDir !== cwd;
+}
+
+/**
+ * Check if turbo.json exists (walks up directory tree)
+ */
+export function hasTurboConfig(cwd: string = process.cwd()): boolean {
+	let dir = cwd;
+	const root = parse(dir).root;
+
+	while (dir !== root) {
+		if (existsSync(join(dir, 'turbo.json'))) {
+			return true;
+		}
+		dir = dirname(dir);
+	}
+
+	return existsSync(join(root, 'turbo.json'));
+}
+
+/**
+ * Get install command for turbo builds (without frozen lockfile)
+ * Turbo prune creates a subset that may not perfectly match the lockfile
+ */
+function getTurboInstallCmd(pm: PackageManager): string {
+	const commands: Record<PackageManager, string> = {
+		pnpm: 'pnpm install',
+		npm: 'npm install',
+		yarn: 'yarn install',
+		bun: 'bun install',
+	};
+	return commands[pm];
+}
+
 /**
  * Get package manager specific commands and paths
  */
@@ -72,6 +160,7 @@ function getPmConfig(pm: PackageManager) {
 			cacheTarget: '/root/.local/share/pnpm/store',
 			cacheId: 'pnpm',
 			run: 'pnpm',
+			dlx: 'pnpm dlx',
 			addGlobal: 'pnpm add -g',
 		},
 		npm: {
@@ -82,6 +171,7 @@ function getPmConfig(pm: PackageManager) {
 			cacheTarget: '/root/.npm',
 			cacheId: 'npm',
 			run: 'npm run',
+			dlx: 'npx',
 			addGlobal: 'npm install -g',
 		},
 		yarn: {
@@ -92,6 +182,7 @@ function getPmConfig(pm: PackageManager) {
 			cacheTarget: '/root/.yarn/cache',
 			cacheId: 'yarn',
 			run: 'yarn',
+			dlx: 'yarn dlx',
 			addGlobal: 'yarn global add',
 		},
 		bun: {
@@ -102,6 +193,7 @@ function getPmConfig(pm: PackageManager) {
 			cacheTarget: '/root/.bun/install/cache',
 			cacheId: 'bun',
 			run: 'bun run',
+			dlx: 'bunx',
 			addGlobal: 'bun add -g',
 		},
 	};
@@ -178,8 +270,8 @@ WORKDIR /app
 # Copy source (deps already installed)
 COPY . .
 
-# Build production server
-RUN ${pm.run} gkm build --provider server --production
+# Build production server using CLI from npm
+RUN ${pm.dlx} @geekmidas/cli build --provider server --production
 
 # Stage 3: Production
 FROM ${baseImage} AS runner
@@ -225,19 +317,13 @@ function generateTurboDockerfile(options: MultiStageDockerfileOptions): string {
 
 	const pm = getPmConfig(packageManager);
 	const installPm = pm.install ? `RUN ${pm.install}` : '';
-	const hasFetch = packageManager === 'pnpm';
 
-	// pnpm has fetch which allows better caching
-	const depsInstall = hasFetch
-		? `# Fetch and install from cache
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.fetch}
+	// For turbo builds, we can't use --frozen-lockfile because turbo prune
+	// creates a subset that may not perfectly match. Use relaxed install.
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
 
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}`
-		: `# Install dependencies with cache
-RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
-    ${pm.installCmd}`;
+	// Use pnpm dlx for pnpm (avoids global bin dir issues in Docker)
+	const turboCmd = packageManager === 'pnpm' ? 'pnpm dlx turbo' : 'npx turbo';
 
 	return `# syntax=docker/dockerfile:1
 # Stage 1: Prune monorepo
@@ -246,12 +332,11 @@ FROM ${baseImage} AS pruner
 WORKDIR /app
 
 ${installPm}
-RUN ${pm.addGlobal} turbo
 
 COPY . .
 
 # Prune to only include necessary packages
-RUN turbo prune ${turboPackage} --docker
+RUN ${turboCmd} prune ${turboPackage} --docker
 
 # Stage 2: Install dependencies
 FROM ${baseImage} AS deps
@@ -264,7 +349,9 @@ ${installPm}
 COPY --from=pruner /app/out/${pm.lockfile} ./
 COPY --from=pruner /app/out/json/ ./
 
-${depsInstall}
+# Install dependencies (no frozen-lockfile since turbo prune creates a subset)
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
 
 # Stage 3: Build
 FROM deps AS builder
@@ -274,8 +361,8 @@ WORKDIR /app
 # Copy pruned source
 COPY --from=pruner /app/out/full/ ./
 
-# Build production server
-RUN ${pm.run} gkm build --provider server --production
+# Build production server using CLI from npm
+RUN ${pm.dlx} @geekmidas/cli build --provider server --production
 
 # Stage 4: Production
 FROM ${baseImage} AS runner

package/src/generators/EndpointGenerator.ts

@@ -925,11 +925,11 @@ import { createApp } from './app.js';
 
 const port = Number(process.env.PORT) || 3000;
 
-const { app, start } = await createApp();
+const { start } = await createApp();
 
 await start({
   port,
-  serve: (app, port) => serve({ fetch: app.fetch, port }),
+  serve: (app, port) => { serve({ fetch: app.fetch, port }); },
 });
 `;