@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

package/src/deploy/dns/Route53Provider.ts

@@ -1,340 +0,0 @@
-/**
- * Route53 DNS Provider
- *
- * Implements DnsProvider interface using AWS Route53.
- */
-
-import {
-	ChangeResourceRecordSetsCommand,
-	ListHostedZonesByNameCommand,
-	ListResourceRecordSetsCommand,
-	Route53Client,
-	type RRType,
-} from '@aws-sdk/client-route-53';
-import { fromIni } from '@aws-sdk/credential-providers';
-import type {
-	DeleteDnsRecord,
-	DeleteResult,
-	DnsProvider,
-	DnsRecord,
-	DnsRecordType,
-	UpsertDnsRecord,
-	UpsertResult,
-} from './DnsProvider';
-
-export interface Route53ProviderOptions {
-	/** AWS region (optional - uses AWS_REGION env var if not provided) */
-	region?: string;
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile?: string;
-	/** Hosted zone ID (optional - auto-detected from domain if not provided) */
-	hostedZoneId?: string;
-	/** Custom endpoint for testing with localstack */
-	endpoint?: string;
-}
-
-/**
- * Route53 DNS provider implementation.
- *
- * Uses AWS default credential chain for authentication.
- * Region can be specified or will use AWS_REGION/AWS_DEFAULT_REGION env vars.
- * Profile can be specified to use a named profile from ~/.aws/credentials.
- */
-export class Route53Provider implements DnsProvider {
-	readonly name = 'route53';
-	private client: Route53Client;
-	private hostedZoneId?: string;
-	private hostedZoneCache: Map<string, string> = new Map();
-
-	constructor(options: Route53ProviderOptions = {}) {
-		// Route53 is a global service, default to us-east-1 if no region specified
-		const region = options.region ?? process.env.AWS_REGION ?? 'us-east-1';
-
-		this.client = new Route53Client({
-			region,
-			...(options.endpoint && { endpoint: options.endpoint }),
-			...(options.profile && {
-				credentials: fromIni({ profile: options.profile }),
-			}),
-		});
-		this.hostedZoneId = options.hostedZoneId;
-	}
-
-	/**
-	 * Get the hosted zone ID for a domain.
-	 * Uses cache to avoid repeated API calls.
-	 */
-	private async getHostedZoneId(domain: string): Promise<string> {
-		// Use configured zone ID if provided
-		if (this.hostedZoneId) {
-			return this.hostedZoneId;
-		}
-
-		// Check cache
-		if (this.hostedZoneCache.has(domain)) {
-			return this.hostedZoneCache.get(domain)!;
-		}
-
-		// Auto-detect from domain
-		const command = new ListHostedZonesByNameCommand({
-			DNSName: domain,
-			MaxItems: 1,
-		});
-
-		const response = await this.client.send(command);
-		const zones = response.HostedZones ?? [];
-
-		// Find exact match (domain with trailing dot)
-		const normalizedDomain = domain.endsWith('.') ? domain : `${domain}.`;
-		const zone = zones.find((z) => z.Name === normalizedDomain);
-
-		if (!zone?.Id) {
-			throw new Error(
-				`No hosted zone found for domain: ${domain}. Create one in Route53 or provide hostedZoneId in config.`,
-			);
-		}
-
-		// Zone ID comes as "/hostedzone/Z1234567890" - extract just the ID
-		const zoneId = zone.Id.replace('/hostedzone/', '');
-		this.hostedZoneCache.set(domain, zoneId);
-		return zoneId;
-	}
-
-	/**
-	 * Convert Route53 record type to our DnsRecordType.
-	 * Excludes NS and SOA which are auto-managed by Route53 for the zone.
-	 */
-	private toRecordType(type: string): DnsRecordType | null {
-		// Exclude NS and SOA which are auto-managed zone records
-		const managedTypes = ['NS', 'SOA'];
-		if (managedTypes.includes(type)) {
-			return null;
-		}
-
-		const validTypes: DnsRecordType[] = [
-			'A',
-			'AAAA',
-			'CNAME',
-			'MX',
-			'TXT',
-			'SRV',
-			'CAA',
-		];
-		return validTypes.includes(type as DnsRecordType)
-			? (type as DnsRecordType)
-			: null;
-	}
-
-	/**
-	 * Extract subdomain from full record name relative to domain.
-	 */
-	private extractSubdomain(recordName: string, domain: string): string {
-		const normalizedDomain = domain.endsWith('.') ? domain : `${domain}.`;
-		const normalizedName = recordName.endsWith('.')
-			? recordName
-			: `${recordName}.`;
-
-		if (normalizedName === normalizedDomain) {
-			return '@';
-		}
-
-		// Remove the domain suffix
-		const subdomain = normalizedName.replace(`.${normalizedDomain}`, '');
-		return subdomain.replace(/\.$/, ''); // Remove trailing dot if any
-	}
-
-	async getRecords(domain: string): Promise<DnsRecord[]> {
-		const zoneId = await this.getHostedZoneId(domain);
-		const records: DnsRecord[] = [];
-
-		let nextRecordName: string | undefined;
-		let nextRecordType: RRType | undefined;
-
-		// Paginate through all records
-		do {
-			const command = new ListResourceRecordSetsCommand({
-				HostedZoneId: zoneId,
-				StartRecordName: nextRecordName,
-				StartRecordType: nextRecordType,
-				MaxItems: 100,
-			});
-
-			const response = await this.client.send(command);
-
-			for (const recordSet of response.ResourceRecordSets ?? []) {
-				const type = this.toRecordType(recordSet.Type ?? '');
-				if (!type || !recordSet.Name) continue;
-
-				const values = (recordSet.ResourceRecords ?? [])
-					.map((r) => r.Value)
-					.filter((v): v is string => !!v);
-
-				records.push({
-					name: this.extractSubdomain(recordSet.Name, domain),
-					type,
-					ttl: recordSet.TTL ?? 300,
-					values,
-				});
-			}
-
-			if (response.IsTruncated) {
-				nextRecordName = response.NextRecordName;
-				nextRecordType = response.NextRecordType;
-			} else {
-				nextRecordName = undefined;
-			}
-		} while (nextRecordName);
-
-		return records;
-	}
-
-	async upsertRecords(
-		domain: string,
-		records: UpsertDnsRecord[],
-	): Promise<UpsertResult[]> {
-		const zoneId = await this.getHostedZoneId(domain);
-		const results: UpsertResult[] = [];
-
-		// Get existing records to determine if creating or updating
-		const existingRecords = await this.getRecords(domain);
-
-		// Process records in batches (Route53 allows max 1000 changes per request)
-		const batchSize = 100;
-		for (let i = 0; i < records.length; i += batchSize) {
-			const batch = records.slice(i, i + batchSize);
-			const changes = [];
-
-			for (const record of batch) {
-				const existing = existingRecords.find(
-					(r) => r.name === record.name && r.type === record.type,
-				);
-
-				const existingValue = existing?.values?.[0];
-
-				if (existing && existingValue === record.value) {
-					// Record exists with same value - unchanged
-					results.push({
-						record,
-						created: false,
-						unchanged: true,
-					});
-					continue;
-				}
-
-				// Build full record name
-				const recordName =
-					record.name === '@' ? domain : `${record.name}.${domain}`;
-
-				changes.push({
-					Action: 'UPSERT' as const,
-					ResourceRecordSet: {
-						Name: recordName,
-						Type: record.type,
-						TTL: record.ttl,
-						ResourceRecords: [{ Value: record.value }],
-					},
-				});
-
-				results.push({
-					record,
-					created: !existing,
-					unchanged: false,
-				});
-			}
-
-			// Execute batch if there are changes
-			if (changes.length > 0) {
-				const command = new ChangeResourceRecordSetsCommand({
-					HostedZoneId: zoneId,
-					ChangeBatch: {
-						Comment: 'Upsert by gkm deploy',
-						Changes: changes,
-					},
-				});
-
-				await this.client.send(command);
-			}
-		}
-
-		return results;
-	}
-
-	async deleteRecords(
-		domain: string,
-		records: DeleteDnsRecord[],
-	): Promise<DeleteResult[]> {
-		const zoneId = await this.getHostedZoneId(domain);
-		const results: DeleteResult[] = [];
-
-		// Get existing records to find the ones to delete
-		const existingRecords = await this.getRecords(domain);
-
-		// Process records in batches (Route53 allows max 1000 changes per request)
-		const batchSize = 100;
-		for (let i = 0; i < records.length; i += batchSize) {
-			const batch = records.slice(i, i + batchSize);
-			const changes = [];
-
-			for (const record of batch) {
-				const existing = existingRecords.find(
-					(r) => r.name === record.name && r.type === record.type,
-				);
-
-				if (!existing) {
-					// Record doesn't exist - already deleted
-					results.push({
-						record,
-						deleted: false,
-						notFound: true,
-					});
-					continue;
-				}
-
-				// Build full record name
-				const recordName =
-					record.name === '@' ? domain : `${record.name}.${domain}`;
-
-				changes.push({
-					Action: 'DELETE' as const,
-					ResourceRecordSet: {
-						Name: recordName,
-						Type: record.type,
-						TTL: existing.ttl,
-						ResourceRecords: existing.values.map((v) => ({ Value: v })),
-					},
-				});
-
-				results.push({
-					record,
-					deleted: true,
-					notFound: false,
-				});
-			}
-
-			// Execute batch if there are changes
-			if (changes.length > 0) {
-				try {
-					const command = new ChangeResourceRecordSetsCommand({
-						HostedZoneId: zoneId,
-						ChangeBatch: {
-							Comment: 'Delete by gkm undeploy',
-							Changes: changes,
-						},
-					});
-
-					await this.client.send(command);
-				} catch (error) {
-					// Mark all records in this batch as failed
-					for (const result of results.slice(-changes.length)) {
-						if (result.deleted) {
-							result.deleted = false;
-							result.error = String(error);
-						}
-					}
-				}
-			}
-		}
-
-		return results;
-	}
-}

package/src/deploy/dns/hostinger-api.ts

@@ -1,261 +0,0 @@
-/**
- * Hostinger DNS API client
- *
- * API Documentation: https://developers.hostinger.com/
- * Authentication: Bearer token from hpanel.hostinger.com/profile/api
- */
-
-const HOSTINGER_API_BASE = 'https://developers.hostinger.com';
-
-/**
- * DNS record types supported by Hostinger
- */
-export type DnsRecordType =
-	| 'A'
-	| 'AAAA'
-	| 'CNAME'
-	| 'MX'
-	| 'TXT'
-	| 'NS'
-	| 'SRV'
-	| 'CAA';
-
-/**
- * A single DNS record
- */
-export interface DnsRecord {
-	/** Subdomain name (e.g., 'api.joemoer' for api.joemoer.traflabs.io) */
-	name: string;
-	/** Record type */
-	type: DnsRecordType;
-	/** TTL in seconds */
-	ttl: number;
-	/** Record values */
-	records: Array<{ content: string }>;
-}
-
-/**
- * Filter for deleting specific records
- */
-export interface DnsRecordFilter {
-	name: string;
-	type: DnsRecordType;
-}
-
-/**
- * API error response
- */
-export interface HostingerErrorResponse {
-	message?: string;
-	errors?: Record<string, string[]>;
-}
-
-/**
- * Hostinger API error
- */
-export class HostingerApiError extends Error {
-	constructor(
-		message: string,
-		public status: number,
-		public statusText: string,
-		public errors?: Record<string, string[]>,
-	) {
-		super(message);
-		this.name = 'HostingerApiError';
-	}
-}
-
-/**
- * Hostinger DNS API client
- *
- * @example
- * ```ts
- * const api = new HostingerApi(token);
- *
- * // Get all records for a domain
- * const records = await api.getRecords('traflabs.io');
- *
- * // Create/update records
- * await api.upsertRecords('traflabs.io', [
- *   { name: 'api.joemoer', type: 'A', ttl: 300, records: ['1.2.3.4'] }
- * ]);
- * ```
- */
-export class HostingerApi {
-	private token: string;
-
-	constructor(token: string) {
-		this.token = token;
-	}
-
-	/**
-	 * Make a request to the Hostinger API
-	 */
-	private async request<T>(
-		method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-		endpoint: string,
-		body?: unknown,
-	): Promise<T> {
-		const url = `${HOSTINGER_API_BASE}${endpoint}`;
-
-		const response = await fetch(url, {
-			method,
-			headers: {
-				'Content-Type': 'application/json',
-				Authorization: `Bearer ${this.token}`,
-			},
-			body: body ? JSON.stringify(body) : undefined,
-		});
-
-		if (!response.ok) {
-			let errorMessage = `Hostinger API error: ${response.status} ${response.statusText}`;
-			let errors: Record<string, string[]> | undefined;
-
-			try {
-				const errorBody = (await response.json()) as HostingerErrorResponse;
-				if (errorBody.message) {
-					errorMessage = `Hostinger API error: ${errorBody.message}`;
-				}
-				errors = errorBody.errors;
-			} catch {
-				// Ignore JSON parse errors
-			}
-
-			throw new HostingerApiError(
-				errorMessage,
-				response.status,
-				response.statusText,
-				errors,
-			);
-		}
-
-		// Handle empty responses
-		const text = await response.text();
-		if (!text || text.trim() === '') {
-			return undefined as T;
-		}
-		return JSON.parse(text) as T;
-	}
-
-	/**
-	 * Get all DNS records for a domain
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 */
-	async getRecords(domain: string): Promise<DnsRecord[]> {
-		interface RecordResponse {
-			data: Array<{
-				name: string;
-				type: DnsRecordType;
-				ttl: number;
-				records: Array<{ content: string }>;
-			}>;
-		}
-
-		const response = await this.request<RecordResponse>(
-			'GET',
-			`/api/dns/v1/zones/${domain}`,
-		);
-
-		return response.data || [];
-	}
-
-	/**
-	 * Create or update DNS records
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 * @param records - Records to create/update
-	 * @param overwrite - If true, replaces all existing records. If false, merges with existing.
-	 */
-	async upsertRecords(
-		domain: string,
-		records: DnsRecord[],
-		overwrite = false,
-	): Promise<void> {
-		await this.request('PUT', `/api/dns/v1/zones/${domain}`, {
-			overwrite,
-			zone: records,
-		});
-	}
-
-	/**
-	 * Validate DNS records before applying
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 * @param records - Records to validate
-	 * @returns true if valid, throws if invalid
-	 */
-	async validateRecords(
-		domain: string,
-		records: DnsRecord[],
-	): Promise<boolean> {
-		await this.request('POST', `/api/dns/v1/zones/${domain}/validate`, {
-			overwrite: false,
-			zone: records,
-		});
-		return true;
-	}
-
-	/**
-	 * Delete specific DNS records
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 * @param filters - Filters to match records for deletion
-	 */
-	async deleteRecords(
-		domain: string,
-		filters: DnsRecordFilter[],
-	): Promise<void> {
-		await this.request('DELETE', `/api/dns/v1/zones/${domain}`, {
-			filters,
-		});
-	}
-
-	/**
-	 * Check if a specific record exists
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 * @param name - Subdomain name (e.g., 'api.joemoer')
-	 * @param type - Record type (e.g., 'A')
-	 */
-	async recordExists(
-		domain: string,
-		name: string,
-		type: DnsRecordType = 'A',
-	): Promise<boolean> {
-		const records = await this.getRecords(domain);
-		return records.some((r) => r.name === name && r.type === type);
-	}
-
-	/**
-	 * Create a single A record if it doesn't exist
-	 *
-	 * @param domain - Root domain (e.g., 'traflabs.io')
-	 * @param subdomain - Subdomain name (e.g., 'api.joemoer')
-	 * @param ip - IP address to point to
-	 * @param ttl - TTL in seconds (default: 300)
-	 * @returns true if created, false if already exists
-	 */
-	async createARecordIfNotExists(
-		domain: string,
-		subdomain: string,
-		ip: string,
-		ttl = 300,
-	): Promise<boolean> {
-		const exists = await this.recordExists(domain, subdomain, 'A');
-		if (exists) {
-			return false;
-		}
-
-		await this.upsertRecords(domain, [
-			{
-				name: subdomain,
-				type: 'A',
-				ttl,
-				records: [{ content: ip }],
-			},
-		]);
-
-		return true;
-	}
-}