@vibesdotdev/infra-core 0.0.1

package/src/kinds/artifact.kind.ts

@@ -0,0 +1,96 @@
+/**
+ * Kind: infra/artifact
+ *
+ * Generic descriptor for generatable infrastructure artifacts.
+ *
+ * This kind is intentionally unopinionated about what gets generated.
+ * Adapter implementations (infra-kubernetes, infra-helm, infra-cloudflare, etc.)
+ * define their own descriptor shapes and generation logic.
+ *
+ * Usage pattern:
+ * 1. Adapters register artifact generators with custom descriptors
+ * 2. Query: runtime.query('infra/artifact').all()
+ * 3. Resolve implementation and call its generate method
+ * 4. Implementation returns artifact content (format determined by impl)
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
+
+/**
+ * Minimal base schema for artifact descriptors.
+ *
+ * Implementations extend this with their own fields (source resources,
+ * output format, generation options, etc.).
+ */
+const ArtifactBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/artifact')
+});
+
+/**
+ * Generic artifact generator interface.
+ *
+ * Implementations define their own input/output shapes.
+ */
+export interface ArtifactGenerator {
+	/**
+	 * Generate artifact content.
+	 *
+	 * @param options - Implementation-specific options (descriptor, context, etc.)
+	 * @returns Generated artifact (content + metadata)
+	 */
+	generate(options?: unknown): Promise<ArtifactOutput>;
+}
+
+/**
+ * Generated artifact output (generic shape).
+ *
+ * Implementations may return more specific types.
+ */
+export interface ArtifactOutput {
+	/** Generated content (string for text formats, Buffer for binary) */
+	content: string | Buffer;
+	/** Recommended filename (including extension) */
+	filename: string;
+	/** Full output path */
+	path: string;
+	/** Optional metadata */
+	metadata?: Record<string, unknown>;
+}
+
+/**
+ * Artifact descriptor type (base shape, implementations extend)
+ */
+export type ArtifactDescriptor = z.infer<typeof ArtifactBaseSchema>;
+
+/**
+ * Artifact descriptor schema
+ */
+export const ArtifactDescriptorSchema = ArtifactBaseSchema;
+
+/**
+ * Artifact kind descriptor for runtime registration.
+ *
+ * Note: This kind has no default implementation. Adapters must register
+ * their own implementations via runtime plugins.
+ */
+class NoOpArtifactImplementation implements ArtifactGenerator {
+	async generate(options?: unknown): Promise<ArtifactOutput> {
+		throw new Error(
+			'No artifact generator registered. Adapter plugins (infra-kubernetes, infra-helm, etc.) must register implementations.'
+		);
+	}
+}
+
+export const artifactKind = createRuntimeKind<ArtifactDescriptor, NoOpArtifactImplementation>({
+	id: 'infra/artifact',
+	descriptorSchema: ArtifactDescriptorSchema,
+	defaultImplementation: NoOpArtifactImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});
+
+// Re-export discovery helpers
+export { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';

package/src/kinds/cache.kind.ts

@@ -0,0 +1,104 @@
+/**
+ * Kind: infra/cache
+ *
+ * Describes a cache service.
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base defines fields universal across adapters: id/kind/name +
+ *   the cache shape (engine, maxMemory, eviction, namespace).
+ * - Adapter-specific fields (region, version, numNodes, size, …)
+ *   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';
+
+const CacheBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/cache'),
+
+	/** Cache engine (e.g., 'cloudflare-kv', 'redis'). */
+	engine: z.string().min(1).optional(),
+
+	/** Maximum memory hint. */
+	maxMemory: z.string().optional(),
+
+	/** Eviction policy. */
+	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
+
+	/** Logical namespace within the cache. */
+	namespace: z.string().optional()
+});
+
+export const DOManagedRedisConfigSchema = z.object({
+	/** Max memory allocation (e.g., '256mb', '1gb'). */
+	maxMemory: z.string().min(1).optional(),
+	/** Eviction policy: lru, lfu, or ttl. */
+	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
+	/** DO region (default: nyc1). */
+	region: z.string().min(1).default('nyc1'),
+	/** Redis version (default: 7). */
+	version: z.string().min(1).default('7'),
+	/** Number of nodes (default: 1). */
+	numNodes: z.number().int().positive().default(1),
+	/** Database size tier (optional, derived from maxMemory if not set). */
+	size: z.string().min(1).optional()
+});
+
+export const CloudflareKVCacheConfigSchema = z.object({
+	/** Logical namespace within the KV store. */
+	namespace: z.string().min(1)
+});
+
+export const DOKSRedisCacheConfigSchema = z.object({
+	/** Kubernetes namespace (default: vibes). */
+	namespace: z.string().min(1).default('vibes'),
+	/** Container image (default: redis:{version}). */
+	image: z.string().min(1).optional(),
+	/** Redis version (default: 7). */
+	version: z.string().min(1).default('7'),
+	/** Max memory allocation (e.g., '256mb'). */
+	maxMemory: z.string().optional(),
+	/** Eviction policy: lru, lfu, or ttl. */
+	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
+	/** Storage size (default: 1Gi). */
+	storageSize: z.string().min(1).default('1Gi')
+});
+
+export const CacheConfigSchema = z.union([
+	DOManagedRedisConfigSchema.extend({ adapter: z.literal('do-managed-redis') }),
+	CloudflareKVCacheConfigSchema.extend({ adapter: z.literal('cloudflare-kv') }),
+	DOKSRedisCacheConfigSchema.extend({ adapter: z.literal('doks-redis') })
+]);
+
+export const CacheDescriptorSchema = CacheBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: CacheConfigSchema.optional()
+});
+
+export type CacheDescriptor = z.infer<typeof CacheDescriptorSchema>;
+
+class DefaultCacheImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): CacheDescriptor {
+		return this.descriptor as CacheDescriptor;
+	}
+}
+
+export const cacheKind = createRuntimeKind<CacheDescriptor, DefaultCacheImplementation>({
+	id: 'infra/cache',
+	descriptorSchema: CacheDescriptorSchema,
+	defaultImplementation: DefaultCacheImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/kinds/database.kind.ts

@@ -0,0 +1,120 @@
+/**
+ * Kind: infra/database
+ *
+ * Describes a database instance.
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base defines fields universal across adapters: id/kind/name +
+ *   the database shape (engine, size, replicas, backups).
+ * - Adapter-specific fields (namespace, storageSize, version, region, …)
+ *   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 DatabaseBackupSchema = z.object({
+	enabled: z.boolean().default(false),
+	schedule: z.string().optional(),
+	retention: z.string().optional()
+});
+export type DatabaseBackup = z.infer<typeof DatabaseBackupSchema>;
+
+const DatabaseBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/database'),
+
+	/** Database engine (e.g., 'turso', 'postgres'). */
+	engine: z.string().min(1).optional(),
+
+	/** Instance size hint. */
+	size: z.string().optional(),
+
+	/** Replica count. */
+	replicas: z.number().int().nonnegative().optional(),
+
+	/** Backup configuration. */
+	backups: DatabaseBackupSchema.optional()
+});
+
+export const DoksDatabaseConfigSchema = z.object({
+	/** Kubernetes namespace (default: vibes). */
+	namespace: z.string().min(1).default('vibes'),
+	/** Storage size for pgdata 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(),
+	/** Postgres version tag (default: 16-alpine). */
+	version: z.string().min(1).default('16-alpine')
+});
+
+export const DOManagedPostgresConfigSchema = z.object({
+	/** Database size tier (default: db-s-1vcpu-1gb). */
+	size: z.string().min(1).default('db-s-1vcpu-1gb'),
+	/** DO region (default: nyc1). */
+	region: z.string().min(1).default('nyc1'),
+	/** Postgres version (default: 16). */
+	version: z.string().min(1).default('16')
+});
+
+export const TursoDatabaseConfigSchema = z.object({
+	/** Turso database name (defaults to descriptor id). */
+	database: z.string().min(1).optional(),
+	/** Edge region for replication (default: aws:iad1). */
+	region: z.string().min(1).default('aws:iad1')
+});
+
+export const CloudflareD1ConfigSchema = z.object({
+	/** D1 adapter name (always 'cloudflare-d1'). */
+	adapter: z.literal('cloudflare-d1'),
+	/** Binding name for D1 in Cloudflare Workers (default: 'DB'). */
+	binding: z.string().min(1).default('DB'),
+	/** D1 database name. */
+	databaseName: z.string().min(1),
+	/** ID of the consuming app (for wrangler.jsonc generation). */
+	consumerAppId: z.string().min(1)
+});
+
+export const DatabaseConfigSchema = z.union([
+	DoksDatabaseConfigSchema.extend({ adapter: z.literal('doks-statefulset') }),
+	DOManagedPostgresConfigSchema.extend({ adapter: z.literal('do-managed-postgres') }),
+	TursoDatabaseConfigSchema.extend({ adapter: z.literal('turso') }),
+	CloudflareD1ConfigSchema
+]);
+
+export const DatabaseDescriptorSchema = DatabaseBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: DatabaseConfigSchema.optional()
+});
+
+export type DatabaseDescriptor = z.infer<typeof DatabaseDescriptorSchema>;
+
+class DefaultDatabaseImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): DatabaseDescriptor {
+		return this.descriptor as DatabaseDescriptor;
+	}
+}
+
+export const databaseKind = createRuntimeKind<DatabaseDescriptor, DefaultDatabaseImplementation>({
+	id: 'infra/database',
+	descriptorSchema: DatabaseDescriptorSchema,
+	defaultImplementation: DefaultDatabaseImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/kinds/discovery.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared discovery helpers for infra resource kinds.
+ *
+ * All infra kinds use the same discovery pattern for *.infra.ts files.
+ */
+
+/**
+ * Glob pattern for discovering infra resource declaration files.
+ */
+export const INFRA_DISCOVERY_PATTERN = '**/*.infra.ts';
+
+/**
+ * Extract the stem (base name without extension) from an infra file.
+ * Matches both .infra.ts and .infra.tsx extensions.
+ *
+ * @example
+ * extractStem('auth.infra.ts') // 'auth'
+ * extractStem('my-service.infra.tsx') // 'my-service'
+ * extractStem('not-infra.ts') // null
+ */
+export function extractStem(filename: string): string | null {
+	const match = filename.match(/^(.+)\.infra\.tsx?$/);
+	const stem = match ? match[1]! : null;
+	// Return null for empty stem (e.g., '.infra.ts')
+	return stem && stem.length > 0 ? stem : null;
+}

package/src/kinds/git-hosting.kind.ts

@@ -0,0 +1,100 @@
+/**
+ * Kind: infra/git-hosting
+ *
+ * Describes a git hosting service instance (e.g. Gitea, Forgejo).
+ *
+ * Schema shape: strict common base + `config` discriminated union.
+ *
+ * - The base (this file) defines fields that are universal across every
+ *   adapter: id/kind/name + the hosting shape every git host declares
+ *   (domain, url, storagePath, authMethod, etc.).
+ * - Adapter-specific fields (dropletSize, dockerImage, volumeSizeGb, …)
+ *   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 GitHostingTypeSchema = z.enum(['gitea', 'forgejo']);
+export type GitHostingType = z.infer<typeof GitHostingTypeSchema>;
+
+export const GitHostingAuthMethodSchema = z.enum(['local', 'oauth', 'token']);
+export type GitHostingAuthMethod = z.infer<typeof GitHostingAuthMethodSchema>;
+
+const GitHostingBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/git-hosting'),
+
+	/** Primary access URL (e.g. 'https://git.vibes.dev'). */
+	url: z.string().url(),
+
+	/** Hostname for DNS resolution (e.g. 'git.vibes.dev'). */
+	hostname: z.string().min(1),
+
+	/** Git hosting software type. */
+	type: GitHostingTypeSchema,
+
+	/** Storage mount path inside the container. */
+	storagePath: z.string().min(1).default('/data'),
+
+	/** Authentication method. */
+	authMethod: GitHostingAuthMethodSchema.default('token'),
+
+	/** Whether TLS is enabled. */
+	ssl: z.boolean().default(true),
+
+	/** Environment variable requirements. */
+	env: z.array(deploymentEnvRequirementSchema).optional()
+});
+
+export const GiteaDoksGitHostingConfigSchema = z.object({
+	/** DigitalOcean Droplet size. */
+	dropletSize: z.string().default('s-2vcpu-2gb'),
+	/** Docker image for the Gitea container. */
+	dockerImage: z.string().default('gitea/gitea:1.21'),
+	/** Volume size in GiB for persistent storage. */
+	volumeSizeGb: z.number().int().positive().default(50),
+	/** Primary domain for the Gitea instance. */
+	domain: z.string().min(1),
+	/** SSH port exposed on the service. */
+	sshPort: z.number().int().positive().default(22),
+	/** HTTP port exposed on the service. */
+	httpPort: z.number().int().positive().default(3000)
+});
+
+export const GitHostingConfigSchema = z.union([
+	GiteaDoksGitHostingConfigSchema.extend({ adapter: z.literal('gitea-doks') })
+]);
+
+export const GitHostingDescriptorSchema = GitHostingBaseSchema.extend({
+	/**
+	 * Adapter-specific configuration. Discriminated union — each adapter
+	 * package defines its own config schema under its discriminator key.
+	 */
+	config: GitHostingConfigSchema.optional()
+});
+
+export type GitHostingDescriptor = z.infer<typeof GitHostingDescriptorSchema>;
+
+class DefaultGitHostingImplementation {
+	constructor(
+		public readonly descriptor: RuntimeDescriptor,
+		public readonly context: unknown
+	) {}
+
+	get config(): GitHostingDescriptor {
+		return this.descriptor as GitHostingDescriptor;
+	}
+}
+
+export const gitHostingKind = createRuntimeKind<GitHostingDescriptor, DefaultGitHostingImplementation>({
+	id: 'infra/git-hosting',
+	descriptorSchema: GitHostingDescriptorSchema,
+	defaultImplementation: DefaultGitHostingImplementation,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});

package/src/kinds/index.ts

@@ -0,0 +1,139 @@
+export { webAppKind, WebAppDescriptorSchema, WebAppConfigSchema, CloudflareWorkersWebAppConfigSchema, DigitalOceanAppWebAppConfigSchema, type WebAppDescriptor, type WebAppDependency } from './web-app.kind';
+export {
+	workerKind,
+	WorkerDescriptorSchema,
+	WorkerConfigSchema,
+	DoksDeploymentWorkerConfigSchema,
+	WorkerScalingSchema,
+	type WorkerDescriptor,
+	type WorkerScaling
+} from './worker.kind';
+export {
+	databaseKind,
+	DatabaseDescriptorSchema,
+	DatabaseConfigSchema,
+	DoksDatabaseConfigSchema,
+	DOManagedPostgresConfigSchema,
+	TursoDatabaseConfigSchema,
+	CloudflareD1ConfigSchema,
+	DatabaseBackupSchema,
+	type DatabaseDescriptor,
+	type DatabaseBackup
+} from './database.kind';
+export {
+	queueKind,
+	QueueDescriptorSchema,
+	QueueConfigSchema,
+	DoksQueueConfigSchema,
+	QueueTopicSchema,
+	type QueueDescriptor,
+	type QueueTopic
+} from './queue.kind';
+export { cacheKind, CacheDescriptorSchema, CacheConfigSchema, DOManagedRedisConfigSchema, type CacheDescriptor } from './cache.kind';
+export {
+	objectStorageKind,
+	ObjectStorageDescriptorSchema,
+	ObjectStorageConfigSchema,
+	DOSpacesConfigSchema,
+	CorsRuleSchema,
+	LifecycleRuleSchema,
+	type ObjectStorageDescriptor,
+	type CorsRule,
+	type LifecycleRule
+} from './object-storage.kind';
+export {
+	sandboxKind,
+	SandboxDescriptorSchema,
+	SandboxConfigSchema,
+	CloudflareSandboxConfigSchema,
+	DockerSandboxConfigSchema,
+	DigitalOceanDropletSandboxConfigSchema,
+	SandboxOutboundProxySchema,
+	SandboxResourceLimitsSchema,
+	type SandboxDescriptor,
+	type SandboxOutboundProxy,
+	type SandboxResourceLimits
+} from './sandbox.kind';
+export {
+	gitHostingKind,
+	GitHostingDescriptorSchema,
+	GitHostingConfigSchema,
+	GiteaDoksGitHostingConfigSchema,
+	GitHostingTypeSchema,
+	GitHostingAuthMethodSchema,
+	type GitHostingDescriptor,
+	type GitHostingType,
+	type GitHostingAuthMethod
+} from './git-hosting.kind';
+export {
+	packageRegistryKind,
+	PackageRegistryDescriptorSchema,
+	PackageRegistryConfigSchema,
+	VerdaccioDoksPackageRegistryConfigSchema,
+	PackageRegistryTypeSchema,
+	type PackageRegistryDescriptor,
+	type PackageRegistryType
+} from './package-registry.kind';
+export {
+	logsKind,
+	InfraLogsDescriptorSchema,
+	type InfraLogsDescriptor,
+	type InfraLogsDescriptorInput,
+	type InfraLogsKind,
+	type InfraLogsKindInput,
+	type LogsImplementation
+} from './logs.kind';
+export {
+	artifactKind,
+	ArtifactDescriptorSchema,
+	type ArtifactDescriptor,
+	type ArtifactGenerator,
+	type ArtifactOutput
+} from './artifact.kind';
+export {
+	alertsKind,
+	InfraAlertsDescriptorSchema,
+	AlertPolicySchema,
+	AlertMechanismSchema,
+	AlertTypeSchema,
+	AlertWindowSchema,
+	type InfraAlertsDescriptor,
+	type InfraAlertsDescriptorInput,
+	type InfraAlertsKind,
+	type InfraAlertsKindInput,
+	type AlertsImplementation,
+	type AlertPolicy,
+	type AlertMechanism,
+	type AlertType
+} from './alerts.kind.ts';
+export {
+	observabilityKind,
+	InfraObservabilityDescriptorSchema,
+	ObservabilityScopeSchema,
+	ObservabilitySettingsSchema,
+	type InfraObservabilityDescriptor,
+	type InfraObservabilityDescriptorInput,
+	type InfraObservabilityKind,
+	type InfraObservabilityKindInput,
+	type ObservabilityImplementation,
+	type ObservabilityScope,
+	type ObservabilitySettings,
+	type ObservabilitySnapshot,
+	type SetObservabilityInput,
+	type SetObservabilityResult
+} from './observability.kind.ts';
+export {
+	rumKind,
+	InfraRumDescriptorSchema,
+	RumPrivacySchema,
+	RumInjectionSchema,
+	type InfraRumDescriptor,
+	type InfraRumDescriptorInput,
+	type InfraRumKind,
+	type InfraRumKindInput,
+	type RumImplementation,
+	type RumSiteSnapshot,
+	type RumPrivacy,
+	type RumInjection
+} from './rum.kind.ts';
+export { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';

package/src/kinds/logs.kind.ts

@@ -0,0 +1,104 @@
+/**
+ * Infra Logs Kind
+ *
+ * Descriptor schema for log sources (Workers, Pages, D1, etc.)
+ * Provides programmatic access to logs for tailing, queries, and analytics.
+ */
+
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
+import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
+
+const LogsBaseSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('infra/logs'),
+	/** Adapter type (e.g., 'cloudflare-logs', 'datadog', 'splunk') */
+	adapter: z.string().min(1),
+	/** Adapter-specific configuration */
+	adapterConfig: z.record(z.string(), z.unknown()).optional(),
+	/** Log sources to monitor */
+	sources: z
+		.array(
+			z.object({
+				/** Source type */
+				type: z.enum(['worker', 'pages', 'd1', 'r2', 'kv']),
+				/** Source name/identifier */
+				name: z.string().min(1),
+				/** Optional environment filter */
+				environment: z.string().optional()
+			})
+		)
+		.default([]),
+	/** Default retention period */
+	retention: z
+		.object({
+			/** Hot storage (immediately accessible) */
+			hotDays: z.number().int().positive().default(7),
+			/** Cold storage (requires retrieval) */
+			coldDays: z.number().int().positive().default(30)
+		})
+		.optional(),
+	/** Alerting configuration */
+	alerts: z
+		.array(
+			z.object({
+				/** Alert name */
+				name: z.string().min(1),
+				/** Alert condition */
+				condition: z.enum(['errorRate', 'duration', 'invocationCount']),
+				/** Threshold value */
+				threshold: z.number(),
+				/** Time window for evaluation */
+				window: z.string(),
+				/** Notification channels */
+				channels: z.array(z.string()).default([])
+			})
+		)
+		.default([])
+});
+
+export const InfraLogsDescriptorSchema = LogsBaseSchema;
+export type InfraLogsDescriptor = z.infer<typeof InfraLogsDescriptorSchema>;
+export type InfraLogsDescriptorInput = z.input<typeof InfraLogsDescriptorSchema>;
+
+export interface LogsImplementation {
+	/** Stream logs in real-time (returns WebSocket URL) */
+	tailLogs(sourceName: string, options?: { status?: 'ok' | 'error' | 'canceled'; limit?: number }): Promise<{ tailId: string; websocketUrl: string }>;
+	/** Stop a log tail session */
+	stopTail(sourceName: string, tailId: string): Promise<void>;
+	/** List active tail sessions */
+	listTails(sourceName: string): Promise<Array<{ id: string; createdAt: string }>>;
+	/** Get analytics summary */
+	getAnalytics(sourceName: string, timeRange?: { timeStart: string; timeEnd?: string }): Promise<{ totalInvocations: number; errorCount: number; errorRate: number; avgDurationMs: number; p99DurationMs: number; totalCpuTimeMs: number }>;
+	/** Get error rate */
+	getErrorRate(sourceName: string, timeRange?: { timeStart: string; timeEnd?: string }): Promise<number>;
+}
+
+export interface DefaultLogsImplementation {
+	generateConfig: () => InfraLogsDescriptor;
+}
+
+class DefaultLogsImplementationClass implements DefaultLogsImplementation {
+	generateConfig(): InfraLogsDescriptor {
+		return {
+			kind: 'infra/logs',
+			id: 'default-logs',
+			name: 'Default Logs',
+			adapter: 'unknown',
+			sources: [],
+			alerts: []
+		};
+	}
+}
+
+export const logsKind = createRuntimeKind<InfraLogsDescriptor, DefaultLogsImplementation>({
+	id: 'infra/logs',
+	descriptorSchema: InfraLogsDescriptorSchema,
+	defaultImplementation: DefaultLogsImplementationClass,
+	discoveryPattern: INFRA_DISCOVERY_PATTERN,
+	extractStem
+});
+
+export type InfraLogsKind = InfraLogsDescriptor;
+export type InfraLogsKindInput = InfraLogsDescriptorInput;