@vibesdotdev/infra-core 0.0.1 → 1.0.0-rc.11

package/src/kinds/package-registry.kind.ts

@@ -1,95 +0,0 @@
-/**
- * Kind: infra/package-registry
- *
- * Describes a package registry instance (npm, Docker, Maven, Helm, etc.).
- *
- * Schema shape: strict common base + `config` discriminated union.
- *
- * - The base (this file) defines fields that are universal across every
- *   adapter: id/kind/name + the registry shape every package host declares
- *   (url, registryType, scope, upstreamUrl, authRequired, ssl, env).
- * - Adapter-specific fields (dockerImage, storageSize, domain, …)
- *   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 { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-import { deploymentEnvRequirementSchema } from '../schemas.ts';
-
-export const PackageRegistryTypeSchema = z.enum(['npm', 'docker', 'maven', 'helm']);
-export type PackageRegistryType = z.infer<typeof PackageRegistryTypeSchema>;
-
-const PackageRegistryBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/package-registry'),
-
-	/** Primary access URL (e.g. 'https://packages.vibes.dev'). */
-	url: z.string().url(),
-
-	/** Package type this registry serves. */
-	registryType: PackageRegistryTypeSchema.default('npm'),
-
-	/** Npm scope this registry owns (e.g. '@vibesdotdev'). */
-	scope: z.string().optional(),
-
-	/** Upstream registry URL this registry proxies (optional). */
-	upstreamUrl: z.string().url().optional(),
-
-	/** Whether authentication is required to pull from this registry. */
-	authRequired: z.boolean().default(true),
-
-	/** Whether TLS is enabled. */
-	ssl: z.boolean().default(true),
-
-	/** Environment variable requirements. */
-	env: z.array(deploymentEnvRequirementSchema).optional()
-});
-
-export const VerdaccioDoksPackageRegistryConfigSchema = z.object({
-	/** Docker image for the Verdaccio container. */
-	dockerImage: z.string().default('verdaccio/verdaccio:5'),
-	/** Persistent storage size (e.g. '10Gi'). */
-	storageSize: z.string().default('10Gi'),
-	/** Primary domain for the registry. */
-	domain: z.string().min(1),
-	/** Upstream npm registry URL to proxy. */
-	upstreamNpmUrl: z.string().url().default('https://registry.npmjs.org'),
-	/** Whether built-in authentication is enabled. */
-	authEnabled: z.boolean().default(true)
-});
-
-export const PackageRegistryConfigSchema = z.union([
-	VerdaccioDoksPackageRegistryConfigSchema.extend({ adapter: z.literal('verdaccio-doks') })
-]);
-
-export const PackageRegistryDescriptorSchema = PackageRegistryBaseSchema.extend({
-	/**
-	 * Adapter-specific configuration. Discriminated union — each adapter
-	 * package defines its own config schema under its discriminator key.
-	 */
-	config: PackageRegistryConfigSchema.optional()
-});
-
-export type PackageRegistryDescriptor = z.infer<typeof PackageRegistryDescriptorSchema>;
-
-class DefaultPackageRegistryImplementation {
-	constructor(
-		public readonly descriptor: RuntimeDescriptor,
-		public readonly context: unknown
-	) {}
-
-	get config(): PackageRegistryDescriptor {
-		return this.descriptor as PackageRegistryDescriptor;
-	}
-}
-
-export const packageRegistryKind = createRuntimeKind<PackageRegistryDescriptor, DefaultPackageRegistryImplementation>({
-	id: 'infra/package-registry',
-	descriptorSchema: PackageRegistryDescriptorSchema,
-	defaultImplementation: DefaultPackageRegistryImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});

package/src/kinds/queue.kind.ts

@@ -1,102 +0,0 @@
-/**
- * Kind: infra/queue
- *
- * Describes a message queue system.
- *
- * Schema shape: strict common base + `config` discriminated union.
- *
- * - The base defines fields universal across adapters: id/kind/name +
- *   the queue shape (engine, topics, maxBatchSize, maxRetries, deadLetterQueue).
- * - Adapter-specific fields (namespace, storageSize, resources, …) 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 { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-export const QueueTopicSchema = z.object({
-	name: z.string().min(1),
-	partitions: z.number().int().positive().optional(),
-	retention: z.string().optional(),
-	replication: z.number().int().positive().optional()
-});
-export type QueueTopic = z.infer<typeof QueueTopicSchema>;
-
-const QueueBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/queue'),
-
-	/** Queue engine (e.g., 'cloudflare-queues', 'redpanda'). */
-	engine: z.string().min(1).optional(),
-
-	/** Topic / queue declarations. */
-	topics: z.array(QueueTopicSchema).optional(),
-
-	/** Maximum batch size. */
-	maxBatchSize: z.number().int().positive().optional(),
-
-	/** Maximum retry count. */
-	maxRetries: z.number().int().nonnegative().optional(),
-
-	/** Dead-letter queue id. */
-	deadLetterQueue: z.string().optional()
-});
-
-export const DoksQueueConfigSchema = z.object({
-	/** Kubernetes namespace (default: vibes). */
-	namespace: z.string().min(1).default('vibes'),
-	/** Storage size for data volume (default: 10Gi). */
-	storageSize: z.string().min(1).default('10Gi'),
-	/** Container resources. */
-	resources: z
-		.object({
-			requests: z.object({ cpu: z.string().min(1), memory: z.string().min(1) }).optional(),
-			limits: z.object({ cpu: z.string().min(1), memory: z.string().min(1) }).optional()
-		})
-		.optional()
-});
-
-export const CloudflareQueuesConfigSchema = z.object({
-	/** Maximum batch size per message. */
-	maxBatchSize: z.number().int().positive().default(10),
-	/** Maximum retry count. */
-	maxRetries: z.number().int().nonnegative().default(3),
-	/** Dead-letter queue id. */
-	deadLetterQueue: z.string().min(1).optional()
-});
-
-export const QueueConfigSchema = z.union([
-	DoksQueueConfigSchema.extend({ adapter: z.literal('doks-statefulset') }),
-	CloudflareQueuesConfigSchema.extend({ adapter: z.literal('cloudflare-queues') })
-]);
-
-export const QueueDescriptorSchema = QueueBaseSchema.extend({
-	/**
-	 * Adapter-specific configuration. Discriminated union — each adapter
-	 * package defines its own config schema under its discriminator key.
-	 */
-	config: QueueConfigSchema.optional()
-});
-
-export type QueueDescriptor = z.infer<typeof QueueDescriptorSchema>;
-
-class DefaultQueueImplementation {
-	constructor(
-		public readonly descriptor: RuntimeDescriptor,
-		public readonly context: unknown
-	) {}
-
-	get config(): QueueDescriptor {
-		return this.descriptor as QueueDescriptor;
-	}
-}
-
-export const queueKind = createRuntimeKind<QueueDescriptor, DefaultQueueImplementation>({
-	id: 'infra/queue',
-	descriptorSchema: QueueDescriptorSchema,
-	defaultImplementation: DefaultQueueImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});

package/src/kinds/rum.kind.ts

@@ -1,135 +0,0 @@
-/**
- * Infra RUM (Real User Monitoring) Kind
- *
- * Provider-agnostic schema for beacon-based front-end telemetry —
- * page-load timing, Core Web Vitals, navigation timing. Provider impls
- * map this shape onto native services:
- *
- *   cloudflare-web-analytics → CF Web Analytics (sites + auto-injection rules)
- *   sentry-replay            → Sentry Performance + Session Replay
- *   plausible                → Plausible Analytics
- *
- * The kind decouples *configuration* (which hostnames, which token,
- * which privacy mode) from *delivery* (how the beacon `<script>` tag
- * lands in the HTML). For SvelteKit apps, the
- * `@vibesdotdev/cloudflare-web-analytics` package provides a `handle`
- * hook that injects the beacon via `transformPageChunk` — no
- * per-app `app.html` edits required once the kind is wired in.
- */
-
-import * as z from 'zod/v4';
-import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
-import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
-import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-const RumPrivacySchema = z.object({
-	/** Drop EU visitor data at the beacon level (GDPR fast path). */
-	excludeEU: z.boolean().default(false),
-	/** Honor Do-Not-Track / Global Privacy Control headers. */
-	respectDoNotTrack: z.boolean().default(true),
-	/** Strip PII (query params, fragments) from reported URLs. */
-	stripQueryParams: z.boolean().default(false)
-});
-
-export type RumPrivacy = z.infer<typeof RumPrivacySchema>;
-
-/**
- * Where + how the beacon `<script>` lands in the served HTML.
- *
- *   app-html               → bake the snippet into app.html (manual; pre-Phase 3)
- *   sveltekit-hook         → injected via `transformPageChunk` in handle hook (preferred)
- *   provider-auto          → provider auto-injection (CF: only works on non-Worker traffic)
- *   custom                 → caller injects however they want; we just track config
- */
-const RumInjectionSchema = z.enum([
-	'app-html',
-	'sveltekit-hook',
-	'provider-auto',
-	'custom'
-]);
-
-export type RumInjection = z.infer<typeof RumInjectionSchema>;
-
-const RumBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/rum'),
-	adapter: z.string().min(1),
-	adapterConfig: z.record(z.string(), z.unknown()).optional(),
-	environment: z.string().default('local'),
-	/**
-	 * Public site token (a.k.a. site_tag / beacon token / measurement
-	 * id). Provider-specific format; safe to commit because it's
-	 * embedded in client-side HTML for every visitor to see.
-	 *
-	 * Pass `{ source: 'secret', key: 'NAME' }` only when the provider
-	 * explicitly wants a private token — most don't.
-	 */
-	siteToken: z.union([
-		z.string().min(1),
-		z.object({ source: z.literal('secret'), key: z.string().min(1) })
-	]),
-	/** Hostnames the beacon should report from. `*` matches all subdomains. */
-	hostnames: z.array(z.string().min(1)).default(['*']),
-	injection: RumInjectionSchema.default('sveltekit-hook'),
-	privacy: RumPrivacySchema.default(() => ({
-		excludeEU: false,
-		respectDoNotTrack: true,
-		stripQueryParams: false
-	})),
-	/** Whether the site is currently enabled. Provider impls read+write this. */
-	enabled: z.boolean().default(true)
-});
-
-export type InfraRumDescriptor = z.infer<typeof RumBaseSchema>;
-export type InfraRumDescriptorInput = z.input<typeof RumBaseSchema>;
-
-/**
- * Snapshot of a single configured RUM site on the provider. Returned
- * by `listSites`; consumed by the CLI for table rendering and drift
- * detection.
- */
-export interface RumSiteSnapshot {
-	/** Provider-assigned site id (CF: site_tag). */
-	siteTag: string;
-	/** Friendly name (often the apex hostname). */
-	name?: string;
-	hostnames: string[];
-	enabled: boolean;
-	injection?: RumInjection;
-	/** Page-views captured in the last 24h (when available). */
-	pageViews24h?: number;
-	createdAt?: string;
-}
-
-export interface RumImplementation {
-	/** Enumerate the configured RUM sites on the provider. */
-	listSites(): Promise<RumSiteSnapshot[]>;
-	/** Look up a single site by siteTag. */
-	getSite(siteTag: string): Promise<RumSiteSnapshot | null>;
-	/**
-	 * Ensure a site exists matching the descriptor; returns the
-	 * siteTag (provider-assigned id) and whether it was created or
-	 * already existed.
-	 */
-	ensureSite(descriptor: InfraRumDescriptor): Promise<{
-		siteTag: string;
-		created: boolean;
-	}>;
-	/** Toggle enabled state. */
-	setEnabled(siteTag: string, enabled: boolean): Promise<void>;
-}
-
-export const rumKind = createRuntimeKind<InfraRumDescriptor, RumImplementation>({
-	id: 'infra/rum',
-	descriptorSchema: RumBaseSchema,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});
-
-export type InfraRumKind = InfraRumDescriptor;
-export type InfraRumKindInput = InfraRumDescriptorInput;
-
-export {
-	RumBaseSchema as InfraRumDescriptorSchema,
-	RumPrivacySchema,
-	RumInjectionSchema
-};

package/src/kinds/sandbox.kind.ts

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,103 +0,0 @@
-/**
- * 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
-});