@geekmidas/cli 1.10.35 → 1.10.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.35",
+  "version": "1.10.36",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -57,10 +57,10 @@
     "tsx": "~4.20.3",
     "yaml": "~2.8.2",
     "@geekmidas/constructs": "~3.0.9",
-    "@geekmidas/envkit": "~1.0.5",
     "@geekmidas/errors": "~1.0.0",
-    "@geekmidas/logger": "~1.0.1",
-    "@geekmidas/schema": "~1.0.0"
+    "@geekmidas/schema": "~1.0.0",
+    "@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/index.ts

@@ -688,6 +688,23 @@ const FRONTEND_FRAMEWORKS: Record<FrontendFramework, FrontendFrameworkSpec> = {
 		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',
+	},
 };
 
 /**
@@ -699,7 +716,18 @@ function detectFrontendFramework(
 	fullPath: string,
 	deps: Record<string, string>,
 ): FrontendFramework | undefined {
-	const order: FrontendFramework[] = ['nextjs', 'remix', 'vite'];
+	// 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;

package/src/index.ts

@@ -286,13 +286,17 @@ program
 program
 	.command('openapi')
 	.description('Generate OpenAPI specification from endpoints')
-	.action(async () => {
+	.option(
+		'--app <name>',
+		'Workspace mode: generate for a single named backend app',
+	)
+	.action(async (options: { app?: string }) => {
 		try {
 			const globalOptions = program.opts();
 			if (globalOptions.cwd) {
 				process.chdir(globalOptions.cwd);
 			}
-			await openapiCommand({});
+			await openapiCommand({ app: options.app });
 		} catch (error) {
 			console.error(formatError(error));
 			process.exit(1);

package/src/init/__tests__/generators.spec.ts

@@ -2,11 +2,13 @@ import { describe, expect, it } from 'vitest';
 import { generateConfigFiles } from '../generators/config.js';
 import { generateDockerFiles } from '../generators/docker.js';
 import { generateEnvFiles } from '../generators/env.js';
+import { generateExpoAppFiles } from '../generators/mobile-expo.js';
 import { generateModelsPackage } from '../generators/models.js';
 import { generateMonorepoFiles } from '../generators/monorepo.js';
 import { generatePackageJson } from '../generators/package.js';
 import { generateTestFiles } from '../generators/test.js';
 import { generateUiPackageFiles } from '../generators/ui.js';
+import { generateTanStackWebFiles } from '../generators/web-tanstack.js';
 import { apiTemplate } from '../templates/api.js';
 import type { TemplateOptions } from '../templates/index.js';
 import { minimalTemplate } from '../templates/minimal.js';
@@ -431,6 +433,151 @@ describe('generateMonorepoFiles', () => {
 	});
 });
 
+describe('generateTanStackWebFiles', () => {
+	const fullstackOptions: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+		frontendFramework: 'tanstack-start',
+	};
+
+	it('returns empty array for non-fullstack template', () => {
+		expect(generateTanStackWebFiles(baseOptions)).toHaveLength(0);
+	});
+
+	it('generates the expected file paths', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('apps/web/package.json');
+		expect(paths).toContain('apps/web/vite.config.ts');
+		expect(paths).toContain('apps/web/src/router.tsx');
+		expect(paths).toContain('apps/web/src/routes/__root.tsx');
+		expect(paths).toContain('apps/web/src/routes/index.tsx');
+		expect(paths).toContain('apps/web/src/config/client.ts');
+	});
+
+	it('uses VITE_ prefix in client config, not NEXT_PUBLIC_', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const clientConfig = files.find(
+			(f) => f.path === 'apps/web/src/config/client.ts',
+		);
+		expect(clientConfig).toBeDefined();
+		expect(clientConfig!.content).toContain('VITE_API_URL');
+		expect(clientConfig!.content).toContain('VITE_AUTH_URL');
+		expect(clientConfig!.content).not.toContain('NEXT_PUBLIC_');
+	});
+
+	it('declares tanstack and vite as dependencies', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const pkg = JSON.parse(
+			files.find((f) => f.path === 'apps/web/package.json')!.content,
+		);
+		expect(pkg.dependencies['@tanstack/react-start']).toBeDefined();
+		expect(pkg.dependencies['@tanstack/react-router']).toBeDefined();
+		expect(pkg.devDependencies.vite).toBeDefined();
+		expect(pkg.dependencies.next).toBeUndefined();
+	});
+});
+
+describe('generateExpoAppFiles', () => {
+	const fullstackOptions: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+		frontendFramework: 'expo',
+	};
+
+	it('returns empty array for non-fullstack template', () => {
+		expect(generateExpoAppFiles(baseOptions)).toHaveLength(0);
+	});
+
+	it('generates the expected Expo file paths', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('apps/app/package.json');
+		expect(paths).toContain('apps/app/app.config.ts');
+		expect(paths).toContain('apps/app/eas.json');
+		expect(paths).toContain('apps/app/babel.config.js');
+		expect(paths).toContain('apps/app/metro.config.js');
+		expect(paths).toContain('apps/app/app/_layout.tsx');
+		expect(paths).toContain('apps/app/app/index.tsx');
+		expect(paths).toContain('apps/app/app/login.tsx');
+		expect(paths).toContain('apps/app/lib/auth-client.ts');
+	});
+
+	it('uses EXPO_PUBLIC_ prefix in config.ts', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const configTs = files.find((f) => f.path === 'apps/app/config.ts');
+		expect(configTs).toBeDefined();
+		expect(configTs!.content).toContain('EXPO_PUBLIC_API_URL');
+		expect(configTs!.content).toContain('EXPO_PUBLIC_AUTH_URL');
+		expect(configTs!.content).not.toContain('VITE_');
+		expect(configTs!.content).not.toContain('NEXT_PUBLIC_');
+	});
+
+	it('seeds eas.json with EXPO_PUBLIC_ env vars per profile', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const eas = JSON.parse(
+			files.find((f) => f.path === 'apps/app/eas.json')!.content,
+		);
+		expect(eas.build.dev.env.EXPO_PUBLIC_API_URL).toBeDefined();
+		expect(eas.build.dev.env.EXPO_PUBLIC_AUTH_URL).toBeDefined();
+	});
+
+	it('declares expo + better-auth/expo as dependencies', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const pkg = JSON.parse(
+			files.find((f) => f.path === 'apps/app/package.json')!.content,
+		);
+		expect(pkg.dependencies.expo).toBeDefined();
+		expect(pkg.dependencies['@better-auth/expo']).toBeDefined();
+		expect(pkg.dependencies['expo-router']).toBeDefined();
+		expect(pkg.dependencies.next).toBeUndefined();
+	});
+});
+
+describe('generateMonorepoFiles - frontendFramework wiring', () => {
+	const fullstackBase: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+	};
+
+	it('emits framework: nextjs by default', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'nextjs' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'nextjs'");
+		expect(cfg!.content).toContain("path: 'apps/web'");
+	});
+
+	it('emits framework: tanstack-start when selected', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'tanstack-start' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'tanstack-start'");
+		expect(cfg!.content).toContain("path: 'apps/web'");
+	});
+
+	it('emits framework: expo and apps/app path when selected', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'expo' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'expo'");
+		expect(cfg!.content).toContain("path: 'apps/app'");
+		expect(cfg!.content).toContain('port: 8081');
+	});
+});
+
 describe('generateModelsPackage', () => {
 	it('should return empty array for non-monorepo', () => {
 		const files = generateModelsPackage(baseOptions);