@geekmidas/cli 0.30.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.30.0",
+  "version": "0.31.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/constructs": "~0.6.0",
     "@geekmidas/errors": "~0.1.0",
     "@geekmidas/logger": "~0.4.0",
-    "@geekmidas/constructs": "~0.6.0",
-    "@geekmidas/envkit": "~0.5.0",
-    "@geekmidas/schema": "~0.1.0"
+    "@geekmidas/schema": "~0.1.0",
+    "@geekmidas/envkit": "~0.5.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

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

@@ -0,0 +1,140 @@
+import { mkdir, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createEntryWrapper, findSecretsRoot } from '../index';
+
+describe('findSecretsRoot', () => {
+	let testDir: string;
+
+	beforeEach(async () => {
+		testDir = join(tmpdir(), `gkm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		await mkdir(testDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	it('should return startDir when no .gkm/secrets exists', () => {
+		const result = findSecretsRoot(testDir);
+		expect(result).toBe(testDir);
+	});
+
+	it('should find secrets in current directory', async () => {
+		await mkdir(join(testDir, '.gkm', 'secrets'), { recursive: true });
+
+		const result = findSecretsRoot(testDir);
+		expect(result).toBe(testDir);
+	});
+
+	it('should find secrets in parent directory', async () => {
+		const childDir = join(testDir, 'apps', 'auth');
+		await mkdir(childDir, { recursive: true });
+		await mkdir(join(testDir, '.gkm', 'secrets'), { recursive: true });
+
+		const result = findSecretsRoot(childDir);
+		expect(result).toBe(testDir);
+	});
+
+	it('should find secrets in grandparent directory', async () => {
+		const grandchildDir = join(testDir, 'apps', 'auth', 'src');
+		await mkdir(grandchildDir, { recursive: true });
+		await mkdir(join(testDir, '.gkm', 'secrets'), { recursive: true });
+
+		const result = findSecretsRoot(grandchildDir);
+		expect(result).toBe(testDir);
+	});
+
+	it('should prefer closer secrets directory', async () => {
+		// Create secrets in both parent and child
+		const childDir = join(testDir, 'apps', 'auth');
+		await mkdir(join(testDir, '.gkm', 'secrets'), { recursive: true });
+		await mkdir(join(childDir, '.gkm', 'secrets'), { recursive: true });
+
+		const result = findSecretsRoot(childDir);
+		expect(result).toBe(childDir);
+	});
+});
+
+describe('createEntryWrapper', () => {
+	let testDir: string;
+
+	beforeEach(async () => {
+		testDir = join(tmpdir(), `gkm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		await mkdir(testDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	it('should create wrapper without secrets injection', async () => {
+		const wrapperPath = join(testDir, 'wrapper.ts');
+		const entryPath = '/path/to/entry.ts';
+
+		await createEntryWrapper(wrapperPath, entryPath, undefined);
+
+		const content = await readFile(wrapperPath, 'utf-8');
+
+		expect(content).toContain("import '/path/to/entry.ts'");
+		expect(content).not.toContain('Credentials');
+		expect(content).toContain("Entry wrapper generated by 'gkm dev --entry'");
+	});
+
+	it('should create wrapper with secrets injection', async () => {
+		const wrapperPath = join(testDir, 'wrapper.ts');
+		const entryPath = '/path/to/entry.ts';
+		const secretsPath = '/path/to/secrets.json';
+
+		await createEntryWrapper(wrapperPath, entryPath, secretsPath);
+
+		const content = await readFile(wrapperPath, 'utf-8');
+
+		expect(content).toContain(
+			"import { Credentials } from '@geekmidas/envkit/credentials'",
+		);
+		expect(content).toContain(secretsPath);
+		expect(content).toContain('Object.assign(Credentials');
+		expect(content).toContain("import '/path/to/entry.ts'");
+	});
+
+	it('should inject secrets before entry import', async () => {
+		const wrapperPath = join(testDir, 'wrapper.ts');
+		const entryPath = '/path/to/entry.ts';
+		const secretsPath = '/path/to/secrets.json';
+
+		await createEntryWrapper(wrapperPath, entryPath, secretsPath);
+
+		const content = await readFile(wrapperPath, 'utf-8');
+
+		const credentialsIndex = content.indexOf('Credentials');
+		const importIndex = content.indexOf("import '/path/to/entry.ts'");
+
+		expect(credentialsIndex).toBeGreaterThan(-1);
+		expect(importIndex).toBeGreaterThan(-1);
+		expect(credentialsIndex).toBeLessThan(importIndex);
+	});
+
+	it('should include shebang line', async () => {
+		const wrapperPath = join(testDir, 'wrapper.ts');
+		const entryPath = '/path/to/entry.ts';
+
+		await createEntryWrapper(wrapperPath, entryPath, undefined);
+
+		const content = await readFile(wrapperPath, 'utf-8');
+
+		expect(content.startsWith('#!/usr/bin/env node')).toBe(true);
+	});
+
+	it('should handle Windows-style paths', async () => {
+		const wrapperPath = join(testDir, 'wrapper.ts');
+		const entryPath = 'C:\\Users\\test\\project\\src\\index.ts';
+
+		await createEntryWrapper(wrapperPath, entryPath, undefined);
+
+		const content = await readFile(wrapperPath, 'utf-8');
+
+		expect(content).toContain(entryPath);
+	});
+});

package/src/dev/index.ts

@@ -2,7 +2,7 @@ import { type ChildProcess, execSync, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:net';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import chokidar from 'chokidar';
 import { config as dotenvConfig } from 'dotenv';
 import fg from 'fast-glob';
@@ -304,9 +304,18 @@ export interface DevOptions {
 	app?: string;
 	/** Filter apps by pattern (passed to turbo --filter) */
 	filter?: string;
+	/** Entry file to run (bypasses gkm config) */
+	entry?: string;
+	/** Watch for file changes (default: true with --entry) */
+	watch?: boolean;
 }
 
 export async function devCommand(options: DevOptions): Promise<void> {
+	// Handle --entry mode: run any file with secret injection
+	if (options.entry) {
+		return entryDevCommand(options);
+	}
+
 	// Load default .env file BEFORE loading config
 	// This ensures env vars are available when config and its dependencies are loaded
 	const defaultEnv = loadEnvFiles('.env');
@@ -1242,6 +1251,242 @@ async function buildServer(
 	]);
 }
 
+/**
+ * Find the directory containing .gkm/secrets/.
+ * Walks up from cwd until it finds one, or returns cwd.
+ * @internal Exported for testing
+ */
+export function findSecretsRoot(startDir: string): string {
+	let dir = startDir;
+	while (dir !== '/') {
+		if (existsSync(join(dir, '.gkm', 'secrets'))) {
+			return dir;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return startDir;
+}
+
+/**
+ * Create a wrapper script that injects secrets before importing the entry file.
+ * @internal Exported for testing
+ */
+export async function createEntryWrapper(
+	wrapperPath: string,
+	entryPath: string,
+	secretsJsonPath?: string,
+): Promise<void> {
+	const credentialsInjection = secretsJsonPath
+		? `import { Credentials } from '@geekmidas/envkit/credentials';
+import { existsSync, readFileSync } from 'node:fs';
+
+// Inject dev secrets into Credentials (before app import)
+const secretsPath = '${secretsJsonPath}';
+if (existsSync(secretsPath)) {
+  Object.assign(Credentials, JSON.parse(readFileSync(secretsPath, 'utf-8')));
+}
+
+`
+		: '';
+
+	const content = `#!/usr/bin/env node
+/**
+ * Entry wrapper generated by 'gkm dev --entry'
+ */
+${credentialsInjection}// Import and run the user's entry file
+import '${entryPath}';
+`;
+
+	await writeFile(wrapperPath, content);
+}
+
+/**
+ * Run any TypeScript file with secret injection.
+ * Does not require gkm.config.ts.
+ */
+async function entryDevCommand(options: DevOptions): Promise<void> {
+	const { entry, port = 3000, watch = true } = options;
+
+	if (!entry) {
+		throw new Error('--entry requires a file path');
+	}
+
+	const entryPath = resolve(process.cwd(), entry);
+
+	if (!existsSync(entryPath)) {
+		throw new Error(`Entry file not found: ${entryPath}`);
+	}
+
+	logger.log(`🚀 Starting entry file: ${entry}`);
+
+	// Load .env files
+	const defaultEnv = loadEnvFiles('.env');
+	if (defaultEnv.loaded.length > 0) {
+		logger.log(`📦 Loaded env: ${defaultEnv.loaded.join(', ')}`);
+	}
+
+	// Determine secrets root (current dir or workspace root)
+	const secretsRoot = findSecretsRoot(process.cwd());
+
+	// Determine app name for per-app secret mapping
+	const appName = getAppNameFromCwd() ?? undefined;
+
+	// Load secrets
+	const appSecrets = await loadSecretsForApp(secretsRoot, appName);
+	if (Object.keys(appSecrets).length > 0) {
+		logger.log(`🔐 Loaded ${Object.keys(appSecrets).length} secret(s)`);
+	}
+
+	// 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));
+	}
+
+	// Create wrapper entry that injects secrets before importing user's file
+	const wrapperDir = join(process.cwd(), '.gkm');
+	await mkdir(wrapperDir, { recursive: true });
+	const wrapperPath = join(wrapperDir, 'entry-wrapper.ts');
+	await createEntryWrapper(wrapperPath, entryPath, secretsJsonPath);
+
+	// Start with tsx
+	const runner = new EntryRunner(wrapperPath, entryPath, watch, port);
+	await runner.start();
+
+	// Handle graceful shutdown
+	let isShuttingDown = false;
+	const shutdown = () => {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+
+		logger.log('\n🛑 Shutting down...');
+		runner.stop();
+		process.exit(0);
+	};
+
+	process.on('SIGINT', shutdown);
+	process.on('SIGTERM', shutdown);
+
+	// Keep the process alive
+	await new Promise(() => {});
+}
+
+/**
+ * Runs and watches a TypeScript entry file using tsx.
+ */
+class EntryRunner {
+	private childProcess: ChildProcess | null = null;
+	private watcher: ReturnType<typeof chokidar.watch> | null = null;
+	private isRunning = false;
+
+	constructor(
+		private wrapperPath: string,
+		private entryPath: string,
+		private watch: boolean,
+		private port: number,
+	) {}
+
+	async start(): Promise<void> {
+		await this.runProcess();
+
+		if (this.watch) {
+			// Watch the entry file's directory for changes
+			const watchDir = dirname(this.entryPath);
+
+			this.watcher = chokidar.watch(watchDir, {
+				ignored: /(^|[/\\])\../,
+				persistent: true,
+				ignoreInitial: true,
+			});
+
+			let restartTimeout: NodeJS.Timeout | null = null;
+
+			this.watcher.on('change', (path) => {
+				logger.log(`📝 File changed: ${path}`);
+
+				// Debounce restarts
+				if (restartTimeout) {
+					clearTimeout(restartTimeout);
+				}
+
+				restartTimeout = setTimeout(async () => {
+					logger.log('🔄 Restarting...');
+					await this.restart();
+				}, 300);
+			});
+
+			logger.log(`👀 Watching for changes in: ${watchDir}`);
+		}
+	}
+
+	private async runProcess(): Promise<void> {
+		// Pass PORT as environment variable
+		const env = { ...process.env, PORT: String(this.port) };
+
+		this.childProcess = spawn('npx', ['tsx', this.wrapperPath], {
+			stdio: 'inherit',
+			env,
+			detached: true,
+		});
+
+		this.isRunning = true;
+
+		this.childProcess.on('error', (error) => {
+			logger.error('❌ Process error:', error);
+		});
+
+		this.childProcess.on('exit', (code) => {
+			if (code !== null && code !== 0 && code !== 143) {
+				// 143 = SIGTERM
+				logger.error(`❌ Process exited with code ${code}`);
+			}
+			this.isRunning = false;
+		});
+
+		// Give the process a moment to start
+		await new Promise((resolve) => setTimeout(resolve, 500));
+
+		if (this.isRunning) {
+			logger.log(`\n🎉 Running at http://localhost:${this.port}`);
+		}
+	}
+
+	async restart(): Promise<void> {
+		this.stopProcess();
+		await new Promise((resolve) => setTimeout(resolve, 500));
+		await this.runProcess();
+	}
+
+	stop(): void {
+		this.watcher?.close();
+		this.stopProcess();
+	}
+
+	private stopProcess(): void {
+		if (this.childProcess && this.isRunning) {
+			const pid = this.childProcess.pid;
+			if (pid) {
+				try {
+					process.kill(-pid, 'SIGTERM');
+				} catch {
+					try {
+						process.kill(pid, 'SIGTERM');
+					} catch {
+						// Process already dead
+					}
+				}
+			}
+			this.childProcess = null;
+			this.isRunning = false;
+		}
+	}
+}
+
 class DevServer {
 	private serverProcess: ChildProcess | null = null;
 	private isRunning = false;

package/src/index.ts

@@ -136,28 +136,42 @@ program
 	.command('dev')
 	.description('Start development server with automatic reload')
 	.option('-p, --port <port>', 'Port to run the development server on')
+	.option('--entry <file>', 'Entry file to run (bypasses gkm config)')
+	.option('--watch', 'Watch for file changes (default: true with --entry)')
+	.option('--no-watch', 'Disable file watching')
 	.option(
 		'--enable-openapi',
 		'Enable OpenAPI documentation for development server',
 		true,
 	)
-	.action(async (options: { port?: string; enableOpenapi?: boolean }) => {
-		try {
-			const globalOptions = program.opts();
-			if (globalOptions.cwd) {
-				process.chdir(globalOptions.cwd);
-			}
+	.action(
+		async (options: {
+			port?: string;
+			entry?: string;
+			watch?: boolean;
+			enableOpenapi?: boolean;
+		}) => {
+			try {
+				const globalOptions = program.opts();
+				if (globalOptions.cwd) {
+					process.chdir(globalOptions.cwd);
+				}
 
-			await devCommand({
-				port: options.port ? Number.parseInt(options.port, 10) : 3000,
-				portExplicit: !!options.port,
-				enableOpenApi: options.enableOpenapi ?? true,
-			});
-		} catch (error) {
-			console.error(error instanceof Error ? error.message : 'Command failed');
-			process.exit(1);
-		}
-	});
+				await devCommand({
+					port: options.port ? Number.parseInt(options.port, 10) : 3000,
+					portExplicit: !!options.port,
+					enableOpenApi: options.enableOpenapi ?? true,
+					entry: options.entry,
+					watch: options.watch,
+				});
+			} catch (error) {
+				console.error(
+					error instanceof Error ? error.message : 'Command failed',
+				);
+				process.exit(1);
+			}
+		},
+	);
 
 program
 	.command('test')

package/src/init/versions.ts

@@ -35,7 +35,7 @@ export const GEEKMIDAS_VERSIONS = {
 	'@geekmidas/constructs': '~0.6.0',
 	'@geekmidas/db': '~0.3.0',
 	'@geekmidas/emailkit': '~0.2.0',
-	'@geekmidas/envkit': '~0.4.0',
+	'@geekmidas/envkit': '~0.5.0',
 	'@geekmidas/errors': '~0.1.0',
 	'@geekmidas/events': '~0.2.0',
 	'@geekmidas/logger': '~0.4.0',