@vibesdotdev/infra-doks 0.0.1

package/src/types.ts

@@ -0,0 +1,563 @@
+/**
+ * Kubernetes manifest type definitions.
+ *
+ * These types represent the subset of K8s API objects used by DOKS infrastructure
+ * implementations. Each type produces a plain object serializable to YAML.
+ */
+
+// Shared
+
+export interface K8sMetadata {
+	name?: string;
+	namespace?: string;
+	labels?: Record<string, string>;
+	annotations?: Record<string, string>;
+}
+
+export interface K8sLabelSelector {
+	matchLabels: Record<string, string>;
+}
+
+// Container & Pod
+
+export interface K8sResourceQuantity {
+	cpu?: string;
+	memory?: string;
+}
+
+export interface K8sResourceRequirements {
+	requests?: K8sResourceQuantity;
+	limits?: K8sResourceQuantity;
+}
+
+export interface K8sEnvFromSource {
+	configMapRef?: { name: string };
+	secretRef?: { name: string };
+}
+
+export interface K8sEnvVar {
+	name: string;
+	value?: string;
+	valueFrom?: {
+		secretKeyRef?: { name: string; key: string };
+		configMapKeyRef?: { name: string; key: string };
+	};
+}
+
+export interface K8sProbe {
+	httpGet?: { path: string; port: number };
+	tcpSocket?: { port: number };
+	exec?: { command: string[] };
+	initialDelaySeconds?: number;
+	periodSeconds?: number;
+	timeoutSeconds?: number;
+	failureThreshold?: number;
+}
+
+export interface K8sContainerPort {
+	name?: string;
+	containerPort: number;
+	protocol?: 'TCP' | 'UDP';
+}
+
+export interface K8sVolumeMount {
+	name: string;
+	mountPath: string;
+	readOnly?: boolean;
+}
+
+export interface K8sContainer {
+	name: string;
+	image: string;
+	command?: string[];
+	args?: string[];
+	ports?: K8sContainerPort[];
+	env?: K8sEnvVar[];
+	envFrom?: K8sEnvFromSource[];
+	resources?: K8sResourceRequirements;
+	volumeMounts?: K8sVolumeMount[];
+	livenessProbe?: K8sProbe;
+	readinessProbe?: K8sProbe;
+}
+
+export interface K8sConfigMapKeyToPath {
+	key: string;
+	path: string;
+	mode?: number;
+}
+
+export interface K8sVolume {
+	name: string;
+	emptyDir?: Record<string, never>;
+	configMap?: {
+		name: string;
+		items?: K8sConfigMapKeyToPath[];
+		defaultMode?: number;
+		optional?: boolean;
+	};
+	secret?: { secretName: string };
+	persistentVolumeClaim?: { claimName: string };
+}
+
+export interface K8sPodSpec {
+	containers: K8sContainer[];
+	initContainers?: K8sContainer[];
+	volumes?: K8sVolume[];
+	serviceAccountName?: string;
+	nodeSelector?: Record<string, string>;
+	tolerations?: Array<{
+		key?: string;
+		operator?: string;
+		value?: string;
+		effect?: string;
+	}>;
+}
+
+export interface K8sPodTemplateSpec {
+	metadata: K8sMetadata;
+	spec: K8sPodSpec;
+}
+
+// Deployment
+
+export interface K8sDeployment {
+	apiVersion: 'apps/v1';
+	kind: 'Deployment';
+	metadata: K8sMetadata;
+	spec: {
+		replicas: number;
+		selector: K8sLabelSelector;
+		template: K8sPodTemplateSpec;
+		strategy?: {
+			type: 'RollingUpdate' | 'Recreate';
+			rollingUpdate?: { maxSurge?: string | number; maxUnavailable?: string | number };
+		};
+	};
+}
+
+// StatefulSet
+
+export interface K8sPersistentVolumeClaimSpec {
+	accessModes: string[];
+	resources: { requests: { storage: string } };
+	storageClassName?: string;
+}
+
+export interface K8sVolumeClaimTemplate {
+	metadata: K8sMetadata;
+	spec: K8sPersistentVolumeClaimSpec;
+}
+
+export interface K8sStatefulSet {
+	apiVersion: 'apps/v1';
+	kind: 'StatefulSet';
+	metadata: K8sMetadata;
+	spec: {
+		serviceName: string;
+		replicas: number;
+		selector: K8sLabelSelector;
+		template: K8sPodTemplateSpec;
+		volumeClaimTemplates?: K8sVolumeClaimTemplate[];
+	};
+}
+
+// Service
+
+export interface K8sServicePort {
+	name?: string;
+	port: number;
+	targetPort: number | string;
+	protocol?: 'TCP' | 'UDP';
+}
+
+export interface K8sService {
+	apiVersion: 'v1';
+	kind: 'Service';
+	metadata: K8sMetadata;
+	spec: {
+		type?: 'ClusterIP' | 'NodePort' | 'LoadBalancer' | 'ExternalName';
+		selector: Record<string, string>;
+		ports: K8sServicePort[];
+		clusterIP?: string;
+	};
+}
+
+// ConfigMap
+
+export interface K8sConfigMap {
+	apiVersion: 'v1';
+	kind: 'ConfigMap';
+	metadata: K8sMetadata;
+	data?: Record<string, string>;
+}
+
+// Secret
+
+export interface K8sSecret {
+	apiVersion: 'v1';
+	kind: 'Secret';
+	metadata: K8sMetadata;
+	type?: string;
+	data?: Record<string, string>;
+	stringData?: Record<string, string>;
+}
+
+// DigitalOcean Managed Service Specs
+
+export interface DOManagedDBSpec {
+	name: string;
+	engine: string;
+	version: string;
+	size: string;
+	region: string;
+	num_nodes: number;
+}
+
+export interface DOManagedRedisSpec {
+	name: string;
+	engine: 'redis';
+	version: string;
+	size: string;
+	region: string;
+	num_nodes: number;
+	eviction_policy?: string;
+}
+
+export interface DOSpacesSpec {
+	name: string;
+	region: string;
+	acl: 'private' | 'public-read';
+	cors_rules?: Array<{
+		allowed_origins: string[];
+		allowed_methods: string[];
+		allowed_headers?: string[];
+		max_age_seconds?: number;
+	}>;
+	lifecycle_rules?: Array<{
+		prefix?: string;
+		expiration_days?: number;
+	}>;
+}
+
+// Cloud Provider Types (migrated from integrations/cloud)
+
+export type InstanceStatus =
+	| 'pending'
+	| 'running'
+	| 'stopping'
+	| 'stopped'
+	| 'terminating'
+	| 'terminated'
+	| 'error';
+
+export type VolumeStatus = 'creating' | 'available' | 'in-use' | 'deleting' | 'deleted' | 'error';
+
+export interface CloudProvider {
+	name: string;
+	createInstance(config: InstanceConfig): Promise<CloudInstance>;
+	deleteInstance(instanceId: string): Promise<void>;
+	getInstance(instanceId: string): Promise<CloudInstance | null>;
+	listInstances(filters?: InstanceFilters): Promise<CloudInstance[]>;
+	createVolume(config: VolumeConfig): Promise<CloudVolume>;
+	attachVolume(volumeId: string, instanceId: string): Promise<void>;
+	detachVolume(volumeId: string): Promise<void>;
+	deleteVolume(volumeId: string): Promise<void>;
+	listVolumes(filters?: VolumeFilters): Promise<CloudVolume[]>;
+	getOrCreateVPC(name: string): Promise<string>;
+	addSSHKey(name: string, publicKey: string): Promise<string>;
+	listSSHKeys(): Promise<SSHKey[]>;
+}
+
+export interface InstanceConfig {
+	name: string;
+	type: string;
+	region: string;
+	image: string;
+	sshKeys?: string[];
+	vpcId?: string;
+	userData?: string;
+	tags: Record<string, string>;
+}
+
+export interface CloudInstance {
+	id: string;
+	name: string;
+	type: string;
+	region: string;
+	status: InstanceStatus;
+	publicIp?: string;
+	privateIp?: string;
+	createdAt: Date;
+	tags: Record<string, string>;
+	metadata?: Record<string, unknown>;
+}
+
+export interface InstanceFilters {
+	status?: InstanceStatus[];
+	tags?: Record<string, string>;
+	region?: string;
+}
+
+export interface VolumeConfig {
+	name: string;
+	size: number;
+	region: string;
+	tags?: Record<string, string>;
+}
+
+export interface CloudVolume {
+	id: string;
+	name: string;
+	size: number;
+	region: string;
+	status: VolumeStatus;
+	attachedTo?: string;
+	createdAt: Date;
+	tags?: Record<string, string>;
+}
+
+export interface VolumeFilters {
+	status?: VolumeStatus[];
+	region?: string;
+	attachedTo?: string;
+}
+
+export interface SSHKey {
+	id: string;
+	name: string;
+	fingerprint: string;
+	publicKey: string;
+}
+
+export interface CloudProviderConfig {
+	type: 'digitalocean' | 'aws' | 'gcp' | 'azure';
+	credentials: string;
+	region?: string;
+}
+
+export class CloudProviderError extends Error {
+	constructor(
+		message: string,
+		public code: string,
+		public provider: string,
+		public details?: unknown
+	) {
+		super(message);
+		this.name = 'CloudProviderError';
+	}
+}
+
+// Kubernetes Types (migrated from integrations/infrastructure/kubernetes)
+
+export type PodPhase = 'Pending' | 'Running' | 'Succeeded' | 'Failed' | 'Unknown';
+export type ConditionStatus = 'True' | 'False' | 'Unknown';
+export type DeploymentConditionType = 'Available' | 'Progressing' | 'ReplicaFailure';
+export type ServiceType = 'ClusterIP' | 'NodePort' | 'LoadBalancer' | 'ExternalName';
+export type ServiceProtocol = 'TCP' | 'UDP' | 'SCTP';
+export type EventType = 'Normal' | 'Warning';
+export type ContainerState =
+	| { running?: { startedAt?: Date } }
+	| { terminated?: { exitCode?: number; reason?: string; message?: string; startedAt?: Date; finishedAt?: Date } }
+	| { waiting?: { reason?: string; message?: string } };
+
+export interface K8sConfig {
+	inCluster?: boolean;
+	kubeconfig?: string;
+	context?: string;
+	namespace?: string;
+}
+
+export interface K8sEnvironment {
+	name: string;
+	context: string;
+	namespace: string;
+	apiServer?: string;
+	provider?: 'eks' | 'aks' | 'gke' | 'docker-desktop' | 'minikube' | 'other';
+}
+
+export interface PodSelector {
+	name?: string;
+	namespace?: string;
+	labels?: Record<string, string>;
+}
+
+export interface PodStatus {
+	name: string;
+	namespace: string;
+	phase: PodPhase;
+	ready: boolean;
+	restarts: number;
+	age: string;
+	ip?: string;
+	node?: string;
+	conditions: Array<{
+		type: string;
+		status: ConditionStatus;
+		reason?: string;
+		message?: string;
+		lastTransitionTime: Date;
+	}>;
+	containers: Array<{
+		name: string;
+		ready: boolean;
+		restartCount: number;
+		state: ContainerState;
+		image: string;
+		imageID: string;
+	}>;
+}
+
+export interface LogOptions {
+	follow?: boolean;
+	tailLines?: number;
+	container?: string;
+	previous?: boolean;
+	sinceSeconds?: number;
+	limitBytes?: number;
+	timestamps?: boolean;
+}
+
+export interface LogEntry {
+	timestamp: Date;
+	pod: string;
+	namespace: string;
+	container: string;
+	message: string;
+	level?: string;
+	cluster?: string;
+	node?: string;
+	labels?: Record<string, string>;
+}
+
+export interface LogStream {
+	subscribe(callback: (log: LogEntry) => void): () => void;
+	pause(): void;
+	resume(): void;
+	close(): void;
+}
+
+export interface DeploymentStatus {
+	name: string;
+	namespace: string;
+	replicas: {
+		desired: number;
+		current: number;
+		available: number;
+		updated: number;
+	};
+	conditions: Array<{
+		type: DeploymentConditionType;
+		status: ConditionStatus;
+		reason?: string;
+		message?: string;
+		lastUpdateTime: Date;
+		lastTransitionTime: Date;
+	}>;
+	strategy: string;
+	minReadySeconds: number;
+	revisionHistoryLimit: number;
+	selector: Record<string, string>;
+}
+
+export interface ServiceInfo {
+	name: string;
+	namespace: string;
+	type: ServiceType;
+	clusterIP?: string;
+	externalIPs?: string[];
+	loadBalancerIP?: string;
+	ports: Array<{
+		name?: string;
+		protocol: ServiceProtocol;
+		port: number;
+		targetPort: number | string;
+		nodePort?: number;
+	}>;
+	selector: Record<string, string> | null;
+}
+
+export interface PodMetrics {
+	pod: string;
+	namespace: string;
+	containers: Record<string, ResourceMetrics>;
+}
+
+export interface ResourceMetrics {
+	cpu?: { usage: number };
+	memory?: { usage: number };
+	timestamp?: Date;
+}
+
+export interface K8sEvent {
+	type: EventType;
+	reason: string;
+	message: string;
+	source: {
+		component?: string;
+		host?: string;
+	};
+	firstTimestamp: Date;
+	lastTimestamp: Date;
+	count: number;
+	involvedObject: {
+		kind: string;
+		name: string;
+		namespace?: string;
+	};
+}
+
+export interface ExecOptions {
+	pod: string;
+	container?: string;
+	command: string[];
+	namespace?: string;
+	tty?: boolean;
+}
+
+export interface ExecResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+}
+
+export interface PortForwardOptions {
+	pod: string;
+	remotePort: number;
+	localPort: number;
+	namespace?: string;
+}
+
+export interface PortForward {
+	localPort: number;
+	remotePort: number;
+	close(): void;
+}
+
+export class K8sError extends Error {
+	constructor(
+		message: string,
+		public statusCode?: number,
+		public reason?: string
+	) {
+		super(message);
+		this.name = 'K8sError';
+	}
+}
+
+export class K8sAuthError extends K8sError {
+	constructor(message: string) {
+		super(message, 401, 'Unauthorized');
+		this.name = 'K8sAuthError';
+	}
+}
+
+export class K8sNotFoundError extends K8sError {
+	constructor(
+		public kind: string,
+		public name: string,
+		public namespace?: string
+	) {
+		super(`${kind} '${name}' not found${namespace ? ` in namespace ${namespace}` : ''}`, 404, 'NotFound');
+		this.name = 'K8sNotFoundError';
+	}
+}