@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/src/debug.ts

@@ -1,68 +0,0 @@
-let _debug = false;
-
-/**
- * Enable debug mode globally.
- * When enabled, verbose error details are shown everywhere.
- */
-export function enableDebug(): void {
-	_debug = true;
-}
-
-/**
- * Check if debug mode is active.
- * Activated by `--debug` flag or `GKM_DEBUG=1` env var.
- */
-export function isDebug(): boolean {
-	return _debug || process.env.GKM_DEBUG === '1';
-}
-
-/**
- * Log a message only when debug mode is active.
- */
-export function debug(...args: unknown[]): void {
-	if (isDebug()) {
-		console.debug('[debug]', ...args);
-	}
-}
-
-/**
- * Format a fatal error for display.
- * Always includes the full stack trace since these are process-ending errors.
- */
-export function formatError(error: unknown): string {
-	if (!(error instanceof Error)) {
-		return String(error);
-	}
-
-	let output = error.stack ?? error.message;
-
-	// Include cause chain if present
-	let cause = error.cause;
-	while (cause) {
-		if (cause instanceof Error) {
-			output += `\n\nCaused by: ${cause.stack ?? cause.message}`;
-			cause = cause.cause;
-		} else {
-			output += `\n\nCaused by: ${String(cause)}`;
-			break;
-		}
-	}
-
-	return output;
-}
-
-/**
- * Format a non-fatal error for display.
- * Shows only the message by default, full stack in debug mode.
- */
-export function formatWarning(error: unknown): string {
-	if (!(error instanceof Error)) {
-		return String(error);
-	}
-
-	if (!isDebug()) {
-		return error.message;
-	}
-
-	return error.stack ?? error.message;
-}

package/src/deploy/CachedStateProvider.ts

@@ -1,86 +0,0 @@
-/**
- * Cached State Provider
- *
- * Wraps a remote state provider (SSM) with local filesystem cache.
- * - Read: Local first, then remote if missing
- * - Write: Remote first, then update local cache
- *
- * This enables fast local development while keeping SSM as source of truth.
- */
-
-import type { StateProvider } from './StateProvider';
-import type { DokployStageState } from './state';
-
-/**
- * Cached state provider that wraps a remote provider with local cache.
- */
-export class CachedStateProvider implements StateProvider {
-	constructor(
-		private readonly remote: StateProvider,
-		private readonly local: StateProvider,
-	) {}
-
-	async read(stage: string): Promise<DokployStageState | null> {
-		// Try local cache first
-		const localState = await this.local.read(stage);
-		if (localState) {
-			return localState;
-		}
-
-		// Fall back to remote
-		const remoteState = await this.remote.read(stage);
-		if (remoteState) {
-			// Update local cache
-			await this.local.write(stage, remoteState);
-		}
-
-		return remoteState;
-	}
-
-	async write(stage: string, state: DokployStageState): Promise<void> {
-		// Write to remote first (source of truth)
-		await this.remote.write(stage, state);
-
-		// Update local cache
-		await this.local.write(stage, state);
-	}
-
-	/**
-	 * Force pull from remote to local.
-	 * Used by `gkm state pull` command.
-	 */
-	async pull(stage: string): Promise<DokployStageState | null> {
-		const remoteState = await this.remote.read(stage);
-		if (remoteState) {
-			await this.local.write(stage, remoteState);
-		}
-		return remoteState;
-	}
-
-	/**
-	 * Force push from local to remote.
-	 * Used by `gkm state push` command.
-	 */
-	async push(stage: string): Promise<DokployStageState | null> {
-		const localState = await this.local.read(stage);
-		if (localState) {
-			await this.remote.write(stage, localState);
-		}
-		return localState;
-	}
-
-	/**
-	 * Get both local and remote state for comparison.
-	 * Used by `gkm state diff` command.
-	 */
-	async diff(stage: string): Promise<{
-		local: DokployStageState | null;
-		remote: DokployStageState | null;
-	}> {
-		const [local, remote] = await Promise.all([
-			this.local.read(stage),
-			this.remote.read(stage),
-		]);
-		return { local, remote };
-	}
-}

package/src/deploy/LocalStateProvider.ts

@@ -1,57 +0,0 @@
-/**
- * Local Filesystem State Provider
- *
- * Stores deployment state in .gkm/deploy-{stage}.json files.
- * This is the default provider for local development.
- */
-
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { StateProvider } from './StateProvider';
-import type { DokployStageState } from './state';
-
-/**
- * Get the state file path for a stage.
- */
-function getStateFilePath(workspaceRoot: string, stage: string): string {
-	return join(workspaceRoot, '.gkm', `deploy-${stage}.json`);
-}
-
-/**
- * Local filesystem state provider.
- *
- * Stores state in .gkm/deploy-{stage}.json files in the workspace root.
- */
-export class LocalStateProvider implements StateProvider {
-	constructor(private readonly workspaceRoot: string) {}
-
-	async read(stage: string): Promise<DokployStageState | null> {
-		const filePath = getStateFilePath(this.workspaceRoot, stage);
-
-		try {
-			const content = await readFile(filePath, 'utf-8');
-			return JSON.parse(content) as DokployStageState;
-		} catch (error) {
-			// File doesn't exist - return null
-			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-				return null;
-			}
-			// Log other errors but don't fail
-			console.warn(`Warning: Could not read deploy state: ${error}`);
-			return null;
-		}
-	}
-
-	async write(stage: string, state: DokployStageState): Promise<void> {
-		const filePath = getStateFilePath(this.workspaceRoot, stage);
-		const dir = join(this.workspaceRoot, '.gkm');
-
-		// Ensure .gkm directory exists
-		await mkdir(dir, { recursive: true });
-
-		// Update last deployed timestamp
-		state.lastDeployedAt = new Date().toISOString();
-
-		await writeFile(filePath, JSON.stringify(state, null, 2));
-	}
-}

package/src/deploy/SSMStateProvider.ts

@@ -1,117 +0,0 @@
-/**
- * AWS SSM Parameter Store State Provider
- *
- * Stores deployment state as SecureString parameters in AWS SSM.
- * Uses AWS-managed KMS key for encryption (free tier).
- *
- * Parameter naming: /gkm/{workspaceName}/{stage}/state
- */
-
-import {
-	GetParameterCommand,
-	ParameterNotFound,
-	PutParameterCommand,
-	SSMClient,
-	type SSMClientConfig,
-} from '@aws-sdk/client-ssm';
-import type { AwsRegion, StateProvider } from './StateProvider';
-import type { DokployStageState } from './state';
-
-export interface SSMStateProviderOptions {
-	/** Workspace name (used in parameter path) */
-	workspaceName: string;
-	/** AWS region */
-	region?: AwsRegion;
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile?: string;
-	/** AWS credentials (optional - uses default credential chain if not provided) */
-	credentials?: SSMClientConfig['credentials'];
-	/** Custom endpoint (for LocalStack or other S3-compatible services) */
-	endpoint?: string;
-}
-
-/**
- * AWS SSM Parameter Store state provider.
- *
- * Stores state as encrypted SecureString parameters.
- * Parameter path: /gkm/{workspaceName}/{stage}/state
- */
-export class SSMStateProvider implements StateProvider {
-	constructor(
-		readonly workspaceName: string,
-		private readonly client: SSMClient,
-	) {}
-
-	/**
-	 * Create an SSMStateProvider with a new SSMClient.
-	 */
-	static create(options: SSMStateProviderOptions): SSMStateProvider {
-		const clientConfig: SSMClientConfig = {
-			region: options.region,
-			endpoint: options.endpoint,
-		};
-
-		// Use profile credentials if specified, otherwise use provided credentials or default chain
-		if (options.profile) {
-			// Dynamic import to avoid requiring @aws-sdk/credential-providers when not using profiles
-			const { fromIni } = require('@aws-sdk/credential-providers');
-			clientConfig.credentials = fromIni({ profile: options.profile });
-		} else if (options.credentials) {
-			clientConfig.credentials = options.credentials;
-		}
-
-		const client = new SSMClient(clientConfig);
-		return new SSMStateProvider(options.workspaceName, client);
-	}
-
-	/**
-	 * Get the SSM parameter name for a stage.
-	 */
-	private getParameterName(stage: string): string {
-		return `/gkm/${this.workspaceName}/${stage}/state`;
-	}
-
-	async read(stage: string): Promise<DokployStageState | null> {
-		const parameterName = this.getParameterName(stage);
-
-		try {
-			const response = await this.client.send(
-				new GetParameterCommand({
-					Name: parameterName,
-					WithDecryption: true,
-				}),
-			);
-
-			if (!response.Parameter?.Value) {
-				return null;
-			}
-
-			return JSON.parse(response.Parameter.Value) as DokployStageState;
-		} catch (error) {
-			// Parameter doesn't exist - return null (new deployment)
-			if (error instanceof ParameterNotFound) {
-				return null;
-			}
-
-			// Re-throw other errors (permission denied, network, etc.)
-			throw error;
-		}
-	}
-
-	async write(stage: string, state: DokployStageState): Promise<void> {
-		const parameterName = this.getParameterName(stage);
-
-		// Update last deployed timestamp
-		state.lastDeployedAt = new Date().toISOString();
-
-		await this.client.send(
-			new PutParameterCommand({
-				Name: parameterName,
-				Value: JSON.stringify(state),
-				Type: 'SecureString',
-				Overwrite: true,
-				Description: `GKM deployment state for ${this.workspaceName}/${stage}`,
-			}),
-		);
-	}
-}

package/src/deploy/StateProvider.ts

@@ -1,175 +0,0 @@
-/**
- * State Provider Interface
- *
- * Abstracts the storage backend for deployment state.
- * Built-in providers: LocalStateProvider, SSMStateProvider
- * Users can also supply custom implementations.
- */
-
-import type { DokployStageState } from './state';
-
-/**
- * Interface for deployment state storage providers.
- *
- * Implementations must handle:
- * - Reading state for a stage (returns null if not found)
- * - Writing state for a stage (creates or updates)
- */
-export interface StateProvider {
-	/**
-	 * Read deployment state for a stage.
-	 *
-	 * @param stage - The deployment stage (e.g., 'development', 'production')
-	 * @returns The state object or null if not found
-	 */
-	read(stage: string): Promise<DokployStageState | null>;
-
-	/**
-	 * Write deployment state for a stage.
-	 *
-	 * @param stage - The deployment stage
-	 * @param state - The state object to persist
-	 */
-	write(stage: string, state: DokployStageState): Promise<void>;
-}
-
-/**
- * Valid AWS regions.
- */
-export type AwsRegion =
-	| 'us-east-1'
-	| 'us-east-2'
-	| 'us-west-1'
-	| 'us-west-2'
-	| 'af-south-1'
-	| 'ap-east-1'
-	| 'ap-south-1'
-	| 'ap-south-2'
-	| 'ap-southeast-1'
-	| 'ap-southeast-2'
-	| 'ap-southeast-3'
-	| 'ap-southeast-4'
-	| 'ap-northeast-1'
-	| 'ap-northeast-2'
-	| 'ap-northeast-3'
-	| 'ca-central-1'
-	| 'eu-central-1'
-	| 'eu-central-2'
-	| 'eu-west-1'
-	| 'eu-west-2'
-	| 'eu-west-3'
-	| 'eu-south-1'
-	| 'eu-south-2'
-	| 'eu-north-1'
-	| 'me-south-1'
-	| 'me-central-1'
-	| 'sa-east-1';
-
-/**
- * Local state provider config.
- */
-export interface LocalStateConfig {
-	provider: 'local';
-}
-
-/**
- * SSM state provider config (requires region).
- */
-export interface SSMStateConfig {
-	provider: 'ssm';
-	/** AWS region (required for SSM provider) */
-	region: AwsRegion;
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile?: string;
-}
-
-/**
- * Custom state provider config.
- */
-export interface CustomStateConfig {
-	/** Custom StateProvider implementation */
-	provider: StateProvider;
-}
-
-/**
- * State configuration types.
- */
-export type StateConfig = LocalStateConfig | SSMStateConfig | CustomStateConfig;
-
-/**
- * Check if value is a StateProvider implementation.
- */
-export function isStateProvider(value: unknown): value is StateProvider {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		typeof (value as StateProvider).read === 'function' &&
-		typeof (value as StateProvider).write === 'function'
-	);
-}
-
-export interface CreateStateProviderOptions {
-	/** State config from workspace */
-	config?: StateConfig;
-	/** Workspace root directory (for local provider) */
-	workspaceRoot: string;
-	/** Workspace name (for SSM parameter path) */
-	workspaceName: string;
-}
-
-/**
- * Create a state provider based on configuration.
- *
- * - 'local': LocalStateProvider (default)
- * - 'ssm': CachedStateProvider with SSM as source of truth
- * - Custom: Use provided StateProvider implementation
- */
-export async function createStateProvider(
-	options: CreateStateProviderOptions,
-): Promise<StateProvider> {
-	const { config, workspaceRoot, workspaceName } = options;
-
-	// Default to local provider if no config
-	if (!config) {
-		const { LocalStateProvider } = await import('./LocalStateProvider');
-		return new LocalStateProvider(workspaceRoot);
-	}
-
-	// Custom provider implementation
-	if (isStateProvider(config.provider)) {
-		return config.provider;
-	}
-
-	// Built-in providers (discriminated by provider string)
-	const provider = config.provider;
-
-	if (provider === 'local') {
-		const { LocalStateProvider } = await import('./LocalStateProvider');
-		return new LocalStateProvider(workspaceRoot);
-	}
-
-	if (provider === 'ssm') {
-		if (!workspaceName) {
-			throw new Error(
-				'Workspace name is required for SSM state provider. Set "name" in gkm.config.ts.',
-			);
-		}
-
-		const { LocalStateProvider } = await import('./LocalStateProvider');
-		const { SSMStateProvider } = await import('./SSMStateProvider');
-		const { CachedStateProvider } = await import('./CachedStateProvider');
-
-		const ssmConfig = config as SSMStateConfig;
-		const local = new LocalStateProvider(workspaceRoot);
-		const ssm = SSMStateProvider.create({
-			workspaceName,
-			region: ssmConfig.region,
-			profile: ssmConfig.profile,
-		});
-
-		return new CachedStateProvider(ssm, local);
-	}
-
-	// Should never reach here - custom providers handled above
-	throw new Error(`Unknown state provider: ${JSON.stringify(config)}`);
-}