@geekmidas/cli 1.10.34 → 1.10.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.34",
+  "version": "1.10.36",
   "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/logger": "~1.0.1",
     "@geekmidas/constructs": "~3.0.9",
+    "@geekmidas/errors": "~1.0.0",
     "@geekmidas/schema": "~1.0.0",
-    "@geekmidas/envkit": "~1.0.5"
+    "@geekmidas/envkit": "~1.0.6",
+    "@geekmidas/logger": "~1.0.1"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/__tests__/openapi.spec.ts

@@ -2,12 +2,6 @@ import { existsSync, realpathSync } from 'node:fs';
 import { mkdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-	generateOpenApi,
-	OPENAPI_OUTPUT_PATH,
-	openapiCommand,
-	resolveOpenApiConfig,
-} from '../openapi';
 import type { GkmConfig } from '../types';
 import {
 	cleanupDir,
@@ -16,6 +10,33 @@ import {
 	createTestFile,
 } from './test-helpers';
 
+const spawnCalls: Array<{ cmd: string; args: string[]; cwd: string }> = [];
+let mockSpawnExitCode = 0;
+
+vi.mock('node:child_process', async (importOriginal) => {
+	const actual = await importOriginal<typeof import('node:child_process')>();
+	return {
+		...actual,
+		spawn: vi.fn((cmd: string, args: string[], opts: any) => {
+			spawnCalls.push({ cmd, args: args ?? [], cwd: opts?.cwd ?? '' });
+			const child: any = {
+				on(event: string, cb: (code?: number) => void) {
+					if (event === 'close') queueMicrotask(() => cb(mockSpawnExitCode));
+					return child;
+				},
+			};
+			return child;
+		}),
+	};
+});
+
+const {
+	generateOpenApi,
+	OPENAPI_OUTPUT_PATH,
+	openapiCommand,
+	resolveOpenApiConfig,
+} = await import('../openapi');
+
 describe('resolveOpenApiConfig', () => {
 	const baseConfig: GkmConfig = {
 		routes: './src/endpoints/**/*.ts',
@@ -483,7 +504,7 @@ describe('openapiCommand - workspace mode', () => {
 		vi.restoreAllMocks();
 	});
 
-	it('should generate OpenAPI for backend app in workspace', async () => {
+	it('should generate OpenAPI for a single app via --app flag', async () => {
 		// Create workspace structure
 		const apiDir = join(tempDir, 'apps/api');
 		await mkdir(apiDir, { recursive: true });
@@ -515,10 +536,11 @@ describe('openapiCommand - workspace mode', () => {
 			}),
 		);
 
-		process.chdir(tempDir);
+		// Subprocess invocation simulated: CWD = appPath, --app passed
+		process.chdir(apiDir);
 		const consoleSpy = vi.spyOn(console, 'log');
 
-		await openapiCommand({ cwd: tempDir });
+		await openapiCommand({ cwd: tempDir, app: 'api' });
 
 		// Should generate OpenAPI in the backend app's .gkm folder
 		const outputPath = join(apiDir, OPENAPI_OUTPUT_PATH);
@@ -532,4 +554,72 @@ describe('openapiCommand - workspace mode', () => {
 			expect.stringContaining('[api] Generated OpenAPI'),
 		);
 	});
+
+	it('should throw when --app references unknown app', async () => {
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+				},
+			}),
+		);
+
+		await expect(
+			openapiCommand({ cwd: tempDir, app: 'missing' }),
+		).rejects.toThrow(/App "missing" not found/);
+	});
+
+	it('should spawn one subprocess per backend app in multi-app mode', async () => {
+		// Create workspace with two backend apps
+		const apiDir = join(tempDir, 'apps/api');
+		const adminDir = join(tempDir, 'apps/admin');
+		await mkdir(apiDir, { recursive: true });
+		await mkdir(adminDir, { recursive: true });
+
+		await createTestFile(
+			tempDir,
+			'gkm.config.json',
+			JSON.stringify({
+				name: 'test-workspace',
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+					admin: {
+						type: 'backend',
+						path: 'apps/admin',
+						port: 3001,
+						routes: './src/endpoints/**/*.ts',
+						openapi: { enabled: true },
+					},
+				},
+			}),
+		);
+
+		spawnCalls.length = 0;
+		mockSpawnExitCode = 0;
+
+		await openapiCommand({ cwd: tempDir });
+
+		expect(spawnCalls).toHaveLength(2);
+		expect(spawnCalls[0]?.cwd).toBe(apiDir);
+		expect(spawnCalls[0]?.args).toContain('--app');
+		expect(spawnCalls[0]?.args).toContain('api');
+		expect(spawnCalls[1]?.cwd).toBe(adminDir);
+		expect(spawnCalls[1]?.args).toContain('--app');
+		expect(spawnCalls[1]?.args).toContain('admin');
+	});
 });

package/src/deploy/__tests__/env-resolver.spec.ts

@@ -517,6 +517,34 @@ describe('resolveEnvVar', () => {
 				expect(resolveEnvVar('NEXT_PUBLIC_AUTH_URL', context)).toBeUndefined();
 			});
 		});
+
+		describe('VITE_ prefix', () => {
+			it('should resolve VITE_API_URL from dependencyUrls.api', () => {
+				const context = createContext({
+					dependencyUrls: { api: 'https://api.example.com' },
+				});
+
+				expect(resolveEnvVar('VITE_API_URL', context)).toBe(
+					'https://api.example.com',
+				);
+			});
+
+			it('should resolve all of AUTH_URL, NEXT_PUBLIC_AUTH_URL, and VITE_AUTH_URL to the same value', () => {
+				const context = createContext({
+					dependencyUrls: { auth: 'https://auth.example.com' },
+				});
+
+				expect(resolveEnvVar('AUTH_URL', context)).toBe(
+					'https://auth.example.com',
+				);
+				expect(resolveEnvVar('NEXT_PUBLIC_AUTH_URL', context)).toBe(
+					'https://auth.example.com',
+				);
+				expect(resolveEnvVar('VITE_AUTH_URL', context)).toBe(
+					'https://auth.example.com',
+				);
+			});
+		});
 	});
 });
 

package/src/deploy/env-resolver.ts

@@ -8,6 +8,7 @@
 
 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,
@@ -208,17 +209,11 @@ export function resolveEnvVar(
 	}
 
 	// Check dependency URLs (e.g., AUTH_URL -> dependencyUrls.auth)
-	// Also supports NEXT_PUBLIC_ prefix for frontend apps (NEXT_PUBLIC_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')) {
-		let depName: string;
-
-		if (varName.startsWith('NEXT_PUBLIC_')) {
-			// NEXT_PUBLIC_AUTH_URL -> auth
-			depName = varName.slice(12, -4).toLowerCase();
-		} else {
-			// AUTH_URL -> auth
-			depName = varName.slice(0, -4).toLowerCase();
-		}
+		const stripped = stripPublicPrefix(varName) ?? varName;
+		const depName = stripped.slice(0, -4).toLowerCase();
 
 		if (context.dependencyUrls[depName]) {
 			return context.dependencyUrls[depName];

package/src/deploy/index.ts

@@ -61,6 +61,7 @@ import { readStageSecrets } from '../secrets/storage.js';
 import {
 	getAppBuildOrder,
 	getDeployTargetError,
+	getPublicEnvPrefix,
 	isDeployTargetSupported,
 } from '../workspace/index.js';
 import type { NormalizedWorkspace } from '../workspace/types.js';
@@ -1661,7 +1662,8 @@ export async function workspaceDeployCommand(
 					dependencyUrls,
 				};
 
-				// Resolve all env vars BEFORE Docker build (NEXT_PUBLIC_* must be present at build time)
+				// Resolve all env vars BEFORE Docker build (public-prefixed vars
+				// must be present at bundler build time so they get inlined).
 				const sniffedVars = sniffedApps.get(appName)?.requiredEnvVars ?? [];
 				const { valid, missing, resolved } = validateEnvVars(
 					sniffedVars,
@@ -1678,14 +1680,18 @@ export async function workspaceDeployCommand(
 					);
 				}
 
-				// Build args: all NEXT_PUBLIC_* vars must be present at Next.js build time
+				// Build args: only the framework's public-prefixed vars get baked
+				// into the bundle. Server-only vars stay as runtime env.
+				const publicPrefix = getPublicEnvPrefix(app.framework);
 				const buildArgs: string[] = [];
 				const publicUrlArgNames: string[] = [];
 
-				for (const [key, value] of Object.entries(resolved)) {
-					if (key.startsWith('NEXT_PUBLIC_')) {
-						buildArgs.push(`${key}=${value}`);
-						publicUrlArgNames.push(key);
+				if (publicPrefix) {
+					for (const [key, value] of Object.entries(resolved)) {
+						if (key.startsWith(publicPrefix)) {
+							buildArgs.push(`${key}=${value}`);
+							publicUrlArgNames.push(key);
+						}
 					}
 				}
 
@@ -1693,7 +1699,7 @@ export async function workspaceDeployCommand(
 					logger.log(`      Build args: ${publicUrlArgNames.join(', ')}`);
 				}
 
-				// Build Docker image with NEXT_PUBLIC_* vars as build args
+				// Build Docker image with public-prefixed vars as build args
 				const imageName = `${workspace.name}-${appName}`;
 				const imageRef = registry
 					? `${registry}/${imageName}:${imageTag}`

package/src/deploy/sniffer.ts

@@ -5,6 +5,7 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import type { SniffResult } from '@geekmidas/envkit/sniffer';
 import { normalizeRoutes } from '../workspace/client-generator.js';
+import { getPublicEnvPrefix } from '../workspace/publicEnv.js';
 import type { NormalizedAppConfig } from '../workspace/types.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -117,10 +118,15 @@ export async function sniffAppEnvironment(
 
 	// 1. Frontend apps - handle dependencies and config sniffing
 	if (app.type === 'frontend') {
-		// Auto-generate NEXT_PUBLIC_{DEP}_URL from dependencies
-		const depVars = (app.dependencies ?? []).map(
-			(dep) => `NEXT_PUBLIC_${dep.toUpperCase()}_URL`,
-		);
+		// Auto-generate {prefix}{DEP}_URL from dependencies, where prefix matches
+		// the framework's public-var convention (NEXT_PUBLIC_, VITE_, ...).
+		// For frameworks without a prefix (e.g. Remix), no dep var is required.
+		const publicPrefix = getPublicEnvPrefix(app.framework);
+		const depVars = publicPrefix
+			? (app.dependencies ?? []).map(
+					(dep) => `${publicPrefix}${dep.toUpperCase()}_URL`,
+				)
+			: [];
 
 		// If config specified, sniff by importing the file(s)
 		// The file calls .parse() at module load, which triggers sniffer to capture vars

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

@@ -892,6 +892,125 @@ describe('Workspace Dev Server', () => {
 
 			expect(result.valid).toBe(true);
 		});
+
+		it('should validate a properly configured Vite app', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			writeFileSync(join(appDir, 'vite.config.ts'), 'export default {}');
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					devDependencies: { vite: '^5.0.0' },
+					scripts: { dev: 'vite' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+			expect(result.errors).toHaveLength(0);
+		});
+
+		it('should validate a properly configured Remix app', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			writeFileSync(join(appDir, 'vite.config.ts'), 'export default {}');
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					devDependencies: {
+						'@remix-run/dev': '^2.0.0',
+						vite: '^5.0.0',
+					},
+					scripts: { dev: 'remix vite:dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+			expect(result.errors).toHaveLength(0);
+		});
+
+		it('should warn but stay valid for a custom frontend with a dev script', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// No recognized config, no recognized dep — but has a dev script
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { react: '^18.0.0' },
+					scripts: { dev: 'node serve.mjs' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+			expect(result.errors).toHaveLength(0);
+			expect(result.warnings).toContainEqual(
+				expect.stringContaining('No recognized frontend framework detected'),
+			);
+		});
+
+		it('should error for a custom frontend without a dev script', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { react: '^18.0.0' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(false);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('No "dev" script found'),
+			);
+		});
+
+		it('should validate strictly against an explicit framework', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Has next.config.js + next dep — auto-detect would say nextjs
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			// Caller explicitly declares Vite — should fail because vite
+			// config and vite dep are missing.
+			const result = await validateFrontendApp(
+				'web',
+				'apps/web',
+				testDir,
+				'vite',
+			);
+
+			expect(result.valid).toBe(false);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('Vite config file not found'),
+			);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('Vite not found in dependencies'),
+			);
+		});
 	});
 
 	describe('validateFrontendApps', () => {

package/src/dev/index.ts

@@ -55,6 +55,7 @@ import type {
 	TelescopeConfig,
 } from '../types';
 import {
+	type FrontendFramework,
 	getAppBuildOrder,
 	getDependencyEnvVars,
 	type NormalizedWorkspace,
@@ -641,13 +642,107 @@ export function checkPortConflicts(
 }
 
 /**
- * Next.js config file patterns to check.
+ * Per-framework validation spec for supported frontend frameworks.
  */
-const NEXTJS_CONFIG_FILES = [
-	'next.config.js',
-	'next.config.ts',
-	'next.config.mjs',
-];
+interface FrontendFrameworkSpec {
+	displayName: string;
+	configFiles: string[];
+	dependency: string;
+	installCommand: string;
+}
+
+const FRONTEND_FRAMEWORKS: Record<FrontendFramework, FrontendFrameworkSpec> = {
+	nextjs: {
+		displayName: 'Next.js',
+		configFiles: [
+			'next.config.js',
+			'next.config.ts',
+			'next.config.mjs',
+			'next.config.cjs',
+		],
+		dependency: 'next',
+		installCommand: 'pnpm add next react react-dom',
+	},
+	remix: {
+		displayName: 'Remix',
+		configFiles: [
+			'remix.config.js',
+			'remix.config.mjs',
+			'remix.config.ts',
+			'vite.config.js',
+			'vite.config.ts',
+			'vite.config.mjs',
+			'vite.config.cjs',
+		],
+		dependency: '@remix-run/dev',
+		installCommand: 'pnpm add -D @remix-run/dev',
+	},
+	vite: {
+		displayName: 'Vite',
+		configFiles: [
+			'vite.config.js',
+			'vite.config.ts',
+			'vite.config.mjs',
+			'vite.config.cjs',
+		],
+		dependency: 'vite',
+		installCommand: 'pnpm add -D vite',
+	},
+	'tanstack-start': {
+		displayName: 'TanStack Start',
+		configFiles: [
+			'vite.config.js',
+			'vite.config.ts',
+			'vite.config.mjs',
+			'vite.config.cjs',
+		],
+		dependency: '@tanstack/react-start',
+		installCommand: 'pnpm add @tanstack/react-start @tanstack/react-router',
+	},
+	expo: {
+		displayName: 'Expo',
+		configFiles: ['app.config.ts', 'app.config.js', 'app.json'],
+		dependency: 'expo',
+		installCommand: 'pnpm add expo',
+	},
+};
+
+/**
+ * Auto-detect the frontend framework by scanning package.json deps and config
+ * files. Dependency match wins over config file match because deps are more
+ * distinctive (a Remix app has both vite.config.ts AND @remix-run/dev).
+ */
+function detectFrontendFramework(
+	fullPath: string,
+	deps: Record<string, string>,
+): FrontendFramework | undefined {
+	// tanstack-start before vite/remix so its more specific dep wins; vite last
+	// because plain vite is the fallback when neither nextjs/remix/tanstack match.
+	// Order matters: more specific deps win over general ones.
+	// expo first (own dep), then tanstack-start (uses vite), remix (uses vite),
+	// nextjs (own dep), and plain vite last as the fallback.
+	const order: FrontendFramework[] = [
+		'expo',
+		'tanstack-start',
+		'nextjs',
+		'remix',
+		'vite',
+	];
+	for (const name of order) {
+		if (deps[FRONTEND_FRAMEWORKS[name].dependency]) {
+			return name;
+		}
+	}
+	for (const name of order) {
+		const hasConfig = FRONTEND_FRAMEWORKS[name].configFiles.some((file) =>
+			existsSync(join(fullPath, file)),
+		);
+		if (hasConfig) {
+			return name;
+		}
+	}
+	return undefined;
+}
 
 /**
  * Validation result for a frontend app.
@@ -660,59 +755,88 @@ export interface FrontendValidationResult {
 }
 
 /**
- * Validate a frontend (Next.js) app configuration.
- * Checks for Next.js config file and dependency.
+ * Validate a frontend app configuration.
+ *
+ * If `framework` is provided, validates strictly against that framework's
+ * expected config file and dependency. Otherwise auto-detects the framework
+ * from package.json and config files. If no recognized framework is found, the
+ * app is allowed through with a warning provided it has a `dev` script.
+ *
  * @internal Exported for testing
  */
 export async function validateFrontendApp(
 	appName: string,
 	appPath: string,
 	workspaceRoot: string,
+	framework?: FrontendFramework,
 ): Promise<FrontendValidationResult> {
 	const errors: string[] = [];
 	const warnings: string[] = [];
 	const fullPath = join(workspaceRoot, appPath);
 
-	// Check for Next.js config file
-	const hasConfigFile = NEXTJS_CONFIG_FILES.some((file) =>
-		existsSync(join(fullPath, file)),
-	);
-
-	if (!hasConfigFile) {
+	const packageJsonPath = join(fullPath, 'package.json');
+	if (!existsSync(packageJsonPath)) {
 		errors.push(
-			`Next.js config file not found. Expected one of: ${NEXTJS_CONFIG_FILES.join(', ')}`,
+			`package.json not found at ${appPath}. Run: pnpm init in the app directory.`,
 		);
+		return { appName, valid: false, errors, warnings };
 	}
 
-	// Check for package.json
-	const packageJsonPath = join(fullPath, 'package.json');
-	if (existsSync(packageJsonPath)) {
-		try {
-			// eslint-disable-next-line @typescript-eslint/no-require-imports
-			const pkg = require(packageJsonPath);
-			const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+	let pkg: {
+		dependencies?: Record<string, string>;
+		devDependencies?: Record<string, string>;
+		scripts?: Record<string, string>;
+	};
+	try {
+		// eslint-disable-next-line @typescript-eslint/no-require-imports
+		pkg = require(packageJsonPath);
+	} catch {
+		errors.push(`Failed to read package.json at ${packageJsonPath}`);
+		return { appName, valid: false, errors, warnings };
+	}
 
-			if (!deps.next) {
-				errors.push(
-					'Next.js not found in dependencies. Run: pnpm add next react react-dom',
-				);
-			}
+	const deps: Record<string, string> = {
+		...pkg.dependencies,
+		...pkg.devDependencies,
+	};
 
-			// Check for dev script
-			if (!pkg.scripts?.dev) {
-				warnings.push(
-					'No "dev" script found in package.json. Turbo expects a "dev" script to run.',
-				);
-			}
-		} catch {
-			errors.push(`Failed to read package.json at ${packageJsonPath}`);
+	const resolvedFramework =
+		framework ?? detectFrontendFramework(fullPath, deps);
+
+	if (resolvedFramework) {
+		const spec = FRONTEND_FRAMEWORKS[resolvedFramework];
+		const hasConfig = spec.configFiles.some((file) =>
+			existsSync(join(fullPath, file)),
+		);
+		if (!hasConfig) {
+			errors.push(
+				`${spec.displayName} config file not found. Expected one of: ${spec.configFiles.join(', ')}`,
+			);
+		}
+		if (!deps[spec.dependency]) {
+			errors.push(
+				`${spec.displayName} not found in dependencies. Run: ${spec.installCommand}`,
+			);
 		}
 	} else {
-		errors.push(
-			`package.json not found at ${appPath}. Run: pnpm init in the app directory.`,
+		warnings.push(
+			'No recognized frontend framework detected (Next.js, Vite, Remix). ' +
+				'The app will run via its "dev" script. Set `framework` in your app config to enable strict validation.',
 		);
 	}
 
+	if (!pkg.scripts?.dev) {
+		if (resolvedFramework) {
+			warnings.push(
+				'No "dev" script found in package.json. Turbo expects a "dev" script to run.',
+			);
+		} else {
+			errors.push(
+				'No "dev" script found in package.json. Without a recognized framework or a dev script, there is nothing to run.',
+			);
+		}
+	}
+
 	return {
 		appName,
 		valid: errors.length === 0,
@@ -737,6 +861,7 @@ export async function validateFrontendApps(
 				appName,
 				app.path,
 				workspace.root,
+				app.framework as FrontendFramework | undefined,
 			);
 			results.push(result);
 		}