@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/deploy/backup-provisioner.ts

@@ -1,316 +0,0 @@
-/**
- * Backup Destination Provisioner
- *
- * Creates AWS resources (S3 bucket, IAM user, access keys) and configures
- * Dokploy backup destinations for database backups.
- */
-
-import {
-	CreateAccessKeyCommand,
-	CreateUserCommand,
-	GetUserCommand,
-	IAMClient,
-	type IAMClientConfig,
-	PutUserPolicyCommand,
-} from '@aws-sdk/client-iam';
-import {
-	type BucketLocationConstraint,
-	CreateBucketCommand,
-	HeadBucketCommand,
-	PutBucketVersioningCommand,
-	S3Client,
-	type S3ClientConfig,
-} from '@aws-sdk/client-s3';
-import type { BackupsConfig } from '../workspace/types.js';
-import type { DokployApi } from './dokploy-api.js';
-import type { BackupState } from './state.js';
-
-export interface ProvisionBackupOptions {
-	/** Dokploy API client */
-	api: DokployApi;
-	/** Dokploy project ID */
-	projectId: string;
-	/** Workspace name (used for resource naming) */
-	projectName: string;
-	/** Deploy stage (e.g., 'production', 'staging') */
-	stage: string;
-	/** Backup configuration */
-	config: BackupsConfig;
-	/** Existing backup state (if any) */
-	existingState?: BackupState;
-	/** Logger for progress output */
-	logger: { log: (msg: string) => void };
-	/** AWS endpoint override (for testing with LocalStack) */
-	awsEndpoint?: string;
-}
-
-/**
- * Generate a random suffix for unique resource names
- */
-function randomSuffix(): string {
-	return Math.random().toString(36).substring(2, 8);
-}
-
-/**
- * Sanitize a name for AWS resources (lowercase alphanumeric and hyphens)
- */
-function sanitizeName(name: string): string {
-	return name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-}
-
-/**
- * Create AWS clients with optional profile credentials
- */
-async function createAwsClients(
-	region: string,
-	profile?: string,
-	endpoint?: string,
-): Promise<{ s3: S3Client; iam: IAMClient }> {
-	const config: S3ClientConfig & IAMClientConfig = { region };
-
-	if (profile) {
-		const { fromIni } = await import('@aws-sdk/credential-providers');
-		config.credentials = fromIni({ profile });
-	}
-
-	// Support custom endpoint for testing (e.g., LocalStack)
-	if (endpoint) {
-		config.endpoint = endpoint;
-		(config as S3ClientConfig).forcePathStyle = true;
-		// Use test credentials when endpoint is specified
-		config.credentials = {
-			accessKeyId: 'test',
-			secretAccessKey: 'test',
-		};
-	}
-
-	return {
-		s3: new S3Client(config),
-		iam: new IAMClient(config),
-	};
-}
-
-/**
- * Check if an S3 bucket exists
- */
-async function bucketExists(
-	s3: S3Client,
-	bucketName: string,
-): Promise<boolean> {
-	try {
-		await s3.send(new HeadBucketCommand({ Bucket: bucketName }));
-		return true;
-	} catch (error) {
-		if ((error as { name?: string }).name === 'NotFound') {
-			return false;
-		}
-		// 403 means bucket exists but we don't have access
-		if (
-			(error as { $metadata?: { httpStatusCode?: number } }).$metadata
-				?.httpStatusCode === 403
-		) {
-			return true;
-		}
-		throw error;
-	}
-}
-
-/**
- * Check if an IAM user exists
- */
-async function userExists(iam: IAMClient, userName: string): Promise<boolean> {
-	try {
-		await iam.send(new GetUserCommand({ UserName: userName }));
-		return true;
-	} catch (error) {
-		const errorName = (error as { name?: string }).name;
-		// AWS returns 'NoSuchEntity', LocalStack returns 'NoSuchEntityException'
-		if (errorName === 'NoSuchEntity' || errorName === 'NoSuchEntityException') {
-			return false;
-		}
-		throw error;
-	}
-}
-
-/**
- * Provision backup destination for a deployment.
- *
- * Creates AWS resources (S3 bucket, IAM user) and Dokploy destination if needed.
- * Reuses existing resources from state when possible.
- */
-export async function provisionBackupDestination(
-	options: ProvisionBackupOptions,
-): Promise<BackupState> {
-	const {
-		api,
-		projectName,
-		stage,
-		config,
-		existingState,
-		logger,
-		awsEndpoint,
-	} = options;
-
-	// If we have existing state, verify the Dokploy destination still exists
-	if (existingState?.destinationId) {
-		try {
-			await api.getDestination(existingState.destinationId);
-			logger.log('   Using existing backup destination');
-			return existingState;
-		} catch {
-			logger.log('   Existing destination not found, recreating...');
-		}
-	}
-
-	// Create AWS clients
-	const aws = await createAwsClients(
-		config.region,
-		config.profile,
-		awsEndpoint,
-	);
-	const sanitizedProject = sanitizeName(projectName);
-
-	// 1. Create or verify S3 bucket
-	const bucketName =
-		existingState?.bucketName ??
-		`${sanitizedProject}-${stage}-backups-${randomSuffix()}`;
-
-	const bucketAlreadyExists = await bucketExists(aws.s3, bucketName);
-	if (!bucketAlreadyExists) {
-		logger.log(`   Creating S3 bucket: ${bucketName}`);
-
-		// CreateBucket needs LocationConstraint for non-us-east-1 regions
-		const createBucketParams: {
-			Bucket: string;
-			CreateBucketConfiguration?: {
-				LocationConstraint: BucketLocationConstraint;
-			};
-		} = {
-			Bucket: bucketName,
-		};
-		if (config.region !== 'us-east-1') {
-			createBucketParams.CreateBucketConfiguration = {
-				LocationConstraint: config.region as BucketLocationConstraint,
-			};
-		}
-
-		await aws.s3.send(new CreateBucketCommand(createBucketParams));
-
-		// Enable versioning for backup integrity
-		await aws.s3.send(
-			new PutBucketVersioningCommand({
-				Bucket: bucketName,
-				VersioningConfiguration: { Status: 'Enabled' },
-			}),
-		);
-	} else {
-		logger.log(`   Using existing S3 bucket: ${bucketName}`);
-	}
-
-	// 2. Create or verify IAM user
-	const iamUserName =
-		existingState?.iamUserName ?? `dokploy-backup-${sanitizedProject}-${stage}`;
-
-	const iamUserAlreadyExists = await userExists(aws.iam, iamUserName);
-	if (!iamUserAlreadyExists) {
-		logger.log(`   Creating IAM user: ${iamUserName}`);
-		await aws.iam.send(new CreateUserCommand({ UserName: iamUserName }));
-	} else {
-		logger.log(`   Using existing IAM user: ${iamUserName}`);
-	}
-
-	// 3. Attach bucket policy to IAM user
-	const policyDocument = {
-		Version: '2012-10-17',
-		Statement: [
-			{
-				Effect: 'Allow',
-				Action: [
-					's3:GetObject',
-					's3:PutObject',
-					's3:DeleteObject',
-					's3:ListBucket',
-					's3:GetBucketLocation',
-				],
-				Resource: [
-					`arn:aws:s3:::${bucketName}`,
-					`arn:aws:s3:::${bucketName}/*`,
-				],
-			},
-		],
-	};
-
-	logger.log('   Updating IAM policy');
-	await aws.iam.send(
-		new PutUserPolicyCommand({
-			UserName: iamUserName,
-			PolicyName: 'DokployBackupAccess',
-			PolicyDocument: JSON.stringify(policyDocument),
-		}),
-	);
-
-	// 4. Create access key (or reuse existing if state has it and destination needs recreation)
-	let accessKeyId: string;
-	let secretAccessKey: string;
-
-	if (existingState?.iamAccessKeyId && existingState?.iamSecretAccessKey) {
-		// Reuse existing credentials
-		logger.log('   Using existing IAM access key');
-		accessKeyId = existingState.iamAccessKeyId;
-		secretAccessKey = existingState.iamSecretAccessKey;
-	} else {
-		// Create new access key
-		logger.log('   Creating IAM access key');
-		const accessKeyResult = await aws.iam.send(
-			new CreateAccessKeyCommand({ UserName: iamUserName }),
-		);
-
-		if (!accessKeyResult.AccessKey) {
-			throw new Error('Failed to create IAM access key');
-		}
-
-		accessKeyId = accessKeyResult.AccessKey.AccessKeyId!;
-		secretAccessKey = accessKeyResult.AccessKey.SecretAccessKey!;
-	}
-
-	// 5. Create Dokploy destination
-	const destinationName = `${sanitizedProject}-${stage}-s3`;
-	logger.log(`   Creating Dokploy destination: ${destinationName}`);
-
-	const { destination, created } = await api.findOrCreateDestination(
-		destinationName,
-		{
-			accessKey: accessKeyId,
-			secretAccessKey: secretAccessKey,
-			bucket: bucketName,
-			region: config.region,
-		},
-	);
-
-	if (created) {
-		logger.log('   ✓ Dokploy destination created');
-	} else {
-		logger.log('   ✓ Using existing Dokploy destination');
-	}
-
-	// 6. Test connection
-	try {
-		await api.testDestinationConnection(destination.destinationId);
-		logger.log('   ✓ Destination connection verified');
-	} catch (error) {
-		logger.log(
-			`   ⚠ Warning: Could not verify destination connection: ${error}`,
-		);
-	}
-
-	return {
-		bucketName,
-		bucketArn: `arn:aws:s3:::${bucketName}`,
-		iamUserName,
-		iamAccessKeyId: accessKeyId,
-		iamSecretAccessKey: secretAccessKey,
-		destinationId: destination.destinationId,
-		region: config.region,
-		createdAt: existingState?.createdAt ?? new Date().toISOString(),
-	};
-}

package/src/deploy/dns/DnsProvider.ts

@@ -1,201 +0,0 @@
-/**
- * DNS Provider Interface
- *
- * Abstracts DNS operations for different providers.
- * Built-in providers: HostingerProvider, Route53Provider
- * Users can also supply custom implementations.
- */
-
-import type { z } from 'zod/v4';
-import type {
-	CloudflareDnsProviderSchema,
-	CustomDnsProviderSchema,
-	DnsProviderSchema,
-	DnsRecordSchema,
-	DnsRecordTypeSchema,
-	HostingerDnsProviderSchema,
-	ManualDnsProviderSchema,
-	Route53DnsProviderSchema,
-	UpsertDnsRecordSchema,
-	UpsertResultSchema,
-} from '../../workspace/schema';
-
-// =============================================================================
-// DNS Record Types (derived from Zod schemas)
-// =============================================================================
-
-/**
- * DNS record types supported across providers.
- */
-export type DnsRecordType = z.infer<typeof DnsRecordTypeSchema>;
-
-/**
- * A DNS record as returned by the provider.
- */
-export type DnsRecord = z.infer<typeof DnsRecordSchema>;
-
-/**
- * A DNS record to create or update.
- */
-export type UpsertDnsRecord = z.infer<typeof UpsertDnsRecordSchema>;
-
-/**
- * Result of an upsert operation.
- */
-export type UpsertResult = z.infer<typeof UpsertResultSchema>;
-
-// =============================================================================
-// DNS Provider Interface
-// =============================================================================
-
-/**
- * A record to delete from DNS.
- */
-export interface DeleteDnsRecord {
-	/** Record name/subdomain (e.g., 'api' or '@' for root) */
-	name: string;
-	/** Record type (A, CNAME, etc.) */
-	type: DnsRecordType;
-}
-
-/**
- * Result of a delete operation.
- */
-export interface DeleteResult {
-	/** The record that was requested for deletion */
-	record: DeleteDnsRecord;
-	/** Whether the record was deleted */
-	deleted: boolean;
-	/** Whether the record was not found (already deleted) */
-	notFound: boolean;
-	/** Error message if deletion failed */
-	error?: string;
-}
-
-/**
- * Interface for DNS providers.
- *
- * Implementations must handle:
- * - Getting all records for a domain
- * - Creating or updating records for a domain
- * - Deleting records from a domain
- */
-export interface DnsProvider {
-	/** Provider name for logging */
-	readonly name: string;
-
-	/**
-	 * Get all DNS records for a domain.
-	 *
-	 * @param domain - Root domain (e.g., 'example.com')
-	 * @returns Array of DNS records
-	 */
-	getRecords(domain: string): Promise<DnsRecord[]>;
-
-	/**
-	 * Create or update DNS records.
-	 *
-	 * @param domain - Root domain (e.g., 'example.com')
-	 * @param records - Records to create or update
-	 * @returns Results of the upsert operations
-	 */
-	upsertRecords(
-		domain: string,
-		records: UpsertDnsRecord[],
-	): Promise<UpsertResult[]>;
-
-	/**
-	 * Delete DNS records.
-	 *
-	 * @param domain - Root domain (e.g., 'example.com')
-	 * @param records - Records to delete
-	 * @returns Results of the delete operations
-	 */
-	deleteRecords(
-		domain: string,
-		records: DeleteDnsRecord[],
-	): Promise<DeleteResult[]>;
-}
-
-// =============================================================================
-// DNS Provider Config Types (derived from Zod schemas)
-// =============================================================================
-
-export type HostingerDnsConfig = z.infer<typeof HostingerDnsProviderSchema>;
-export type Route53DnsConfig = z.infer<typeof Route53DnsProviderSchema>;
-export type CloudflareDnsConfig = z.infer<typeof CloudflareDnsProviderSchema>;
-export type ManualDnsConfig = z.infer<typeof ManualDnsProviderSchema>;
-export type CustomDnsConfig = z.infer<typeof CustomDnsProviderSchema>;
-/** Single DNS provider config (for one domain) */
-export type DnsConfig = z.infer<typeof DnsProviderSchema>;
-
-// =============================================================================
-// DNS Provider Factory
-// =============================================================================
-
-/**
- * Check if value is a DnsProvider implementation.
- */
-export function isDnsProvider(value: unknown): value is DnsProvider {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		typeof (value as DnsProvider).name === 'string' &&
-		typeof (value as DnsProvider).getRecords === 'function' &&
-		typeof (value as DnsProvider).upsertRecords === 'function' &&
-		typeof (value as DnsProvider).deleteRecords === 'function'
-	);
-}
-
-export interface CreateDnsProviderOptions {
-	/** DNS config from workspace */
-	config: DnsConfig;
-}
-
-/**
- * Create a DNS provider based on configuration.
- *
- * - 'hostinger': HostingerProvider
- * - 'route53': Route53Provider
- * - 'manual': Returns null (user handles DNS)
- * - Custom: Use provided DnsProvider implementation
- */
-export async function createDnsProvider(
-	options: CreateDnsProviderOptions,
-): Promise<DnsProvider | null> {
-	const { config } = options;
-
-	// Manual mode - no provider needed
-	if (config.provider === 'manual') {
-		return null;
-	}
-
-	// Custom provider implementation
-	if (isDnsProvider(config.provider)) {
-		return config.provider;
-	}
-
-	// Built-in providers
-	const provider = config.provider;
-
-	if (provider === 'hostinger') {
-		const { HostingerProvider } = await import('./HostingerProvider');
-		return new HostingerProvider();
-	}
-
-	if (provider === 'route53') {
-		const { Route53Provider } = await import('./Route53Provider');
-		const route53Config = config as Route53DnsConfig;
-		return new Route53Provider({
-			region: route53Config.region,
-			profile: route53Config.profile,
-			hostedZoneId: route53Config.hostedZoneId,
-		});
-	}
-
-	if (provider === 'cloudflare') {
-		throw new Error('Cloudflare DNS provider not yet implemented');
-	}
-
-	throw new Error(`Unknown DNS provider: ${JSON.stringify(config)}`);
-}

package/src/deploy/dns/HostingerProvider.ts

@@ -1,174 +0,0 @@
-/**
- * Hostinger DNS Provider
- *
- * Implements DnsProvider interface using the Hostinger DNS API.
- */
-
-import { getHostingerToken } from '../../auth/credentials';
-import type {
-	DeleteDnsRecord,
-	DeleteResult,
-	DnsProvider,
-	DnsRecord,
-	UpsertDnsRecord,
-	UpsertResult,
-} from './DnsProvider';
-import { HostingerApi } from './hostinger-api';
-
-/**
- * Hostinger DNS provider implementation.
- */
-export class HostingerProvider implements DnsProvider {
-	readonly name = 'hostinger';
-	private api: HostingerApi | null = null;
-
-	/**
-	 * Get or create the Hostinger API client.
-	 */
-	private async getApi(): Promise<HostingerApi> {
-		if (this.api) {
-			return this.api;
-		}
-
-		const token = await getHostingerToken();
-		if (!token) {
-			throw new Error(
-				'Hostinger API token not configured. Run `gkm login --service=hostinger` or get your token from https://hpanel.hostinger.com/profile/api',
-			);
-		}
-
-		this.api = new HostingerApi(token);
-		return this.api;
-	}
-
-	async getRecords(domain: string): Promise<DnsRecord[]> {
-		const api = await this.getApi();
-		const records = await api.getRecords(domain);
-
-		return records.map((r) => ({
-			name: r.name,
-			type: r.type,
-			ttl: r.ttl,
-			values: r.records.map((rec) => rec.content),
-		}));
-	}
-
-	async upsertRecords(
-		domain: string,
-		records: UpsertDnsRecord[],
-	): Promise<UpsertResult[]> {
-		const api = await this.getApi();
-		const results: UpsertResult[] = [];
-
-		// Get existing records to check what already exists
-		const existingRecords = await api.getRecords(domain);
-
-		for (const record of records) {
-			const existing = existingRecords.find(
-				(r) => r.name === record.name && r.type === record.type,
-			);
-
-			const existingValue = existing?.records?.[0]?.content;
-
-			if (existing && existingValue === record.value) {
-				// Record exists with same value - unchanged
-				results.push({
-					record,
-					created: false,
-					unchanged: true,
-				});
-				continue;
-			}
-
-			// Create or update the record
-			await api.upsertRecords(domain, [
-				{
-					name: record.name,
-					type: record.type,
-					ttl: record.ttl,
-					records: [{ content: record.value }],
-				},
-			]);
-
-			results.push({
-				record,
-				created: !existing,
-				unchanged: false,
-			});
-		}
-
-		return results;
-	}
-
-	async deleteRecords(
-		domain: string,
-		records: DeleteDnsRecord[],
-	): Promise<DeleteResult[]> {
-		const api = await this.getApi();
-		const results: DeleteResult[] = [];
-
-		// Get existing records to check what exists
-		const existingRecords = await api.getRecords(domain);
-
-		// Filter to only records that exist
-		const recordsToDelete = records.filter((record) =>
-			existingRecords.some(
-				(r) => r.name === record.name && r.type === record.type,
-			),
-		);
-
-		// Delete existing records
-		if (recordsToDelete.length > 0) {
-			try {
-				await api.deleteRecords(
-					domain,
-					recordsToDelete.map((r) => ({
-						name: r.name,
-						type: r.type as
-							| 'A'
-							| 'AAAA'
-							| 'CNAME'
-							| 'MX'
-							| 'TXT'
-							| 'SRV'
-							| 'CAA',
-					})),
-				);
-
-				for (const record of recordsToDelete) {
-					results.push({
-						record,
-						deleted: true,
-						notFound: false,
-					});
-				}
-			} catch (error) {
-				// If batch delete fails, report error for all records
-				for (const record of recordsToDelete) {
-					results.push({
-						record,
-						deleted: false,
-						notFound: false,
-						error: String(error),
-					});
-				}
-			}
-		}
-
-		// Mark non-existent records as not found
-		for (const record of records) {
-			const existing = existingRecords.find(
-				(r) => r.name === record.name && r.type === record.type,
-			);
-			if (!existing) {
-				results.push({
-					record,
-					deleted: false,
-					notFound: true,
-				});
-			}
-		}
-
-		return results;
-	}
-}