@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

package/src/auth/index.ts

@@ -1,233 +0,0 @@
-import { stdin as input, stdout as output } from 'node:process';
-import * as readline from 'node:readline/promises';
-import {
-	getCredentialsPath,
-	getDokployCredentials,
-	removeDokployCredentials,
-	storeDokployCredentials,
-} from './credentials';
-
-const logger = console;
-
-export interface LoginOptions {
-	/** Service to login to */
-	service: 'dokploy';
-	/** API token (if not provided, will prompt) */
-	token?: string;
-	/** Endpoint URL */
-	endpoint?: string;
-}
-
-export interface LogoutOptions {
-	/** Service to logout from */
-	service?: 'dokploy' | 'all';
-}
-
-/**
- * Validate Dokploy token by making a test API call
- */
-export async function validateDokployToken(
-	endpoint: string,
-	token: string,
-): Promise<boolean> {
-	const { DokployApi } = await import('../deploy/dokploy-api');
-	const api = new DokployApi({ baseUrl: endpoint, token });
-	return api.validateToken();
-}
-
-/**
- * Prompt for input (handles both TTY and non-TTY)
- */
-async function prompt(message: string, hidden = false): Promise<string> {
-	if (!process.stdin.isTTY) {
-		throw new Error(
-			'Interactive input required. Please provide --token option.',
-		);
-	}
-
-	if (hidden) {
-		// For hidden input, use raw mode directly without readline
-		process.stdout.write(message);
-
-		return new Promise((resolve, reject) => {
-			let value = '';
-
-			const cleanup = () => {
-				process.stdin.setRawMode(false);
-				process.stdin.pause();
-				process.stdin.removeListener('data', onData);
-				process.stdin.removeListener('error', onError);
-			};
-
-			const onError = (err: Error) => {
-				cleanup();
-				reject(err);
-			};
-
-			const onData = (char: Buffer) => {
-				const c = char.toString();
-
-				if (c === '\n' || c === '\r') {
-					cleanup();
-					process.stdout.write('\n');
-					resolve(value);
-				} else if (c === '\u0003') {
-					// Ctrl+C
-					cleanup();
-					process.stdout.write('\n');
-					process.exit(1);
-				} else if (c === '\u007F' || c === '\b') {
-					// Backspace
-					if (value.length > 0) {
-						value = value.slice(0, -1);
-					}
-				} else {
-					value += c;
-				}
-			};
-
-			process.stdin.setRawMode(true);
-			process.stdin.resume();
-			process.stdin.on('data', onData);
-			process.stdin.on('error', onError);
-		});
-	} else {
-		// For visible input, use readline
-		const rl = readline.createInterface({ input, output });
-		try {
-			return await rl.question(message);
-		} finally {
-			rl.close();
-		}
-	}
-}
-
-/**
- * Login to a service
- */
-export async function loginCommand(options: LoginOptions): Promise<void> {
-	const { service, token: providedToken, endpoint: providedEndpoint } = options;
-
-	if (service === 'dokploy') {
-		logger.log('\n🔐 Logging in to Dokploy...\n');
-
-		// Get endpoint
-		let endpoint = providedEndpoint;
-		if (!endpoint) {
-			endpoint = await prompt(
-				'Dokploy URL (e.g., https://dokploy.example.com): ',
-			);
-		}
-
-		// Normalize endpoint (remove trailing slash)
-		endpoint = endpoint.replace(/\/$/, '');
-
-		// Validate endpoint format
-		try {
-			new URL(endpoint);
-		} catch {
-			logger.error('Invalid URL format');
-			process.exit(1);
-		}
-
-		// Get token
-		let token = providedToken;
-		if (!token) {
-			logger.log(`\nGenerate a token at: ${endpoint}/settings/profile\n`);
-			token = await prompt('API Token: ', true);
-		}
-
-		if (!token) {
-			logger.error('Token is required');
-			process.exit(1);
-		}
-
-		// Validate token
-		logger.log('\nValidating credentials...');
-		const isValid = await validateDokployToken(endpoint, token);
-
-		if (!isValid) {
-			logger.error(
-				'\n✗ Invalid credentials. Please check your token and try again.',
-			);
-			process.exit(1);
-		}
-
-		// Store credentials
-		await storeDokployCredentials(token, endpoint);
-
-		logger.log('\n✓ Successfully logged in to Dokploy!');
-		logger.log(`  Endpoint: ${endpoint}`);
-		logger.log(`  Credentials stored in: ${getCredentialsPath()}`);
-		logger.log(
-			'\nYou can now use deploy commands without setting DOKPLOY_API_TOKEN.',
-		);
-	}
-}
-
-/**
- * Logout from a service
- */
-export async function logoutCommand(options: LogoutOptions): Promise<void> {
-	const { service = 'dokploy' } = options;
-
-	if (service === 'all') {
-		const dokployRemoved = await removeDokployCredentials();
-
-		if (dokployRemoved) {
-			logger.log('\n✓ Logged out from all services');
-		} else {
-			logger.log('\nNo stored credentials found');
-		}
-		return;
-	}
-
-	if (service === 'dokploy') {
-		const removed = await removeDokployCredentials();
-
-		if (removed) {
-			logger.log('\n✓ Logged out from Dokploy');
-		} else {
-			logger.log('\nNo Dokploy credentials found');
-		}
-	}
-}
-
-/**
- * Show current login status
- */
-export async function whoamiCommand(): Promise<void> {
-	logger.log('\n📋 Current credentials:\n');
-
-	const dokploy = await getDokployCredentials();
-
-	if (dokploy) {
-		logger.log('  Dokploy:');
-		logger.log(`    Endpoint: ${dokploy.endpoint}`);
-		logger.log(`    Token: ${maskToken(dokploy.token)}`);
-	} else {
-		logger.log('  Dokploy: Not logged in');
-	}
-
-	logger.log(`\n  Credentials file: ${getCredentialsPath()}`);
-}
-
-/**
- * Mask a token for display
- */
-export function maskToken(token: string): string {
-	if (token.length <= 8) {
-		return '****';
-	}
-	return `${token.slice(0, 4)}...${token.slice(-4)}`;
-}
-
-// Re-export credentials utilities for use in other modules
-export {
-	getDokployCredentials,
-	getDokployEndpoint,
-	getDokployRegistryId,
-	getDokployToken,
-	storeDokployCredentials,
-	storeDokployRegistryId,
-} from './credentials';

package/src/build/__tests__/bundler.spec.ts

@@ -1,446 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { Construct } from '@geekmidas/constructs';
-import { itWithDir } from '@geekmidas/testkit/os';
-import { beforeEach, describe, expect, vi } from 'vitest';
-import type { StageSecrets } from '../../secrets/types';
-import { bundleServer } from '../bundler';
-
-// Mock child_process to avoid actually running tsdown
-vi.mock('node:child_process', () => ({
-	spawnSync: vi.fn().mockReturnValue({ status: 0, error: null }),
-	execSync: vi.fn().mockReturnValue('tsdown/0.12.8 darwin-arm64 node-v22.21.1'),
-}));
-
-// Mock construct that returns specific environment variables
-function createMockConstruct(envVars: string[]): Construct {
-	return {
-		getEnvironment: vi.fn().mockResolvedValue(envVars),
-	} as unknown as Construct;
-}
-
-// Helper to create a minimal secrets file
-async function createSecretsFile(
-	dir: string,
-	stage: string,
-	secrets: Partial<StageSecrets>,
-): Promise<void> {
-	const secretsDir = join(dir, '.gkm', 'secrets');
-	await mkdir(secretsDir, { recursive: true });
-
-	const fullSecrets: StageSecrets = {
-		stage,
-		createdAt: new Date().toISOString(),
-		updatedAt: new Date().toISOString(),
-		services: {},
-		urls: {},
-		custom: {},
-		...secrets,
-	};
-
-	await writeFile(
-		join(secretsDir, `${stage}.json`),
-		JSON.stringify(fullSecrets, null, 2),
-	);
-}
-
-// Helper to create a minimal entry point file and mock the bundle output
-async function createEntryPoint(dir: string): Promise<string> {
-	const outputDir = join(dir, '.gkm', 'server');
-	const distDir = join(outputDir, 'dist');
-	await mkdir(outputDir, { recursive: true });
-	await mkdir(distDir, { recursive: true });
-
-	const entryPoint = join(outputDir, 'server.ts');
-	await writeFile(entryPoint, 'console.log("hello");');
-
-	// Create the output file that esbuild would normally create
-	// (since we're mocking spawnSync, the file won't be created automatically)
-	await writeFile(join(distDir, 'server.mjs'), 'console.log("bundled");');
-
-	return entryPoint;
-}
-
-describe('bundleServer environment validation', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	itWithDir(
-		'should pass validation when all required env vars are present',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				urls: { DATABASE_URL: 'postgresql://localhost/db' },
-				custom: { API_KEY: 'sk_test_123' },
-			});
-
-			const constructs = [
-				createMockConstruct(['DATABASE_URL']),
-				createMockConstruct(['API_KEY']),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				// Should not throw
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					constructs,
-				});
-
-				expect(result.masterKey).toBeDefined();
-				expect(constructs[0].getEnvironment).toHaveBeenCalled();
-				expect(constructs[1].getEnvironment).toHaveBeenCalled();
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should throw error when required env vars are missing',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				urls: { DATABASE_URL: 'postgresql://localhost/db' },
-				custom: {},
-			});
-
-			const constructs = [
-				createMockConstruct(['DATABASE_URL', 'API_KEY', 'JWT_SECRET']),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'production',
-						constructs,
-					}),
-				).rejects.toThrow('Missing environment variables');
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should include missing variables in error message',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'staging', {
-				custom: { EXISTING_VAR: 'value' },
-			});
-
-			const constructs = [
-				createMockConstruct(['EXISTING_VAR', 'MISSING_VAR_1', 'MISSING_VAR_2']),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'staging',
-						constructs,
-					}),
-				).rejects.toThrow(/MISSING_VAR_1/);
-
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'staging',
-						constructs,
-					}),
-				).rejects.toThrow(/MISSING_VAR_2/);
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should collect env vars from multiple constructs',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				urls: { DATABASE_URL: 'postgresql://localhost/db' },
-				custom: {
-					API_KEY: 'key',
-					REDIS_URL: 'redis://localhost',
-					JWT_SECRET: 'secret',
-				},
-			});
-
-			const constructs = [
-				createMockConstruct(['DATABASE_URL']),
-				createMockConstruct(['API_KEY', 'REDIS_URL']),
-				createMockConstruct(['JWT_SECRET']),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					constructs,
-				});
-
-				expect(result.masterKey).toBeDefined();
-
-				// All constructs should have been checked
-				for (const construct of constructs) {
-					expect(construct.getEnvironment).toHaveBeenCalled();
-				}
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should deduplicate env vars from multiple constructs',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				custom: { SHARED_VAR: 'value' },
-			});
-
-			// Multiple constructs requiring the same variable
-			const constructs = [
-				createMockConstruct(['SHARED_VAR']),
-				createMockConstruct(['SHARED_VAR']),
-				createMockConstruct(['SHARED_VAR']),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				// Should pass since SHARED_VAR is provided once
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					constructs,
-				});
-
-				expect(result.masterKey).toBeDefined();
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should skip validation when no constructs provided',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				custom: {},
-			});
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				// Should not throw even with empty secrets
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					constructs: [],
-				});
-
-				expect(result.masterKey).toBeDefined();
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should skip validation when constructs is undefined',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				custom: {},
-			});
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					// No constructs provided
-				});
-
-				expect(result.masterKey).toBeDefined();
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should recognize service credentials as provided',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'production', {
-				services: {
-					postgres: {
-						host: 'localhost',
-						port: 5432,
-						username: 'app',
-						password: 'secret',
-						database: 'mydb',
-					},
-				},
-			});
-
-			const constructs = [
-				createMockConstruct([
-					'POSTGRES_HOST',
-					'POSTGRES_PORT',
-					'POSTGRES_USER',
-					'POSTGRES_PASSWORD',
-					'POSTGRES_DB',
-				]),
-			];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				const result = await bundleServer({
-					entryPoint,
-					outputDir: join(dir, '.gkm', 'server', 'dist'),
-					minify: false,
-					sourcemap: false,
-					external: [],
-					stage: 'production',
-					constructs,
-				});
-
-				expect(result.masterKey).toBeDefined();
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should auto-initialize secrets and throw for missing env vars',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			// Don't create secrets file - it should be auto-initialized
-
-			const constructs = [createMockConstruct(['DATABASE_URL'])];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				// Should auto-initialize secrets but then fail because DATABASE_URL is required
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'production',
-						constructs,
-					}),
-				).rejects.toThrow('Missing environment variables');
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-
-	itWithDir(
-		'should include helpful instructions in error message',
-		async ({ dir }) => {
-			const entryPoint = await createEntryPoint(dir);
-			await createSecretsFile(dir, 'myapp', {
-				custom: {},
-			});
-
-			const constructs = [createMockConstruct(['MISSING_VAR'])];
-
-			const originalCwd = process.cwd();
-			process.chdir(dir);
-
-			try {
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'myapp',
-						constructs,
-					}),
-				).rejects.toThrow(/gkm secrets:set/);
-
-				await expect(
-					bundleServer({
-						entryPoint,
-						outputDir: join(dir, '.gkm', 'server', 'dist'),
-						minify: false,
-						sourcemap: false,
-						external: [],
-						stage: 'myapp',
-						constructs,
-					}),
-				).rejects.toThrow(/gkm secrets:import/);
-			} finally {
-				process.chdir(originalCwd);
-			}
-		},
-	);
-});