@vibesdotdev/infra-doks 0.0.1

package/src/cloud/digitalocean.ts

@@ -0,0 +1,363 @@
+/**
+ * DigitalOcean Cloud Provider Implementation
+ *
+ * Implements the CloudProvider interface for DigitalOcean.
+ */
+
+import { BaseCloudProvider } from './base.ts';
+import type {
+	CloudInstance,
+	InstanceConfig,
+	InstanceFilters,
+	CloudVolume,
+	VolumeConfig,
+	VolumeFilters,
+	SSHKey,
+	InstanceStatus
+} from '../types.ts';
+
+interface DODroplet {
+	id: number;
+	name: string;
+	status: string;
+	size: { slug: string };
+	region: { slug: string };
+	image: { slug: string };
+	networks: {
+		v4: Array<{ ip_address: string; type: string }>;
+	};
+	created_at: string;
+	tags: string[];
+}
+
+interface DOVolume {
+	id: string;
+	name: string;
+	size_gigabytes: number;
+	region: { slug: string };
+	droplet_ids: number[];
+	created_at: string;
+	tags: string[];
+}
+
+interface DOSSHKey {
+	id: number;
+	fingerprint: string;
+	public_key: string;
+	name: string;
+}
+
+interface DOResponseMap {
+	'/droplets': { droplet: DODroplet } | { droplets: DODroplet[] };
+	'/volumes': { volume: DOVolume } | { volumes: DOVolume[] };
+	'/vpcs': { vpc: { id: string }; vpcs: Array<{ id: string; name: string }> } | { vpc: { id: string } };
+	'/account/keys': { ssh_key: DOSSHKey } | { ssh_keys: DOSSHKey[] };
+}
+
+type DOResponse<T> = T extends keyof DOResponseMap ? DOResponseMap[T] : Record<string, unknown>;
+
+export class DigitalOceanProvider extends BaseCloudProvider {
+	name = 'digitalocean';
+	private readonly apiBase = 'https://api.digitalocean.com/v2';
+
+	constructor(apiToken: string, defaultRegion: string = 'nyc3') {
+		super(apiToken, defaultRegion);
+	}
+
+	private async doRequest<T = Record<string, unknown>>(path: string, options: RequestInit = {}): Promise<T> {
+		const response = await fetch(`${this.apiBase}${path}`, {
+			...options,
+			headers: {
+				Authorization: `Bearer ${this.credentials}`,
+				'Content-Type': 'application/json',
+				...options.headers
+			}
+		});
+
+		if (!response.ok) {
+			const error = await response.text();
+			throw this.createError(`DigitalOcean API error: ${response.status}`, 'API_ERROR', {
+				status: response.status,
+				error
+			});
+		}
+
+		return response.json() as Promise<T>;
+	}
+
+	async createInstance(config: InstanceConfig): Promise<CloudInstance> {
+		const dropletData = {
+			name: config.name,
+			region: config.region || this.defaultRegion,
+			size: config.type,
+			image: config.image,
+			ssh_keys: config.sshKeys || [],
+			vpc_uuid: config.vpcId,
+			tags: this.formatTags(this.buildTags(config.tags)),
+			user_data: config.userData
+		};
+
+		const response = await this.doRequest<DOResponse<'/droplets'>>('/droplets', {
+			method: 'POST',
+			body: JSON.stringify(dropletData)
+		});
+
+		const droplet = (response as { droplet: DODroplet }).droplet;
+
+		// Wait for droplet to be ready
+		const readyDroplet = await this.waitForDropletReady(droplet.id);
+
+		return this.mapDropletToInstance(readyDroplet);
+	}
+
+	async deleteInstance(instanceId: string): Promise<void> {
+		const numericId = this.extractDropletId(instanceId);
+
+		await this.doRequest(`/droplets/${numericId}`, {
+			method: 'DELETE'
+		});
+	}
+
+	async getInstance(instanceId: string): Promise<CloudInstance | null> {
+		try {
+			const numericId = this.extractDropletId(instanceId);
+			const response = await this.doRequest<{ droplet: DODroplet }>(`/droplets/${numericId}`);
+			return this.mapDropletToInstance(response.droplet);
+		} catch (error: unknown) {
+			if ((error as { details?: { status: number } }).details?.status === 404) {
+				return null;
+			}
+			throw error;
+		}
+	}
+
+	async listInstances(filters?: InstanceFilters): Promise<CloudInstance[]> {
+		const params = new URLSearchParams();
+		if (filters?.tags) {
+			params.append('tag_name', this.formatTags(filters.tags).join(','));
+		}
+
+		const response = await this.doRequest<{ droplets: DODroplet[] }>(`/droplets?${params.toString()}`);
+		const droplets = response.droplets;
+
+		let instances = droplets.map((d) => this.mapDropletToInstance(d));
+
+		// Apply additional filters
+		if (filters?.status) {
+			instances = instances.filter((i) => filters.status!.includes(i.status));
+		}
+
+		if (filters?.region) {
+			instances = instances.filter((i) => i.region === filters.region);
+		}
+
+		return instances;
+	}
+
+	async createVolume(config: VolumeConfig): Promise<CloudVolume> {
+		const volumeData = {
+			name: config.name,
+			size_gigabytes: config.size,
+			region: config.region || this.defaultRegion,
+			tags: config.tags ? this.formatTags(config.tags) : []
+		};
+
+		const response = await this.doRequest<{ volume: DOVolume }>('/volumes', {
+			method: 'POST',
+			body: JSON.stringify(volumeData)
+		});
+
+		return this.mapVolumeToCloudVolume(response.volume);
+	}
+
+	async attachVolume(volumeId: string, instanceId: string): Promise<void> {
+		const numericId = this.extractDropletId(instanceId);
+
+		await this.doRequest(`/volumes/${volumeId}/actions`, {
+			method: 'POST',
+			body: JSON.stringify({
+				type: 'attach',
+				droplet_id: numericId
+			})
+		});
+
+		// Wait for volume to be attached
+		await this.waitForVolumeStatus(volumeId, 'in-use');
+	}
+
+	async detachVolume(volumeId: string): Promise<void> {
+		await this.doRequest(`/volumes/${volumeId}/actions`, {
+			method: 'POST',
+			body: JSON.stringify({
+				type: 'detach'
+			})
+		});
+
+		// Wait for volume to be available
+		await this.waitForVolumeStatus(volumeId, 'available');
+	}
+
+	async deleteVolume(volumeId: string): Promise<void> {
+		await this.doRequest(`/volumes/${volumeId}`, {
+			method: 'DELETE'
+		});
+	}
+
+	async listVolumes(filters?: VolumeFilters): Promise<CloudVolume[]> {
+		const params = new URLSearchParams();
+		if (filters?.region) {
+			params.append('region', filters.region);
+		}
+
+		const response = await this.doRequest<{ volumes: DOVolume[] }>(`/volumes?${params.toString()}`);
+		const volumes = response.volumes;
+
+		return volumes.map((v) => this.mapVolumeToCloudVolume(v));
+	}
+
+	async getOrCreateVPC(name: string): Promise<string> {
+		// List existing VPCs
+		const response = await this.doRequest<{ vpcs?: Array<{ id: string; name: string }> }>('/vpcs');
+		const vpcs = response.vpcs || [];
+
+		// Check if VPC with this name exists
+		const existingVpc = vpcs.find((vpc: Record<string, unknown>) => vpc.name === name);
+		if (existingVpc) {
+			return existingVpc.id;
+		}
+
+		// Create new VPC
+		const vpcData = {
+			name,
+			region: this.defaultRegion,
+			ip_range: '10.0.0.0/16'
+		};
+
+		const createResponse = await this.doRequest<{ vpc: { id: string } }>('/vpcs', {
+			method: 'POST',
+			body: JSON.stringify(vpcData)
+		});
+
+		return createResponse.vpc.id;
+	}
+
+	async addSSHKey(name: string, publicKey: string): Promise<string> {
+		const response = await this.doRequest<{ ssh_key: DOSSHKey }>('/account/keys', {
+			method: 'POST',
+			body: JSON.stringify({
+				name,
+				public_key: publicKey
+			})
+		});
+
+		return response.ssh_key.fingerprint;
+	}
+
+	async listSSHKeys(): Promise<SSHKey[]> {
+		const response = await this.doRequest<{ ssh_keys: DOSSHKey[] }>('/account/keys');
+		const keys = response.ssh_keys;
+
+		return keys.map((key) => ({
+			id: key.fingerprint,
+			name: key.name,
+			fingerprint: key.fingerprint,
+			publicKey: key.public_key
+		}));
+	}
+
+	// Helper methods
+	private async waitForDropletReady(dropletId: number): Promise<DODroplet> {
+		const startTime = Date.now();
+		const timeout = 300000;
+		const pollInterval = 5000;
+
+		while (Date.now() - startTime < timeout) {
+			const response = await this.doRequest<{ droplet: DODroplet }>(`/droplets/${dropletId}`);
+			const droplet = response.droplet;
+
+			if (droplet.status === 'active') {
+				return droplet;
+			}
+
+			if (droplet.status === 'error' || droplet.status === 'archive') {
+				throw this.createError(`Droplet entered error state: ${droplet.status}`, 'DROPLET_ERROR', {
+					dropletId,
+					status: droplet.status
+				});
+			}
+
+			await this.sleep(pollInterval);
+		}
+
+		throw this.createError('Timeout waiting for droplet to be ready', 'TIMEOUT', {
+			dropletId,
+			timeout
+		});
+	}
+
+	private mapDropletToInstance(droplet: DODroplet): CloudInstance {
+		const publicIp = droplet.networks.v4.find((n) => n.type === 'public')?.ip_address;
+		const privateIp = droplet.networks.v4.find((n) => n.type === 'private')?.ip_address;
+
+		return {
+			id: `do-${droplet.id}`,
+			name: droplet.name,
+			type: droplet.size.slug,
+			region: droplet.region.slug,
+			status: this.mapDropletStatus(droplet.status),
+			publicIp,
+			privateIp,
+			createdAt: new Date(droplet.created_at),
+			tags: this.parseTags(droplet.tags)
+		};
+	}
+
+	private mapDropletStatus(doStatus: string): InstanceStatus {
+		const statusMap: Record<string, InstanceStatus> = {
+			new: 'pending',
+			active: 'running',
+			off: 'stopped',
+			archive: 'terminated',
+			error: 'error'
+		};
+
+		return statusMap[doStatus] || 'pending';
+	}
+
+	private mapVolumeToCloudVolume(volume: DOVolume): CloudVolume {
+		return {
+			id: volume.id,
+			name: volume.name,
+			size: volume.size_gigabytes,
+			region: volume.region.slug,
+			status: volume.droplet_ids.length > 0 ? 'in-use' : 'available',
+			attachedTo: volume.droplet_ids.length > 0 ? `do-${volume.droplet_ids[0]}` : undefined,
+			createdAt: new Date(volume.created_at),
+			tags: this.parseTags(volume.tags)
+		};
+	}
+
+	private extractDropletId(instanceId: string): number {
+		if (instanceId.startsWith('do-')) {
+			return parseInt(instanceId.substring(3), 10);
+		}
+		return parseInt(instanceId, 10);
+	}
+
+	private formatTags(tags: Record<string, string>): string[] {
+		return Object.entries(tags).map(([key, value]) => `${key}:${value}`);
+	}
+
+	private parseTags(tags: string[]): Record<string, string> {
+		const result: Record<string, string> = {};
+
+		for (const tag of tags) {
+			const [key, value] = tag.split(':');
+			if (key && value) {
+				result[key] = value;
+			}
+		}
+
+		return result;
+	}
+}

package/src/cloud/factory.ts

@@ -0,0 +1,190 @@
+/**
+ * Cloud Provider Factory
+ *
+ * Creates cloud provider instances based on configuration.
+ * Unsupported providers return a stub that throws {@link CloudProviderError}
+ * on every operation instead of crashing at construction time.
+ */
+
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+import { getLogger } from '@vibesdotdev/logging';
+import type {
+	CloudProvider,
+	CloudProviderConfig,
+	CloudInstance,
+	InstanceConfig,
+	InstanceFilters,
+	CloudVolume,
+	VolumeConfig,
+	VolumeFilters,
+	SSHKey
+} from '../types.ts';
+import { CloudProviderError } from '../types.ts';
+import { DigitalOceanProvider } from './digitalocean.ts';
+
+const logger = getLogger('infra-doks:cloud');
+
+/**
+ * Stub returned for providers that are recognised but not yet implemented.
+ *
+ * Logs a warning once at construction and throws a structured
+ * {@link CloudProviderError} on every method call so callers can distinguish
+ * "provider not available" from "unknown provider" without catching raw Errors.
+ */
+class UnsupportedCloudProvider implements CloudProvider {
+	readonly name: string;
+
+	constructor(providerType: string) {
+		this.name = providerType;
+		logger.warn(`${providerType} cloud provider requested but is not yet implemented`);
+	}
+
+	private unsupported(): never {
+		throw new CloudProviderError(
+			`${this.name} provider is not yet implemented`,
+			'PROVIDER_NOT_IMPLEMENTED',
+			this.name
+		);
+	}
+
+	createInstance(_config: InstanceConfig): Promise<CloudInstance> {
+		return this.unsupported();
+	}
+	deleteInstance(_instanceId: string): Promise<void> {
+		return this.unsupported();
+	}
+	getInstance(_instanceId: string): Promise<CloudInstance | null> {
+		return this.unsupported();
+	}
+	listInstances(_filters?: InstanceFilters): Promise<CloudInstance[]> {
+		return this.unsupported();
+	}
+
+	createVolume(_config: VolumeConfig): Promise<CloudVolume> {
+		return this.unsupported();
+	}
+	attachVolume(_volumeId: string, _instanceId: string): Promise<void> {
+		return this.unsupported();
+	}
+	detachVolume(_volumeId: string): Promise<void> {
+		return this.unsupported();
+	}
+	deleteVolume(_volumeId: string): Promise<void> {
+		return this.unsupported();
+	}
+	listVolumes(_filters?: VolumeFilters): Promise<CloudVolume[]> {
+		return this.unsupported();
+	}
+
+	getOrCreateVPC(_name: string): Promise<string> {
+		return this.unsupported();
+	}
+	addSSHKey(_name: string, _publicKey: string): Promise<string> {
+		return this.unsupported();
+	}
+	listSSHKeys(): Promise<SSHKey[]> {
+		return this.unsupported();
+	}
+}
+
+/**
+ * Create a cloud provider instance.
+ *
+ * For known-but-unimplemented providers (aws, gcp, azure) the returned
+ * instance is valid but every method call throws a structured
+ * {@link CloudProviderError} with code `PROVIDER_NOT_IMPLEMENTED`.
+ *
+ * For completely unknown provider types a raw {@link Error} is still thrown
+ * at construction time because the caller has passed an invalid configuration.
+ */
+export function createCloudProvider(config: CloudProviderConfig): CloudProvider {
+	switch (config.type) {
+		case 'digitalocean':
+			return new DigitalOceanProvider(config.credentials, config.region);
+
+		case 'aws':
+			return new UnsupportedCloudProvider(config.type);
+
+		case 'gcp':
+			return new UnsupportedCloudProvider(config.type);
+
+		case 'azure':
+			return new UnsupportedCloudProvider(config.type);
+
+		default: {
+			// Exhaustiveness check: this should never be reached if config.type
+			// is one of the known providers. TypeScript should narrow config to
+			// never here, but we use a type assertion to handle edge cases.
+			throw new Error(`Unknown cloud provider type: ${(config as CloudProviderConfig).type}`);
+		}
+	}
+}
+
+/**
+ * Get cloud provider from environment configuration
+ */
+export function getCloudProviderFromEnv(): CloudProvider | null {
+	// Check for DigitalOcean
+	const doToken = getRuntimeEnv('DIGITALOCEAN_TOKEN');
+	if (doToken) {
+		return createCloudProvider({
+			type: 'digitalocean',
+			credentials: doToken,
+			region: getRuntimeEnv('GPU_REGION') || 'nyc3'
+		});
+	}
+
+	// Check for AWS
+	const awsAccessKey = getRuntimeEnv('AWS_ACCESS_KEY_ID');
+	const awsSecretKey = getRuntimeEnv('AWS_SECRET_ACCESS_KEY');
+	if (awsAccessKey && awsSecretKey) {
+		logger.warn('AWS credentials detected but AWS provider is not yet implemented');
+	}
+
+	const gcpCredentials = getRuntimeEnv('GOOGLE_APPLICATION_CREDENTIALS');
+	if (gcpCredentials) {
+		logger.warn('GCP provider detected but not yet implemented');
+	}
+
+	const azureClientId = getRuntimeEnv('AZURE_CLIENT_ID');
+	if (azureClientId) {
+		logger.warn('Azure provider detected but not yet implemented');
+	}
+
+	return null;
+}
+
+/**
+ * Validate cloud provider configuration
+ */
+export function validateCloudProviderConfig(config: CloudProviderConfig): string[] {
+	const errors: string[] = [];
+
+	if (!config.type) {
+		errors.push('Cloud provider type is required');
+	}
+
+	if (!config.credentials) {
+		errors.push('Cloud provider credentials are required');
+	}
+
+	// Provider-specific validation
+	switch (config.type) {
+		case 'digitalocean':
+			if (!config.credentials || config.credentials.length < 20) {
+				errors.push('Invalid DigitalOcean API token');
+			}
+			break;
+
+		case 'aws':
+		case 'gcp':
+		case 'azure':
+			errors.push(`${config.type} provider not yet implemented`);
+			break;
+
+		default:
+			errors.push(`Unknown cloud provider type: ${config.type}`);
+	}
+
+	return errors;
+}

package/src/cloud/index.ts

@@ -0,0 +1,81 @@
+/**
+ * Cloud Provider Abstraction Layer
+ *
+ * Provides a unified interface for managing cloud resources across
+ * different providers (DigitalOcean, AWS, GCP, Azure).
+ */
+
+export type {
+	K8sMetadata,
+	K8sLabelSelector,
+	K8sResourceQuantity,
+	K8sResourceRequirements,
+	K8sEnvFromSource,
+	K8sEnvVar,
+	K8sProbe,
+	K8sContainerPort,
+	K8sVolumeMount,
+	K8sContainer,
+	K8sConfigMapKeyToPath,
+	K8sVolume,
+	K8sPodSpec,
+	K8sPodTemplateSpec,
+	K8sDeployment,
+	K8sPersistentVolumeClaimSpec,
+	K8sVolumeClaimTemplate,
+	K8sStatefulSet,
+	K8sServicePort,
+	K8sService,
+	K8sConfigMap,
+	K8sSecret,
+	DOManagedDBSpec,
+	DOManagedRedisSpec,
+	DOSpacesSpec,
+	CloudProvider,
+	InstanceConfig,
+	CloudInstance,
+	InstanceFilters,
+	VolumeConfig,
+	CloudVolume,
+	VolumeFilters,
+	SSHKey,
+	CloudProviderConfig,
+	InstanceStatus,
+	VolumeStatus,
+	K8sConfig,
+	K8sEnvironment,
+	PodSelector,
+	PodStatus,
+	LogOptions,
+	LogEntry,
+	LogStream,
+	DeploymentStatus,
+	ServiceInfo,
+	PodMetrics,
+	ResourceMetrics,
+	K8sEvent,
+	ExecOptions,
+	ExecResult,
+	PortForwardOptions,
+	PortForward,
+	PodPhase,
+	ConditionStatus,
+	DeploymentConditionType,
+	ServiceType,
+	ServiceProtocol,
+	EventType,
+	ContainerState,
+} from '../types.ts';
+export {
+	CloudProviderError,
+	K8sError,
+	K8sAuthError,
+	K8sNotFoundError,
+} from '../types.ts';
+export { BaseCloudProvider } from './base.ts';
+export { DigitalOceanProvider } from './digitalocean.ts';
+export {
+	createCloudProvider,
+	getCloudProviderFromEnv,
+	validateCloudProviderConfig
+} from './factory.ts';