@vibesdotdev/infra-deploy 0.0.1

package/src/cli/audit/infra-audit.cli-command.impl.ts

@@ -0,0 +1,293 @@
+/**
+ * `vibes infra audit`
+ *
+ * Composes existing infra/* implementations into one human-readable
+ * report. Mirrors the manual CF dashboard sweep we keep doing:
+ *
+ *   - infra/alerts:   policies configured (or "GAP" if none)
+ *   - infra/logs:     log sources, retention, analytics-snapshot
+ *   - (future: infra/observability, infra/rum, infra/worker stats)
+ *
+ * Read-only. Never modifies provider state. `--output json` emits a
+ * structured payload for piping into ops dashboards.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { type UIContext } from '@vibesdotdev/cli/providers';
+import type {
+	AlertsImplementation,
+	AlertPolicy,
+	InfraAlertsDescriptor,
+	InfraLogsDescriptor,
+	InfraObservabilityDescriptor,
+	ObservabilityImplementation,
+	ObservabilitySnapshot
+} from '@vibesdotdev/infra-core/kinds';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+interface AlertsSection {
+	providers: Array<{
+		descriptorId: string;
+		adapter: string;
+		policies: Array<AlertPolicy & { providerId: string }>;
+		error?: string;
+	}>;
+	gaps: string[];
+}
+
+interface LogsSection {
+	providers: Array<{
+		descriptorId: string;
+		adapter: string;
+		sources: InfraLogsDescriptor['sources'];
+		retention?: InfraLogsDescriptor['retention'];
+		alertsConfigured: number;
+		error?: string;
+	}>;
+}
+
+interface ObservabilitySection {
+	providers: Array<{
+		descriptorId: string;
+		adapter: string;
+		workerCount: number;
+		minSampling?: number;
+		maxSampling?: number;
+		avgSampling?: number;
+		overSampledWorkers: string[];
+		error?: string;
+	}>;
+	gaps: string[];
+}
+
+interface AuditReport {
+	timestamp: string;
+	alerts?: AlertsSection;
+	logs?: LogsSection;
+	observability?: ObservabilitySection;
+	notes: string[];
+}
+
+async function gatherAlerts(runtime: ReturnType<typeof getVibesRuntime>): Promise<AlertsSection> {
+	const section: AlertsSection = { providers: [], gaps: [] };
+	if (!runtime.hasKind('infra/alerts')) {
+		section.gaps.push('infra/alerts kind not registered — no provider plugin loaded for alerting.');
+		return section;
+	}
+	const descriptors = runtime.assets('infra/alerts').descriptors() as InfraAlertsDescriptor[];
+	if (descriptors.length === 0) {
+		section.gaps.push('No infra/alerts descriptors registered.');
+		return section;
+	}
+	for (const d of descriptors) {
+		try {
+			const impl = (await runtime
+				.query('infra/alerts')
+				.withId(d.id)
+				.resolve()) as AlertsImplementation;
+			const policies = await impl.listPolicies();
+			section.providers.push({ descriptorId: d.id, adapter: d.adapter, policies });
+			if (policies.length === 0) {
+				section.gaps.push(
+					`${d.adapter}: zero policies configured. Budget/usage/error-rate alerts are not in place.`
+				);
+			}
+		} catch (err) {
+			section.providers.push({
+				descriptorId: d.id,
+				adapter: d.adapter,
+				policies: [],
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	return section;
+}
+
+async function gatherObservability(
+	runtime: ReturnType<typeof getVibesRuntime>
+): Promise<ObservabilitySection> {
+	const section: ObservabilitySection = { providers: [], gaps: [] };
+	if (!runtime.hasKind('infra/observability')) {
+		section.gaps.push('infra/observability kind not registered — no provider plugin loaded.');
+		return section;
+	}
+	const descriptors = runtime
+		.assets('infra/observability')
+		.descriptors() as InfraObservabilityDescriptor[];
+	for (const d of descriptors) {
+		try {
+			const impl = (await runtime
+				.query('infra/observability')
+				.withId(d.id)
+				.resolve()) as ObservabilityImplementation;
+			const snapshots = (await impl.getStatus({ kind: 'account-wide' })) as ObservabilitySnapshot[];
+			const samples = snapshots
+				.map((s) => s.settings.logs?.headSamplingRate)
+				.filter((r): r is number => typeof r === 'number');
+			const overSampled = snapshots
+				.filter((s) => (s.settings.logs?.headSamplingRate ?? 0) >= 1)
+				.map((s) => s.workerName);
+			section.providers.push({
+				descriptorId: d.id,
+				adapter: d.adapter,
+				workerCount: snapshots.length,
+				minSampling: samples.length ? Math.min(...samples) : undefined,
+				maxSampling: samples.length ? Math.max(...samples) : undefined,
+				avgSampling: samples.length ? samples.reduce((a, b) => a + b, 0) / samples.length : undefined,
+				overSampledWorkers: overSampled
+			});
+			if (overSampled.length > 0) {
+				section.gaps.push(
+					`${d.adapter}: ${overSampled.length} worker(s) at 100% log sampling — runaway-cost risk under the new CF Observability metering.`
+				);
+			}
+		} catch (err) {
+			section.providers.push({
+				descriptorId: d.id,
+				adapter: d.adapter,
+				workerCount: 0,
+				overSampledWorkers: [],
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	return section;
+}
+
+async function gatherLogs(runtime: ReturnType<typeof getVibesRuntime>): Promise<LogsSection> {
+	const section: LogsSection = { providers: [] };
+	if (!runtime.hasKind('infra/logs')) return section;
+	const descriptors = runtime.assets('infra/logs').descriptors() as InfraLogsDescriptor[];
+	for (const d of descriptors) {
+		try {
+			await runtime.query('infra/logs').withId(d.id).resolve(); // probe resolves
+			section.providers.push({
+				descriptorId: d.id,
+				adapter: d.adapter,
+				sources: d.sources ?? [],
+				retention: d.retention,
+				alertsConfigured: (d.alerts ?? []).length
+			});
+		} catch (err) {
+			section.providers.push({
+				descriptorId: d.id,
+				adapter: d.adapter,
+				sources: [],
+				alertsConfigured: 0,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	return section;
+}
+
+export default {
+	async execute(_args: Record<string, unknown>, opts: Record<string, unknown>): Promise<void> {
+		const runtime = await getVibesRuntime();
+		const ui = (await runtime.context('cli/ui')) as UIContext;
+
+		const include = (readString(opts.include) ?? 'alerts,logs,observability')
+			.split(',')
+			.map((s) => s.trim());
+		const output = readString(opts.output) ?? 'text';
+
+		const report: AuditReport = { timestamp: new Date().toISOString(), notes: [] };
+
+		if (include.includes('alerts')) report.alerts = await gatherAlerts(runtime);
+		if (include.includes('logs')) report.logs = await gatherLogs(runtime);
+		if (include.includes('observability')) report.observability = await gatherObservability(runtime);
+
+		if (include.includes('rum')) {
+			report.notes.push('infra/rum kind is not implemented yet (Phase 3 of design doc).');
+		}
+		if (include.includes('workers')) {
+			report.notes.push(
+				'Workers fleet audit not implemented yet — use `vibes infra deploy list` for the deployed-app inventory and CF dashboard for live request counts.'
+			);
+		}
+
+		if (output === 'json') {
+			ui.json(report);
+			return;
+		}
+
+		ui.info(`=== Infra audit (${report.timestamp}) ===\n`);
+
+		if (report.alerts) {
+			ui.info('## Alerts');
+			for (const p of report.alerts.providers) {
+				ui.info(`\n[${p.adapter}] (${p.descriptorId})`);
+				if (p.error) {
+					ui.error(`  ${p.error}`);
+					continue;
+				}
+				if (p.policies.length === 0) {
+					ui.warn('  (no policies — billing / usage / error-rate alerts are off)');
+					continue;
+				}
+				for (const policy of p.policies) {
+					const mech = policy.mechanisms.map((m) => `${m.kind}:${m.target}`).join(', ');
+					ui.info(
+						`  ${policy.enabled ? '✓' : '✗'} ${policy.type.padEnd(12)} ${policy.name.padEnd(40)} threshold=${policy.threshold} → ${mech}`
+					);
+				}
+			}
+			if (report.alerts.gaps.length > 0) {
+				ui.info('\nGaps:');
+				for (const gap of report.alerts.gaps) ui.warn(`  • ${gap}`);
+			}
+		}
+
+		if (report.logs) {
+			ui.info('\n## Logs');
+			for (const p of report.logs.providers) {
+				ui.info(`\n[${p.adapter}] (${p.descriptorId})`);
+				if (p.error) {
+					ui.error(`  ${p.error}`);
+					continue;
+				}
+				ui.info(`  sources=${p.sources.length} alerts=${p.alertsConfigured}`);
+				if (p.retention) {
+					ui.info(
+						`  retention: hot=${p.retention.hotDays}d cold=${p.retention.coldDays}d`
+					);
+				}
+			}
+		}
+
+		if (report.observability) {
+			ui.info('\n## Observability');
+			const fmt = (r: number | undefined): string =>
+				r === undefined ? '—' : `${(r * 100).toFixed(0)}%`;
+			for (const p of report.observability.providers) {
+				ui.info(`\n[${p.adapter}] (${p.descriptorId})`);
+				if (p.error) {
+					ui.error(`  ${p.error}`);
+					continue;
+				}
+				ui.info(
+					`  workers=${p.workerCount}  sampling min=${fmt(p.minSampling)} avg=${fmt(p.avgSampling)} max=${fmt(p.maxSampling)}`
+				);
+				if (p.overSampledWorkers.length > 0) {
+					ui.warn(
+						`  ${p.overSampledWorkers.length} worker(s) at 100% sampling — tune with ` +
+							'`vibes infra observability set --sampling 0.1 --filter "vibes-*"`'
+					);
+				}
+			}
+			if (report.observability.gaps.length > 0) {
+				ui.info('\nGaps:');
+				for (const gap of report.observability.gaps) ui.warn(`  • ${gap}`);
+			}
+		}
+
+		if (report.notes.length > 0) {
+			ui.info('\n## Notes');
+			for (const note of report.notes) ui.info(`  • ${note}`);
+		}
+	}
+};

package/src/cli/infra-deploy.cli-group.descriptor.ts

@@ -0,0 +1,12 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-deploy',
+	kind: 'cli/group',
+	name: 'deploy',
+	description: 'Build and deploy apps declared in deployment.config.ts',
+	parent: 'infra',
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

package/src/cli/infra.cli-group.descriptor.ts

@@ -0,0 +1,11 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra',
+	kind: 'cli/group',
+	name: 'infra',
+	description: 'Infrastructure commands',
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

package/src/cli/list/infra-deploy.list.cli-command.descriptor.ts

@@ -0,0 +1,29 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-deploy.list',
+	kind: 'cli/command',
+	name: 'list',
+	description: 'List deployable apps under <root> (scans for deployment.config.ts)',
+	group: 'infra-deploy',
+	arguments: [
+		{
+			name: 'root',
+			description: 'Root directory to scan (defaults to cwd)',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{
+			flags: '-o, --output <format>',
+			description: 'Output format (text|json|table)',
+			default: 'table'
+		},
+		{ flags: '--max-depth <n>', description: 'Maximum directory depth to scan', default: '4', type: 'number' },
+		{ flags: '--order, --graph', description: 'Show suggested deploy order based on dependsOn (topological)' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

package/src/cli/list/infra-deploy.list.cli-command.impl.ts

@@ -0,0 +1,125 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { UIContext } from '@vibesdotdev/cli/providers';
+import { discoverDeployments } from '../shared/discover-deployments.ts';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+/**
+ * Simple topological order for deploy (earlier = must deploy first).
+ * Apps with no dependsOn come first. Uses Kahn's algorithm.
+ */
+function computeDeployOrder(
+	apps: Array<{ appId: string; dependsOn: Array<{ appId: string }> }>
+): string[] {
+	const graph = new Map<string, Set<string>>();
+	const indegree = new Map<string, number>();
+
+	for (const a of apps) {
+		if (!graph.has(a.appId)) graph.set(a.appId, new Set());
+		indegree.set(a.appId, indegree.get(a.appId) ?? 0);
+		for (const dep of a.dependsOn ?? []) {
+			if (!graph.has(dep.appId)) graph.set(dep.appId, new Set());
+			graph.get(dep.appId)!.add(a.appId);
+			indegree.set(a.appId, (indegree.get(a.appId) ?? 0) + 1);
+		}
+	}
+
+	const queue: string[] = [];
+	for (const [id, deg] of indegree) if (deg === 0) queue.push(id);
+
+	const order: string[] = [];
+	while (queue.length) {
+		const node = queue.shift()!;
+		order.push(node);
+		for (const neighbor of graph.get(node) ?? []) {
+			indegree.set(neighbor, (indegree.get(neighbor) ?? 1) - 1);
+			if (indegree.get(neighbor) === 0) queue.push(neighbor);
+		}
+	}
+
+	// Any remaining (cycles) appended at end
+	for (const [id] of indegree) if (!order.includes(id)) order.push(id);
+
+	return order;
+}
+
+export default {
+	async execute(args: Record<string, unknown>, opts: Record<string, unknown>): Promise<void> {
+		const runtime = getVibesRuntime();
+		const ui = (await runtime.context('cli/ui')) as UIContext;
+
+		const rootInput = readString(args.root) ?? '.';
+		const output = readString(opts.output) ?? 'table';
+		const maxDepthRaw = readString(opts.maxDepth);
+		const maxDepthParsed = maxDepthRaw ? Number.parseInt(maxDepthRaw, 10) : 4;
+		const maxDepth = Number.isFinite(maxDepthParsed) ? maxDepthParsed : 4;
+
+		function readBoolean(v: unknown): boolean {
+			return v === true || v === 'true' || v === 'yes';
+		}
+
+		const showOrder = readBoolean(opts.order) || readBoolean(opts.graph);
+
+		const rows: Array<{
+			appId: string;
+			appName: string;
+			provider: string;
+			path: string;
+			dependsOn: string[];
+		}> = [];
+		const appData: Array<{ appId: string; dependsOn: Array<{ appId: string }> }> = [];
+
+		const discovered = await discoverDeployments({
+			root: rootInput,
+			maxDepth,
+			onError: ({ appDir, error }) => {
+				rows.push({
+					appId: '(unparseable)',
+					appName: error.message,
+					provider: '-',
+					path: relative(process.cwd(), appDir) || '.',
+					dependsOn: []
+				});
+			}
+		});
+
+		for (const d of discovered) {
+			const depIds = d.dependsOn.map((dep) => dep.appId);
+			rows.push({
+				appId: d.appId,
+				appName: d.appName,
+				provider: d.provider,
+				path: relative(process.cwd(), d.appDir) || '.',
+				dependsOn: depIds
+			});
+			appData.push({ appId: d.appId, dependsOn: d.dependsOn });
+		}
+
+		if (rows.length === 0) {
+			const root = isAbsolute(rootInput) ? rootInput : resolve(process.cwd(), rootInput);
+			if (output === 'json') ui.json([]);
+			else ui.info(`No deployment configs found under ${root}`);
+			return;
+		}
+
+		if (showOrder) {
+			const order = computeDeployOrder(appData);
+			if (output === 'json') {
+				ui.json({ order, apps: rows });
+			} else {
+				ui.info('Suggested deploy order (earlier = prerequisites first):');
+				order.forEach((id, i) => ui.log(`  ${i + 1}. ${id}`));
+			}
+			return;
+		}
+
+		if (output === 'json') {
+			ui.json(rows);
+			return;
+		}
+		ui.table(rows, { columns: ['appId', 'appName', 'provider', 'path', 'dependsOn'] });
+	}
+};

package/src/cli/logs/infra-logs.cli-command.descriptor.ts

@@ -0,0 +1,65 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-logs',
+	kind: 'cli/command',
+	name: 'logs',
+	description: 'List and query log sources (Workers, Pages, D1, etc.)',
+	group: 'infra',
+	arguments: [
+		{
+			name: 'source',
+			description: 'Log source name to query (optional, lists all if omitted)',
+			required: false,
+			variadic: false
+		},
+		{
+			name: 'worker',
+			description: 'Worker name to filter logs (when source has multiple workers)',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{
+			flags: '-o, --output <format>',
+			description: 'Output format (text|json|table)',
+			default: 'table'
+		},
+		{
+			flags: '--analytics',
+			description: 'Get analytics summary for a source',
+			default: false
+		},
+		{
+			flags: '--timeStart <range>',
+			description: 'Time range for analytics (e.g., 1h, 24h, 7d)',
+			default: '24h'
+		},
+		{
+			flags: '--tail',
+			description: 'Stream logs in real-time',
+			default: false
+		},
+		{
+			flags: '--status <status>',
+			description: 'Filter by status (ok|error|canceled)',
+			default: undefined
+		},
+		{
+			flags: '--limit <n>',
+			description: 'Max log entries to retrieve',
+			default: '100',
+			type: 'number'
+		},
+		{
+			flags: '--window <duration>',
+			description:
+				'Capture window for windowed query mode (e.g., 30s, 2m). Default 30s. Cloudflare exposes only live Tail for per-event data, so this brief window is the largest practical batch.',
+			default: '30s'
+		}
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});