@vibesdotdev/infra-core 0.0.1

package/src/kinds/sandbox.kind.ts

@@ -0,0 +1,115 @@
+/**
+ * Kind: infra/sandbox
+ *
+ * Persistent isolated execution environment with shell, filesystem, and
+ * subprocess capabilities. Used for agent code execution, tool sandboxing,
+ * and long-running background tasks.
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base defines fields universal across every adapter:
+ *   id/kind/name + the sandbox shape (entrypoint, image, limits,
+ *   outboundProxy, liveView, persistent, env).
+ * - Adapter-specific fields live under `config`. Each adapter package
+ *   defines its own concrete schema under its discriminator key.
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
+import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime/schemas/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+import { deploymentEnvRequirementSchema } from '../schemas.ts';
+import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
+
+export const SandboxOutboundProxySchema = z.object({
+	binding: z.string().min(1),
+	workerPath: z.string().min(1).optional(),
+	allowedHosts: z.array(z.string()).default([])
+});
+export type SandboxOutboundProxy = z.infer<typeof SandboxOutboundProxySchema>;
+
+export const SandboxResourceLimitsSchema = z.object({
+	cpu: z.string().optional(),
+	memory: z.string().optional(),
+	disk: z.string().optional(),
+	maxSubprocesses: z.number().int().positive().optional(),
+	timeoutSeconds: z.number().int().positive().optional()
+});
+export type SandboxResourceLimits = z.infer<typeof SandboxResourceLimitsSchema>;
+
+const SandboxBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/sandbox'),
+
+	/** Shell or script to run on sandbox start. */
+	entrypoint: z.string().optional(),
+
+	/** Container image or template snapshot. */
+	image: z.string().optional(),
+
+	/** Resource limits. */
+	limits: SandboxResourceLimitsSchema.optional(),
+
+	/** Outbound egress proxy (CF Outbound Workers for Sandboxes). */
+	outboundProxy: SandboxOutboundProxySchema.optional(),
+
+	/** Enable Live View for human-in-loop debugging. */
+	liveView: z.boolean().optional(),
+
+	/** Persist state between sessions. */
+	persistent: z.boolean().optional(),
+
+	/** Environment variable requirements. */
+	env: z.array(deploymentEnvRequirementSchema).optional()
+});
+
+export const CloudflareSandboxConfigSchema = z.object({
+	/** Container image or template snapshot. */
+	image: z.string().optional()
+});
+
+export const DockerSandboxConfigSchema = z.object({
+	/** Container image. */
+	image: z.string(),
+	/** Volume mounts (hostPath: containerPath). */
+	volumes: z.record(z.string(), z.string()).optional()
+});
+
+export const DigitalOceanDropletSandboxConfigSchema = z.object({
+	/** Droplet size slug (e.g., 's-2vcpu-2gb'). */
+	dropletSize: z.string().min(1)
+});
+
+export const SandboxConfigSchema = z.union([
+	CloudflareSandboxConfigSchema.extend({ adapter: z.literal('cloudflare-sandbox') }),
+	DockerSandboxConfigSchema.extend({ adapter: z.literal('docker') }),
+	DigitalOceanDropletSandboxConfigSchema.extend({ adapter: z.literal('digitalocean-droplet') })
+]);
+
+export const SandboxDescriptorSchema = SandboxBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: SandboxConfigSchema.optional()
+});
+
+export type SandboxDescriptor = z.infer<typeof SandboxDescriptorSchema>;
+
+class DefaultSandboxImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): SandboxDescriptor {
+		return this.descriptor as SandboxDescriptor;
+	}
+}
+
+export const sandboxKind = createRuntimeKind<SandboxDescriptor, DefaultSandboxImplementation>({
+	id: 'infra/sandbox',
+	descriptorSchema: SandboxDescriptorSchema,
+	defaultImplementation: DefaultSandboxImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/kinds/web-app.kind.ts

@@ -0,0 +1,103 @@
+/**
+ * Kind: infra/web-app
+ *
+ * Describes a deployable web application (SvelteKit, static site, etc.).
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base defines fields universal across every adapter:
+ *   id/kind/name + the deployment shape every web-app declares
+ *   (domain, appDir, outputDir, runtime, env, dependsOn).
+ * - Adapter-specific fields (cfWorkerName, secretsStoreId, digitaloceanAppName, …)
+ *   live exclusively under `config`. Each adapter package defines its own
+ *   concrete schema under its discriminator key.
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
+import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime/schemas/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+import { deploymentEnvRequirementSchema } from '../schemas.ts';
+import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
+
+export const WebAppDependencySchema = z.object({
+	serviceId: z.string().min(1),
+	reason: z.string().optional()
+});
+export type WebAppDependency = z.infer<typeof WebAppDependencySchema>;
+
+const WebAppBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/web-app'),
+
+	/** Primary domain for this app (e.g., 'auth.vibes.dev'). */
+	domain: z.string().min(1),
+
+	/** Application source directory (e.g., 'apps/auth-web'). */
+	appDir: z.string().min(1),
+
+	/** Build output directory (e.g., '.svelte-kit/cloudflare'). */
+	outputDir: z.string().min(1),
+
+	/** Runtime environment for app deployments. */
+	runtime: z.enum(['edge', 'node']),
+
+	/** Environment variable requirements. */
+	env: z.array(deploymentEnvRequirementSchema).optional(),
+
+	/** Service dependencies. */
+	dependsOn: z.array(WebAppDependencySchema).optional()
+});
+
+export const CloudflareWorkersWebAppConfigSchema = z.object({
+	/** Cloudflare Workers script name (e.g., "vibes-ai"). */
+	cfWorkerName: z.string().min(1),
+	/** Path to the `_worker.js` entry point relative to outputDir. */
+	workerEntry: z.string().min(1).default('_worker.js'),
+	/** Compatibility date for wrangler. */
+	compatibilityDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+	/** Compatibility flags for wrangler. */
+	compatibilityFlags: z.array(z.string()).default(['nodejs_compat']),
+	/** Environment variables to include. */
+	env: z.record(z.string(), z.string()).default({}),
+	/** Cloudflare Secrets Store ID for secret bindings. */
+	secretsStoreId: z.string().min(1).optional()
+});
+
+export const DigitalOceanAppWebAppConfigSchema = z.object({
+	/** DigitalOcean App name. */
+	digitaloceanAppName: z.string().min(1)
+});
+
+export const WebAppConfigSchema = z.union([
+	CloudflareWorkersWebAppConfigSchema.extend({ adapter: z.literal('cloudflare-workers') }),
+	DigitalOceanAppWebAppConfigSchema.extend({ adapter: z.literal('digitalocean-apps') })
+]);
+
+export const WebAppDescriptorSchema = WebAppBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: WebAppConfigSchema.optional()
+});
+
+export type WebAppDescriptor = z.infer<typeof WebAppDescriptorSchema>;
+
+class DefaultWebAppImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): WebAppDescriptor {
+		return this.descriptor as WebAppDescriptor;
+	}
+}
+
+export const webAppKind = createRuntimeKind<WebAppDescriptor, DefaultWebAppImplementation>({
+	id: 'infra/web-app',
+	descriptorSchema: WebAppDescriptorSchema,
+	defaultImplementation: DefaultWebAppImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/kinds/worker.kind.ts

@@ -0,0 +1,203 @@
+/**
+ * Kind: infra/worker
+ *
+ * Describes a background worker process.
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base defines fields universal across adapters: id/kind/name +
+ *   the worker shape (entrypoint, queues, concurrency, scaling, env).
+ * - Adapter-specific fields (namespace, image, healthPort, …) live under
+ *   `config`. Each adapter package defines its own concrete schema.
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
+import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime/schemas/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+import { deploymentEnvRequirementSchema } from '../schemas.ts';
+import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
+
+export const WorkerScalingSchema = z.object({
+	min: z.number().int().nonnegative().default(1),
+	max: z.number().int().positive().default(1),
+	cpu: z.string().optional(),
+	memory: z.string().optional()
+});
+export type WorkerScaling = z.infer<typeof WorkerScalingSchema>;
+
+const WorkerBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/worker'),
+
+	/** Path to worker entrypoint (e.g., 'packages/workers/src/ai/entrypoint.ts'). */
+	entrypoint: z.string().min(1).optional(),
+
+	/** Queue names this worker consumes from. */
+	queues: z.array(z.string().min(1)).optional(),
+
+	/** Worker concurrency. */
+	concurrency: z.number().int().positive().optional(),
+
+	/** Scaling configuration. */
+	scaling: WorkerScalingSchema.optional(),
+
+	/** Environment variable requirements. */
+	env: z.array(deploymentEnvRequirementSchema).optional()
+});
+
+export const DoksDeploymentWorkerConfigSchema = z.object({
+	/** Kubernetes namespace (default: vibes). */
+	namespace: z.string().min(1).default('vibes'),
+	/** Container image (default: vibes/{id}:latest). */
+	image: z.string().min(1).optional(),
+	/** Health probe port (default: 8080). */
+	healthPort: z.number().int().positive().default(8080),
+	/** Health probe path (default: /healthz). */
+	healthPath: z.string().min(1).default('/healthz'),
+	/** Readiness probe path (default: /readyz). */
+	readyPath: z.string().min(1).default('/readyz')
+});
+
+export const CloudflareWorkersWorkerConfigSchema = z.object({
+	/** Cloudflare Workers script name (e.g., "vibes-jobs"). */
+	cfWorkerName: z.string().min(1),
+	/** Path to the `_worker.js` entry point relative to outputDir. */
+	workerEntry: z.string().min(1).default('_worker.js'),
+	/** Compatibility date for wrangler. */
+	compatibilityDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+	/** Compatibility flags for wrangler. */
+	compatibilityFlags: z.array(z.string()).default(['nodejs_compat']),
+	/** Environment variables to include. */
+	env: z.record(z.string(), z.string()).default({}),
+	/** Cloudflare Secrets Store ID for secret bindings. */
+	secretsStoreId: z.string().min(1).optional(),
+	/**
+	 * Detailed queue-consumer config. When present, these override the
+	 * coarse `queues: string[]` field on the base descriptor and let
+	 * declarations control batch size, retries, and dead-letter routing.
+	 */
+	consumers: z
+		.array(
+			z.object({
+				queue: z.string().min(1),
+				maxBatchSize: z.number().int().positive().default(10),
+				maxRetries: z.number().int().min(0).default(3),
+				deadLetterQueue: z.string().optional()
+			})
+		)
+		.default([]),
+	/** Durable Object class bindings. */
+	durableObjects: z
+		.array(
+			z.object({
+				binding: z.string().regex(/^[_A-Z0-9]+$/),
+				className: z.string().min(1),
+				scriptName: z.string().min(1).optional()
+			})
+		)
+		.default([]),
+	/** Durable Object migrations. */
+	migrations: z
+		.array(
+			z.object({
+				tag: z.string().min(1),
+				newClasses: z.array(z.string().min(1)).optional(),
+				renamedClasses: z
+					.array(z.object({ from: z.string().min(1), to: z.string().min(1) }))
+					.optional(),
+				deletedClasses: z.array(z.string().min(1)).optional(),
+				newSqliteClasses: z.array(z.string().min(1)).optional()
+			})
+		)
+		.default([]),
+	/** Service bindings — call other Workers from this Worker. */
+	services: z
+		.array(
+			z.object({
+				binding: z.string().regex(/^[_A-Z0-9]+$/),
+				service: z.string().min(1),
+				environment: z.string().min(1).optional()
+			})
+		)
+		.default([]),
+	/** D1 database bindings. */
+	d1Databases: z
+		.array(
+			z.object({
+				binding: z.string().regex(/^[_A-Z0-9]+$/),
+				databaseName: z.string().min(1),
+				databaseId: z.string().min(1)
+			})
+		)
+		.default([]),
+	/** KV namespace bindings. */
+	kvNamespaces: z
+		.array(
+			z.object({
+				binding: z.string().min(1),
+				id: z.string().min(1)
+			})
+		)
+		.default([]),
+	/** R2 bucket bindings. */
+	r2Buckets: z
+		.array(
+			z.object({
+				binding: z.string().min(1),
+				bucketName: z.string().min(1)
+			})
+		)
+		.default([]),
+	/** Queue producer bindings (worker can also produce to queues). */
+	queueProducers: z
+		.array(
+			z.object({
+				queue: z.string().min(1),
+				binding: z.string().min(1)
+			})
+		)
+		.default([]),
+	/** Enable smart placement. */
+	smartPlacement: z.boolean().default(false),
+	/**
+	 * Whether this is a job-consumer Worker. When true, deploy step
+	 * auto-injects the JOB_RESULT_STORE Durable Object binding +
+	 * initial migration via `generateJobConsumerWorkerConfig` from
+	 * `@vibesdotdev/infra-cloudflare`.
+	 */
+	jobConsumer: z.boolean().default(false)
+});
+
+export const WorkerConfigSchema = z.union([
+	DoksDeploymentWorkerConfigSchema.extend({ adapter: z.literal('doks-deployment') }),
+	CloudflareWorkersWorkerConfigSchema.extend({ adapter: z.literal('cloudflare-workers') })
+]);
+
+export const WorkerDescriptorSchema = WorkerBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: WorkerConfigSchema.optional()
+});
+
+export type WorkerDescriptor = z.infer<typeof WorkerDescriptorSchema>;
+
+class DefaultWorkerImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): WorkerDescriptor {
+		return this.descriptor as WorkerDescriptor;
+	}
+}
+
+export const workerKind = createRuntimeKind<WorkerDescriptor, DefaultWorkerImplementation>({
+	id: 'infra/worker',
+	descriptorSchema: WorkerDescriptorSchema,
+	defaultImplementation: DefaultWorkerImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/schemas.ts

@@ -0,0 +1,127 @@
+import * as z from 'zod/v4';
+
+/**
+ * Deployment providers with active adapter implementations.
+ * Only providers backed by adapter packages are enumerated.
+ * - cloudflare-workers: via infra-cloudflare
+ * - digitalocean-app: via infra-doks
+ */
+export const deploymentProviderSchema = z.enum([
+	'cloudflare-workers',
+	'digitalocean-app'
+]);
+export type DeploymentProvider = z.infer<typeof deploymentProviderSchema>;
+
+/**
+ * Map of valid provider × runtime combinations.
+ * Used for cross-validation in appDeploymentSchema refinement.
+ */
+const VALID_PROVIDER_RUNTIME_MATRIX: Record<DeploymentProvider, readonly string[]> = {
+	'cloudflare-workers': ['edge', 'worker'],
+	'digitalocean-app': ['node', 'worker']
+};
+
+export const appRuntimeSchema = z.enum(['edge', 'node', 'worker', 'browser']);
+export type AppRuntime = z.infer<typeof appRuntimeSchema>;
+
+export const deploymentOriginSchema = z.object({
+	hostname: z.string().min(1),
+	origin: z.string().url(),
+	kind: z.enum(['primary', 'redirect', 'preview', 'internal']).default('primary'),
+	description: z.string().optional()
+});
+export type DeploymentOrigin = z.infer<typeof deploymentOriginSchema>;
+
+export const deploymentBuildSchema = z.object({
+	workspaceRootDir: z.string().min(1).default('.'),
+	appDir: z.string().min(1),
+	installCommand: z.string().min(1).optional(),
+	buildCommand: z.string().min(1),
+	outputDir: z.string().min(1)
+});
+export type DeploymentBuild = z.infer<typeof deploymentBuildSchema>;
+
+export const deploymentEnvRequirementSchema = z.object({
+	name: z.string().regex(/^[_A-Z0-9]+$/),
+	public: z.boolean().optional(),
+	required: z.boolean().optional(),
+	value: z.string().optional(),
+	secret: z.boolean().optional(),
+	description: z.string().optional(),
+	/**
+	 * Override the secret name in the remote store. Defaults to `name` when omitted.
+	 * Only meaningful when `secret: true` and the deployment targets a shared
+	 * Secrets Store binding (e.g. `secrets_store_secrets[].secret_name`).
+	 */
+	storeKey: z.string().min(1).optional()
+});
+export type DeploymentEnvRequirement = z.infer<typeof deploymentEnvRequirementSchema>;
+
+export const deploymentDependencySchema = z.object({
+	appId: z.string().min(1),
+	reason: z.string().min(1)
+});
+export type DeploymentDependency = z.infer<typeof deploymentDependencySchema>;
+
+export const deploymentUpstreamSchema = z.object({
+	name: z.string().min(1),
+	origin: z.string().url(),
+	purpose: z.string().min(1),
+	originEnvVar: z
+		.string()
+		.regex(/^[_A-Z0-9]+$/)
+		.optional()
+});
+export type DeploymentUpstream = z.infer<typeof deploymentUpstreamSchema>;
+
+export const appDeploymentSchema = z
+	.object({
+		appId: z.string().min(1),
+		appName: z.string().min(1),
+		provider: deploymentProviderSchema,
+		runtime: appRuntimeSchema,
+		build: deploymentBuildSchema,
+		origins: z.array(deploymentOriginSchema).min(1),
+		env: z.array(deploymentEnvRequirementSchema).default([]),
+		dependsOn: z.array(deploymentDependencySchema).default([]),
+		upstreams: z.array(deploymentUpstreamSchema).default([]),
+		tags: z.array(z.string()).default([]),
+		/** Cloudflare KV namespace bindings (provider-specific extension). */
+		kvNamespaces: z
+			.array(
+				z.object({
+					binding: z.string().min(1),
+					id: z.string().min(1),
+					preview_id: z.string().optional()
+				})
+			)
+			.default([]),
+		/**
+		 * One-off commands to run before the Worker deploy (e.g. DB migrations,
+		 * seed scripts, cache warmers). Executed sequentially in the appDir.
+		 */
+		preDeployCommands: z
+			.array(
+				z.object({
+					command: z.string().min(1),
+					description: z.string().optional()
+				})
+			)
+			.default([])
+	})
+	.refine(
+		(data: { provider: DeploymentProvider; runtime: string }) => {
+			const validRuntimes = VALID_PROVIDER_RUNTIME_MATRIX[data.provider];
+			return validRuntimes.includes(data.runtime);
+		},
+		{
+			error: (issue) => {
+				const data = issue.input as { provider: DeploymentProvider; runtime: string };
+				return `Invalid runtime "${data.runtime}" for provider "${data.provider}". Valid runtimes: ${VALID_PROVIDER_RUNTIME_MATRIX[data.provider].join(', ')}`;
+			},
+			path: ['runtime']
+		}
+	);
+
+export type AppDeploymentInput = z.input<typeof appDeploymentSchema>;
+export type AppDeployment = z.infer<typeof appDeploymentSchema>;