@geekmidas/cli 0.36.0 → 0.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -48,11 +48,11 @@
     "lodash.kebabcase": "^4.1.1",
     "openapi-typescript": "^7.4.2",
     "prompts": "~2.4.2",
+    "@geekmidas/schema": "~0.1.0",
     "@geekmidas/constructs": "~0.6.0",
     "@geekmidas/envkit": "~0.5.0",
     "@geekmidas/errors": "~0.1.0",
-    "@geekmidas/logger": "~0.4.0",
-    "@geekmidas/schema": "~0.1.0"
+    "@geekmidas/logger": "~0.4.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/dev/__tests__/entry-integration.spec.ts

@@ -0,0 +1,346 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { prepareEntryCredentials } from '../index';
+
+describe('prepareEntryCredentials', () => {
+	let workspaceDir: string;
+
+	beforeEach(async () => {
+		workspaceDir = join(tmpdir(), `gkm-entry-test-${Date.now()}`);
+		await mkdir(workspaceDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(workspaceDir, { recursive: true, force: true });
+	});
+
+	describe('workspace with port config', () => {
+		beforeEach(async () => {
+			// Create workspace structure:
+			// workspace/
+			//   gkm.config.ts
+			//   apps/
+			//     api/
+			//       package.json
+			//     auth/
+			//       package.json
+
+			// Create gkm.config.ts
+			const gkmConfig = `
+import { defineWorkspace } from '@geekmidas/cli/config';
+
+export default defineWorkspace({
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+    auth: {
+      type: 'backend',
+      path: 'apps/auth',
+      port: 3002,
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+  },
+  services: {},
+});
+`;
+			await writeFile(join(workspaceDir, 'gkm.config.ts'), gkmConfig);
+
+			// Create apps directories
+			await mkdir(join(workspaceDir, 'apps', 'api', 'src'), {
+				recursive: true,
+			});
+			await mkdir(join(workspaceDir, 'apps', 'auth', 'src'), {
+				recursive: true,
+			});
+
+			// Create package.json for api app
+			await writeFile(
+				join(workspaceDir, 'apps', 'api', 'package.json'),
+				JSON.stringify({ name: '@test/api', version: '0.0.1' }, null, 2),
+			);
+
+			// Create package.json for auth app
+			await writeFile(
+				join(workspaceDir, 'apps', 'auth', 'package.json'),
+				JSON.stringify({ name: '@test/auth', version: '0.0.1' }, null, 2),
+			);
+
+			// Create entry files
+			await writeFile(
+				join(workspaceDir, 'apps', 'api', 'src', 'index.ts'),
+				'console.log("api");',
+			);
+			await writeFile(
+				join(workspaceDir, 'apps', 'auth', 'src', 'index.ts'),
+				'console.log("auth");',
+			);
+		});
+
+		it('should inject PORT from workspace config for api app (port 3000)', async () => {
+			const apiDir = join(workspaceDir, 'apps', 'api');
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.resolvedPort).toBe(3000);
+			expect(result.credentials.PORT).toBe('3000');
+			expect(result.appName).toBe('api');
+			expect(result.secretsRoot).toBe(workspaceDir);
+		});
+
+		it('should inject PORT from workspace config for auth app (port 3002)', async () => {
+			const authDir = join(workspaceDir, 'apps', 'auth');
+
+			const result = await prepareEntryCredentials({ cwd: authDir });
+
+			expect(result.resolvedPort).toBe(3002);
+			expect(result.credentials.PORT).toBe('3002');
+			expect(result.appName).toBe('auth');
+			expect(result.secretsRoot).toBe(workspaceDir);
+		});
+
+		it('should use explicit --port over workspace config', async () => {
+			const authDir = join(workspaceDir, 'apps', 'auth');
+
+			const result = await prepareEntryCredentials({
+				cwd: authDir,
+				explicitPort: 4000,
+			});
+
+			expect(result.resolvedPort).toBe(4000);
+			expect(result.credentials.PORT).toBe('4000');
+			expect(result.appName).toBe('auth');
+		});
+
+		it('should write credentials to dev-secrets.json at workspace root', async () => {
+			const apiDir = join(workspaceDir, 'apps', 'api');
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			// Verify the file was written at workspace root
+			expect(result.secretsJsonPath).toBe(
+				join(workspaceDir, '.gkm', 'dev-secrets.json'),
+			);
+
+			// Verify file contents
+			const content = await readFile(result.secretsJsonPath, 'utf-8');
+			const parsed = JSON.parse(content);
+
+			expect(parsed.PORT).toBe('3000');
+		});
+	});
+
+	describe('without workspace config', () => {
+		beforeEach(async () => {
+			// Create a simple directory without workspace config
+			await mkdir(join(workspaceDir, 'src'), { recursive: true });
+			await writeFile(
+				join(workspaceDir, 'package.json'),
+				JSON.stringify({ name: 'standalone-app', version: '0.0.1' }, null, 2),
+			);
+			await writeFile(
+				join(workspaceDir, 'src', 'index.ts'),
+				'console.log("standalone");',
+			);
+		});
+
+		it('should fallback to port 3000 when no workspace config exists', async () => {
+			const result = await prepareEntryCredentials({ cwd: workspaceDir });
+
+			expect(result.resolvedPort).toBe(3000);
+			expect(result.credentials.PORT).toBe('3000');
+		});
+
+		it('should use explicit --port when no workspace config exists', async () => {
+			const result = await prepareEntryCredentials({
+				cwd: workspaceDir,
+				explicitPort: 5000,
+			});
+
+			expect(result.resolvedPort).toBe(5000);
+			expect(result.credentials.PORT).toBe('5000');
+		});
+
+		it('should write credentials to current directory when not in workspace', async () => {
+			const result = await prepareEntryCredentials({ cwd: workspaceDir });
+
+			expect(result.secretsJsonPath).toBe(
+				join(workspaceDir, '.gkm', 'dev-secrets.json'),
+			);
+		});
+	});
+
+	describe('with GKM_CONFIG_PATH set (turbo environment)', () => {
+		const originalEnv = process.env.GKM_CONFIG_PATH;
+
+		beforeEach(async () => {
+			// Create workspace structure
+			const gkmConfig = `
+import { defineWorkspace } from '@geekmidas/cli/config';
+
+export default defineWorkspace({
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+    auth: {
+      type: 'backend',
+      path: 'apps/auth',
+      port: 3002,
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+  },
+  services: {},
+});
+`;
+			await writeFile(join(workspaceDir, 'gkm.config.ts'), gkmConfig);
+
+			// Create apps directories
+			await mkdir(join(workspaceDir, 'apps', 'api', 'src'), {
+				recursive: true,
+			});
+			await mkdir(join(workspaceDir, 'apps', 'auth', 'src'), {
+				recursive: true,
+			});
+
+			// Create package.json files
+			await writeFile(
+				join(workspaceDir, 'apps', 'api', 'package.json'),
+				JSON.stringify({ name: '@test/api', version: '0.0.1' }, null, 2),
+			);
+			await writeFile(
+				join(workspaceDir, 'apps', 'auth', 'package.json'),
+				JSON.stringify({ name: '@test/auth', version: '0.0.1' }, null, 2),
+			);
+
+			// Set GKM_CONFIG_PATH like turbo does
+			process.env.GKM_CONFIG_PATH = join(workspaceDir, 'gkm.config.ts');
+		});
+
+		afterEach(() => {
+			// Restore original env
+			if (originalEnv === undefined) {
+				delete process.env.GKM_CONFIG_PATH;
+			} else {
+				process.env.GKM_CONFIG_PATH = originalEnv;
+			}
+		});
+
+		it('should read port from workspace config when GKM_CONFIG_PATH is set', async () => {
+			const authDir = join(workspaceDir, 'apps', 'auth');
+
+			const result = await prepareEntryCredentials({ cwd: authDir });
+
+			expect(result.resolvedPort).toBe(3002);
+			expect(result.credentials.PORT).toBe('3002');
+			expect(result.appName).toBe('auth');
+		});
+
+		it('should read port 3000 for api when GKM_CONFIG_PATH is set', async () => {
+			const apiDir = join(workspaceDir, 'apps', 'api');
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.resolvedPort).toBe(3000);
+			expect(result.credentials.PORT).toBe('3000');
+			expect(result.appName).toBe('api');
+		});
+	});
+
+	describe('with secrets', () => {
+		beforeEach(async () => {
+			// Create workspace with secrets
+			const gkmConfig = `
+import { defineWorkspace } from '@geekmidas/cli/config';
+
+export default defineWorkspace({
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+  },
+  services: {},
+});
+`;
+			await writeFile(join(workspaceDir, 'gkm.config.ts'), gkmConfig);
+
+			await mkdir(join(workspaceDir, 'apps', 'api', 'src'), {
+				recursive: true,
+			});
+			await writeFile(
+				join(workspaceDir, 'apps', 'api', 'package.json'),
+				JSON.stringify({ name: '@test/api', version: '0.0.1' }, null, 2),
+			);
+			await writeFile(
+				join(workspaceDir, 'apps', 'api', 'src', 'index.ts'),
+				'console.log("api");',
+			);
+
+			// Create unencrypted secrets (legacy format for testing)
+			await mkdir(join(workspaceDir, '.gkm', 'secrets'), { recursive: true });
+			const secrets = {
+				stage: 'development',
+				createdAt: new Date().toISOString(),
+				updatedAt: new Date().toISOString(),
+				services: {},
+				urls: {
+					DATABASE_URL: 'postgresql://localhost:5432/test',
+				},
+				custom: {
+					API_KEY: 'test-api-key',
+				},
+			};
+			await writeFile(
+				join(workspaceDir, '.gkm', 'secrets', 'development.json'),
+				JSON.stringify(secrets, null, 2),
+			);
+		});
+
+		it('should load secrets and inject PORT', async () => {
+			const apiDir = join(workspaceDir, 'apps', 'api');
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.credentials.PORT).toBe('3000');
+			expect(result.credentials.DATABASE_URL).toBe(
+				'postgresql://localhost:5432/test',
+			);
+			expect(result.credentials.API_KEY).toBe('test-api-key');
+		});
+
+		it('should write both secrets and PORT to dev-secrets.json', async () => {
+			const apiDir = join(workspaceDir, 'apps', 'api');
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			const content = await readFile(result.secretsJsonPath, 'utf-8');
+			const parsed = JSON.parse(content);
+
+			expect(parsed.PORT).toBe('3000');
+			expect(parsed.DATABASE_URL).toBe('postgresql://localhost:5432/test');
+			expect(parsed.API_KEY).toBe('test-api-key');
+		});
+	});
+});

package/src/dev/index.ts

@@ -1307,6 +1307,74 @@ await import('${entryPath}');
 	await writeFile(wrapperPath, content);
 }
 
+/**
+ * Result of preparing entry credentials for dev mode.
+ */
+export interface EntryCredentialsResult {
+	/** Credentials to inject (secrets + PORT) */
+	credentials: Record<string, string>;
+	/** Resolved port (from --port, workspace config, or default 3000) */
+	resolvedPort: number;
+	/** Path where credentials JSON was written */
+	secretsJsonPath: string;
+	/** Resolved app name (if in workspace) */
+	appName: string | undefined;
+	/** Secrets root directory */
+	secretsRoot: string;
+}
+
+/**
+ * Prepare credentials for entry dev mode.
+ * Loads workspace config, secrets, and injects PORT.
+ * @internal Exported for testing
+ */
+export async function prepareEntryCredentials(options: {
+	explicitPort?: number;
+	cwd?: string;
+}): Promise<EntryCredentialsResult> {
+	const cwd = options.cwd ?? process.cwd();
+
+	// Try to get workspace app config for port and secrets
+	let workspaceAppPort: number | undefined;
+	let secretsRoot: string = cwd;
+	let appName: string | undefined;
+
+	try {
+		const appConfig = await loadAppConfig(cwd);
+		workspaceAppPort = appConfig.app.port;
+		secretsRoot = appConfig.workspaceRoot;
+		appName = appConfig.appName;
+	} catch (error) {
+		// Not in a workspace - use defaults
+		logger.log(`⚠️  Could not load workspace config: ${(error as Error).message}`);
+		secretsRoot = findSecretsRoot(cwd);
+		appName = getAppNameFromCwd(cwd) ?? undefined;
+	}
+
+	// Determine port: explicit --port > workspace config > default 3000
+	const resolvedPort = options.explicitPort ?? workspaceAppPort ?? 3000;
+
+	// Load secrets and inject PORT
+	const credentials = await loadSecretsForApp(secretsRoot, appName);
+
+	// Always inject PORT into credentials so apps can read it
+	credentials.PORT = String(resolvedPort);
+
+	// Write secrets to temp JSON file (always write since we have PORT)
+	const secretsDir = join(secretsRoot, '.gkm');
+	await mkdir(secretsDir, { recursive: true });
+	const secretsJsonPath = join(secretsDir, 'dev-secrets.json');
+	await writeFile(secretsJsonPath, JSON.stringify(credentials, null, 2));
+
+	return {
+		credentials,
+		resolvedPort,
+		secretsJsonPath,
+		appName,
+		secretsRoot,
+	};
+}
+
 /**
  * Run any TypeScript file with secret injection.
  * Does not require gkm.config.ts.
@@ -1330,46 +1398,21 @@ async function entryDevCommand(options: DevOptions): Promise<void> {
 		logger.log(`📦 Loaded env: ${defaultEnv.loaded.join(', ')}`);
 	}
 
-	// Try to get workspace app config for port and secrets
-	let workspaceAppPort: number | undefined;
-	let secretsRoot: string = process.cwd();
-	let appName: string | undefined;
+	// Prepare credentials (loads workspace config, secrets, injects PORT)
+	// Only pass explicitPort if --port was actually specified by the user
+	const { credentials, resolvedPort, secretsJsonPath, appName } =
+		await prepareEntryCredentials({
+			explicitPort: options.portExplicit ? options.port : undefined,
+		});
 
-	try {
-		const appConfig = await loadAppConfig();
-		workspaceAppPort = appConfig.app.port;
-		secretsRoot = appConfig.workspaceRoot;
-		appName = appConfig.appName;
-		logger.log(`📦 App: ${appName} (port ${workspaceAppPort})`);
-	} catch {
-		// Not in a workspace - use defaults
-		secretsRoot = findSecretsRoot(process.cwd());
-		appName = getAppNameFromCwd() ?? undefined;
-		if (appName) {
-			logger.log(`📦 App name: ${appName}`);
-		}
+	if (appName) {
+		logger.log(`📦 App: ${appName} (port ${resolvedPort})`);
 	}
 
-	// Determine port: explicit --port > workspace config > default 3000
-	const port = options.port ?? workspaceAppPort ?? 3000;
-
-	logger.log(`🚀 Starting entry file: ${entry} on port ${port}`);
-
-	// Load secrets
-	const appSecrets = await loadSecretsForApp(secretsRoot, appName);
-	if (Object.keys(appSecrets).length > 0) {
-		logger.log(`🔐 Loaded ${Object.keys(appSecrets).length} secret(s)`);
-	} else {
-		logger.log(`⚠️  No secrets found in ${secretsRoot}/.gkm/secrets/`);
-	}
+	logger.log(`🚀 Starting entry file: ${entry} on port ${resolvedPort}`);
 
-	// Write secrets to temp JSON file
-	let secretsJsonPath: string | undefined;
-	if (Object.keys(appSecrets).length > 0) {
-		const secretsDir = join(secretsRoot, '.gkm');
-		await mkdir(secretsDir, { recursive: true });
-		secretsJsonPath = join(secretsDir, 'dev-secrets.json');
-		await writeFile(secretsJsonPath, JSON.stringify(appSecrets, null, 2));
+	if (Object.keys(credentials).length > 1) {
+		logger.log(`🔐 Loaded ${Object.keys(credentials).length - 1} secret(s) + PORT`);
 	}
 
 	// Create wrapper entry that injects secrets before importing user's file
@@ -1379,7 +1422,7 @@ async function entryDevCommand(options: DevOptions): Promise<void> {
 	await createEntryWrapper(wrapperPath, entryPath, secretsJsonPath);
 
 	// Start with tsx
-	const runner = new EntryRunner(wrapperPath, entryPath, watch, port);
+	const runner = new EntryRunner(wrapperPath, entryPath, watch, resolvedPort);
 	await runner.start();
 
 	// Handle graceful shutdown

package/src/init/generators/monorepo.ts

@@ -148,7 +148,6 @@ docker/.env
 
 # IDE
 .idea/
-.vscode/
 *.swp
 *.swo
 
@@ -207,6 +206,56 @@ export default defineConfig({
 });
 `;
 
+	// VSCode settings for consistent development experience
+	const vscodeSettings = {
+		'search.exclude': {
+			'**/.sst': true,
+			'**/.gkm': true,
+			'**/.turbo': true,
+		},
+		'editor.formatOnSave': true,
+		'editor.defaultFormatter': 'biomejs.biome',
+		'editor.codeActionsOnSave': {
+			'source.fixAll.biome': 'always',
+			'source.organizeImports.biome': 'always',
+			'source.organizeImports': 'always',
+		},
+		'[typescriptreact]': {
+			'editor.defaultFormatter': 'biomejs.biome',
+		},
+		'[typescript]': {
+			'editor.defaultFormatter': 'biomejs.biome',
+		},
+		'[javascript]': {
+			'editor.defaultFormatter': 'biomejs.biome',
+		},
+		'[json]': {
+			'editor.defaultFormatter': 'biomejs.biome',
+		},
+		'cSpell.words': [
+			'betterauth',
+			'dokploy',
+			'envkit',
+			'geekmidas',
+			'healthcheck',
+			'kysely',
+			'testkit',
+			'timestamptz',
+			'turborepo',
+			options.name,
+		],
+	};
+
+	// VSCode extensions recommendations
+	const vscodeExtensions = {
+		recommendations: [
+			'biomejs.biome',
+			'streetsidesoftware.code-spell-checker',
+			'dbaeumer.vscode-eslint',
+			'ms-azuretools.vscode-docker',
+		],
+	};
+
 	const files: GeneratedFile[] = [
 		{
 			path: 'package.json',
@@ -236,6 +285,14 @@ export default defineConfig({
 			path: '.gitignore',
 			content: gitignore,
 		},
+		{
+			path: '.vscode/settings.json',
+			content: `${JSON.stringify(vscodeSettings, null, '\t')}\n`,
+		},
+		{
+			path: '.vscode/extensions.json',
+			content: `${JSON.stringify(vscodeExtensions, null, '\t')}\n`,
+		},
 	];
 
 	// Add workspace config for fullstack template