@vibesdotdev/infra-doks 0.0.1

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "@vibesdotdev/infra-doks",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/doks.plugin.d.ts",
+      "bun": "./src/doks.plugin.ts",
+      "import": "./dist/doks.plugin.js",
+      "default": "./dist/doks.plugin.js"
+    },
+    "./implementations/deployment": {
+      "types": "./dist/implementations/deployment.impl.d.ts",
+      "bun": "./src/implementations/deployment.impl.ts",
+      "import": "./dist/implementations/deployment.impl.js",
+      "default": "./dist/implementations/deployment.impl.js"
+    },
+    "./implementations/statefulset": {
+      "types": "./dist/implementations/statefulset.impl.d.ts",
+      "bun": "./src/implementations/statefulset.impl.ts",
+      "import": "./dist/implementations/statefulset.impl.js",
+      "default": "./dist/implementations/statefulset.impl.js"
+    },
+    "./implementations/managed-db": {
+      "types": "./dist/implementations/managed-db.impl.d.ts",
+      "bun": "./src/implementations/managed-db.impl.ts",
+      "import": "./dist/implementations/managed-db.impl.js",
+      "default": "./dist/implementations/managed-db.impl.js"
+    },
+    "./implementations/managed-redis": {
+      "types": "./dist/implementations/managed-redis.impl.d.ts",
+      "bun": "./src/implementations/managed-redis.impl.ts",
+      "import": "./dist/implementations/managed-redis.impl.js",
+      "default": "./dist/implementations/managed-redis.impl.js"
+    },
+    "./implementations/spaces": {
+      "types": "./dist/implementations/spaces.impl.d.ts",
+      "bun": "./src/implementations/spaces.impl.ts",
+      "import": "./dist/implementations/spaces.impl.js",
+      "default": "./dist/implementations/spaces.impl.js"
+    },
+    "./implementations/gitea": {
+      "types": "./dist/implementations/gitea.impl.d.ts",
+      "bun": "./src/implementations/gitea.impl.ts",
+      "import": "./dist/implementations/gitea.impl.js",
+      "default": "./dist/implementations/gitea.impl.js"
+    },
+    "./implementations/verdaccio": {
+      "types": "./dist/implementations/verdaccio.impl.d.ts",
+      "bun": "./src/implementations/verdaccio.impl.ts",
+      "import": "./dist/implementations/verdaccio.impl.js",
+      "default": "./dist/implementations/verdaccio.impl.js"
+    },
+    "./cloud": {
+      "types": "./dist/cloud/index.d.ts",
+      "bun": "./src/cloud/index.ts",
+      "import": "./dist/cloud/index.js",
+      "default": "./dist/cloud/index.js"
+    },
+    "./kubernetes": {
+      "types": "./dist/kubernetes/index.d.ts",
+      "bun": "./src/kubernetes/index.ts",
+      "import": "./dist/kubernetes/index.js",
+      "default": "./dist/kubernetes/index.js"
+    },
+    "./secrets": {
+      "types": "./dist/secrets/index.d.ts",
+      "bun": "./src/secrets/index.ts",
+      "import": "./dist/secrets/index.js",
+      "default": "./dist/secrets/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "bun": "./src/types.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "bun": "./src/client/index.ts",
+      "import": "./dist/client/index.js",
+      "default": "./dist/client/index.js"
+    }
+  },
+  "dependencies": {
+    "@kubernetes/client-node": "^1.4.0",
+    "@vibesdotdev/infra-core": "0.0.1",
+    "@vibesdotdev/logging": "0.0.1",
+    "@vibesdotdev/registry-theme": "0.0.1",
+    "@vibesdotdev/runtime": "0.0.1",
+    "@vibesdotdev/runtime-client": "0.0.1",
+    "@vibesdotdev/secrets": "0.0.1",
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "check": "bun --bun tsc -p tsconfig.json --noEmit",
+    "test": "bun test src/**/*.test.ts",
+    "build": "tsc -p tsconfig.json"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vibesdotdev/monorepo.git",
+    "directory": "packages/infra-doks"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "bin",
+    "README.md",
+    "SPEC.md",
+    "LICENSE",
+    "!src/**/__tests__/**",
+    "!src/**/__stubs__/**",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.spec.ts",
+    "!src/**/*.spec.tsx",
+    "!dist/**/__tests__/**",
+    "!dist/**/__stubs__/**",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/**/*.spec.js",
+    "!dist/**/*.spec.js.map",
+    "!dist/**/*.spec.d.ts",
+    "!dist/**/*.spec.d.ts.map"
+  ],
+  "vibes": {
+    "visibility": "public-framework"
+  }
+}

package/src/client/digitalocean-app-deploy.client.ts

@@ -0,0 +1,226 @@
+/**
+ * DigitalOcean App Platform Deploy Client
+ *
+ * Canonical `runtime/client` (id `digitalocean-app-deploy`) for creating or
+ * updating an App Platform application from an `AppDeployment` manifest.
+ * Uses the DigitalOcean REST API v2 directly (no `doctl` dependency).
+ *
+ * Consumers resolve via `getDigitalOceanAppDeployClient()` (preferred)
+ * or `getVibesClient<DigitalOceanAppDeployClient>('digitalocean-app-deploy')`.
+ *
+ * For the initial deploy, the DO App needs a source reference. The common case
+ * is a git repo reference — the CLI writes the app spec; the operator connects
+ * the git repo in the DO dashboard once. Subsequent calls update the spec.
+ *
+ * Credentials: reads `DIGITALOCEAN_API_TOKEN` from the operator's environment.
+ * (Secrets-manager integration is tracked in `infra-deploy/SPEC.md` Migration
+ * debt — once landed, this client will resolve the token via secrets/store.)
+ */
+
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+import type { VibesRuntime } from '@vibesdotdev/runtime';
+import {
+	BaseRuntimeClient,
+	type RuntimeClientDescriptor
+} from '@vibesdotdev/runtime-client';
+import type { AppDeployment } from '@vibesdotdev/infra-core/deployment';
+
+const DO_API_BASE = 'https://api.digitalocean.com/v2';
+
+export interface DeployAppOptions {
+	deployment: AppDeployment;
+	/** Existing DO App id (for updates). Omit to create a new App. */
+	appId?: string;
+	/** Region slug, e.g. 'nyc', 'sfo3', 'ams'. */
+	region?: string;
+	/** Git repo reference for the app source (github/gitlab). */
+	git?: {
+		repoCloneUrl?: string;
+		branch?: string;
+	};
+	/** Environment name for DO (e.g. 'production'). */
+	environmentName?: string;
+	dryRun?: boolean;
+	onLine?: (stream: 'stdout' | 'stderr', line: string) => void;
+}
+
+export interface DeployAppResult {
+	appId: string;
+	liveUrl?: string;
+}
+
+interface DOEnvSpec {
+	key: string;
+	value?: string;
+	scope?: 'RUN_TIME' | 'BUILD_TIME' | 'RUN_AND_BUILD_TIME';
+	type?: 'GENERAL' | 'SECRET';
+}
+
+interface DOGitHubRef {
+	repo?: string;
+	branch?: string;
+	deploy_on_push?: boolean;
+}
+
+interface DOServiceSpec {
+	name: string;
+	instance_count?: number;
+	instance_size_slug?: string;
+	http_port?: number;
+	build_command?: string;
+	run_command?: string;
+	source_dir?: string;
+	github?: DOGitHubRef;
+	envs?: DOEnvSpec[];
+	health_check?: { http_path?: string };
+}
+
+interface DOStaticSiteSpec {
+	name: string;
+	build_command?: string;
+	source_dir?: string;
+	output_dir?: string;
+	github?: DOGitHubRef;
+	envs?: DOEnvSpec[];
+}
+
+interface DOAppSpec {
+	name: string;
+	region?: string;
+	services?: DOServiceSpec[];
+	static_sites?: DOStaticSiteSpec[];
+	envs?: DOEnvSpec[];
+}
+
+function authHeader(): string {
+	const token = getRuntimeEnv('DIGITALOCEAN_API_TOKEN') ?? '';
+	if (!token) {
+		throw new Error(
+			'DIGITALOCEAN_API_TOKEN is not set. Generate one at https://cloud.digitalocean.com/account/api/tokens and set it in your env.'
+		);
+	}
+	return `Bearer ${token}`;
+}
+
+async function doFetch<T>(path: string, init?: RequestInit): Promise<T> {
+	const response = await fetch(`${DO_API_BASE}${path}`, {
+		...init,
+		headers: {
+			Authorization: authHeader(),
+			'Content-Type': 'application/json',
+			...(init?.headers ?? {})
+		}
+	});
+	if (!response.ok) {
+		const body = await response.text();
+		throw new Error(`DO API ${response.status} ${path}: ${body}`);
+	}
+	if (response.status === 204) return undefined as T;
+	return (await response.json()) as T;
+}
+
+function buildAppSpec(deployment: AppDeployment, options: DeployAppOptions): DOAppSpec {
+	const envs: DOEnvSpec[] = deployment.env
+		.filter((requirement) => typeof requirement.value === 'string')
+		.map((requirement) => ({
+			key: requirement.name,
+			value: requirement.value as string,
+			scope: 'RUN_AND_BUILD_TIME' as const,
+			type: (requirement.secret ? 'SECRET' : 'GENERAL') as 'GENERAL' | 'SECRET'
+		}));
+
+	const github: DOGitHubRef = {
+		repo: options.git?.repoCloneUrl,
+		branch: options.git?.branch ?? 'main',
+		deploy_on_push: false
+	};
+
+	const isStaticRuntime = deployment.runtime === 'browser' || deployment.runtime === 'edge';
+	const sourceDir = deployment.build.appDir;
+	const outputDir = deployment.build.outputDir;
+
+	if (isStaticRuntime) {
+		return {
+			name: deployment.appId,
+			region: options.region ?? 'nyc',
+			static_sites: [
+				{
+					name: deployment.appId,
+					build_command: deployment.build.buildCommand,
+					source_dir: sourceDir,
+					output_dir: outputDir,
+					github: options.git?.repoCloneUrl ? github : undefined,
+					envs
+				}
+			]
+		};
+	}
+
+	return {
+		name: deployment.appId,
+		region: options.region ?? 'nyc',
+		services: [
+			{
+				name: deployment.appId,
+				instance_count: 1,
+				instance_size_slug: 'apps-s-1vcpu-0.5gb',
+				http_port: 3000,
+				build_command: deployment.build.buildCommand,
+				run_command: 'node build',
+				source_dir: sourceDir,
+				github: options.git?.repoCloneUrl ? github : undefined,
+				envs,
+				health_check: { http_path: '/' }
+			}
+		]
+	};
+}
+
+export class DigitalOceanAppDeployClient extends BaseRuntimeClient {
+	constructor(
+		descriptor: RuntimeClientDescriptor = {
+			id: 'digitalocean-app-deploy',
+			kind: 'runtime/client'
+		},
+		context?: unknown,
+		runtime?: VibesRuntime
+	) {
+		super(descriptor, context, runtime);
+	}
+
+	async deployApp(options: DeployAppOptions): Promise<DeployAppResult> {
+		const { deployment, onLine } = options;
+		const spec = buildAppSpec(deployment, options);
+
+		if (options.dryRun) {
+			onLine?.('stdout', `[dry-run] DO App spec for '${deployment.appId}':`);
+			onLine?.('stdout', JSON.stringify(spec, null, 2));
+			return { appId: options.appId ?? '(new)' };
+		}
+
+		if (options.appId) {
+			onLine?.('stdout', `Updating DO App ${options.appId}...`);
+			const updated = await doFetch<{ app: { id: string; live_url?: string; spec?: DOAppSpec } }>(
+				`/apps/${options.appId}`,
+				{
+					method: 'PUT',
+					body: JSON.stringify({ spec })
+				}
+			);
+			return {
+				appId: updated.app.id,
+				liveUrl: updated.app.live_url
+			};
+		}
+
+		onLine?.('stdout', `Creating DO App '${deployment.appId}'...`);
+		const created = await doFetch<{ app: { id: string; live_url?: string } }>(`/apps`, {
+			method: 'POST',
+			body: JSON.stringify({ spec })
+		});
+		return {
+			appId: created.app.id,
+			liveUrl: created.app.live_url
+		};
+	}
+}

package/src/client/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Public surface for the infra-doks runtime clients.
+ *
+ * Consumers resolve the App Platform deploy client via
+ * `getDigitalOceanAppDeployClient()` (preferred) or, for type-pinned generic
+ * resolution, `getVibesClient<DigitalOceanAppDeployClient>('digitalocean-app-deploy')`.
+ *
+ * Requires `doksPlugin` to be registered with the runtime so the
+ * `runtime/client` descriptor + loader for id `digitalocean-app-deploy` are
+ * resolvable.
+ */
+
+import { getVibesClient } from '@vibesdotdev/runtime-client';
+import { DigitalOceanAppDeployClient } from './digitalocean-app-deploy.client';
+
+export {
+	DigitalOceanAppDeployClient,
+	type DeployAppOptions,
+	type DeployAppResult
+} from './digitalocean-app-deploy.client';
+
+export async function getDigitalOceanAppDeployClient(): Promise<DigitalOceanAppDeployClient> {
+	return getVibesClient<DigitalOceanAppDeployClient>('digitalocean-app-deploy');
+}

package/src/cloud/base.ts

@@ -0,0 +1,149 @@
+/**
+ * Base Cloud Provider Implementation
+ *
+ * Abstract base class that provides common functionality for all cloud providers.
+ */
+
+import type {
+	CloudProvider,
+	CloudInstance,
+	InstanceConfig,
+	InstanceFilters,
+	CloudVolume,
+	VolumeConfig,
+	VolumeFilters,
+	SSHKey
+} from '../types.ts';
+import { CloudProviderError } from '../types.ts';
+
+export abstract class BaseCloudProvider implements CloudProvider {
+	abstract name: string;
+
+	constructor(
+		protected credentials: string,
+		protected defaultRegion?: string
+	) {}
+
+	// Abstract methods that must be implemented by each provider
+	abstract createInstance(config: InstanceConfig): Promise<CloudInstance>;
+	abstract deleteInstance(instanceId: string): Promise<void>;
+	abstract getInstance(instanceId: string): Promise<CloudInstance | null>;
+	abstract listInstances(filters?: InstanceFilters): Promise<CloudInstance[]>;
+
+	abstract createVolume(config: VolumeConfig): Promise<CloudVolume>;
+	abstract attachVolume(volumeId: string, instanceId: string): Promise<void>;
+	abstract detachVolume(volumeId: string): Promise<void>;
+	abstract deleteVolume(volumeId: string): Promise<void>;
+	abstract listVolumes(filters?: VolumeFilters): Promise<CloudVolume[]>;
+
+	abstract getOrCreateVPC(name: string): Promise<string>;
+	abstract addSSHKey(name: string, publicKey: string): Promise<string>;
+	abstract listSSHKeys(): Promise<SSHKey[]>;
+
+	// Common helper methods
+	protected generateInstanceName(prefix: string = 'gpu-instance'): string {
+		const timestamp = Date.now();
+		const random = Math.random().toString(36).substring(2, 8);
+		return `${prefix}-${timestamp}-${random}`;
+	}
+
+	protected generateVolumeName(prefix: string = 'gpu-volume'): string {
+		const timestamp = Date.now();
+		const random = Math.random().toString(36).substring(2, 8);
+		return `${prefix}-${timestamp}-${random}`;
+	}
+
+	protected async waitForInstanceStatus(
+		instanceId: string,
+		targetStatus: string,
+		timeoutMs: number = 300000,
+		pollIntervalMs: number = 5000
+	): Promise<CloudInstance> {
+		const startTime = Date.now();
+
+		while (Date.now() - startTime < timeoutMs) {
+			const instance = await this.getInstance(instanceId);
+
+			if (!instance) {
+				throw this.createError('Instance not found', 'INSTANCE_NOT_FOUND', { instanceId });
+			}
+
+			if (instance.status === targetStatus) {
+				return instance;
+			}
+
+			if (instance.status === 'error' || instance.status === 'terminated') {
+				throw this.createError(
+					`Instance entered error state: ${instance.status}`,
+					'INSTANCE_ERROR',
+					{ instanceId, status: instance.status }
+				);
+			}
+
+			await this.sleep(pollIntervalMs);
+		}
+
+		throw this.createError(`Timeout waiting for instance status: ${targetStatus}`, 'TIMEOUT', {
+			instanceId,
+			targetStatus,
+			timeoutMs
+		});
+	}
+
+	protected async waitForVolumeStatus(
+		volumeId: string,
+		targetStatus: string,
+		timeoutMs: number = 120000,
+		pollIntervalMs: number = 3000
+	): Promise<CloudVolume> {
+		const startTime = Date.now();
+
+		while (Date.now() - startTime < timeoutMs) {
+			const volumes = await this.listVolumes();
+			const volume = volumes.find((v) => v.id === volumeId);
+
+			if (!volume) {
+				throw this.createError('Volume not found', 'VOLUME_NOT_FOUND', { volumeId });
+			}
+
+			if (volume.status === targetStatus) {
+				return volume;
+			}
+
+			if (volume.status === 'error' || volume.status === 'deleted') {
+				throw this.createError(`Volume entered error state: ${volume.status}`, 'VOLUME_ERROR', {
+					volumeId,
+					status: volume.status
+				});
+			}
+
+			await this.sleep(pollIntervalMs);
+		}
+
+		throw this.createError(`Timeout waiting for volume status: ${targetStatus}`, 'TIMEOUT', {
+			volumeId,
+			targetStatus,
+			timeoutMs
+		});
+	}
+
+	protected createError(message: string, code: string, details?: unknown): CloudProviderError {
+		return new CloudProviderError(message, code, this.name, details);
+	}
+
+	protected sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+
+	protected buildTags(
+		tags: Record<string, string>,
+		additionalTags?: Record<string, string>
+	): Record<string, string> {
+		return {
+			'managed-by': 'vibes',
+			provider: this.name,
+			...tags,
+			...additionalTags
+		};
+	}
+}