@vibesdotdev/infra-deploy 0.0.1

package/src/cli/observability/infra-observability-set.cli-command.impl.ts

@@ -0,0 +1,173 @@
+/**
+ * `vibes infra observability set [--worker NAME] [--filter GLOB]
+ *                                [--sampling 0.1] [--logs true|false]
+ *                                [--traces true|false] [--dry-run]`
+ *
+ * Writes observability config to one Worker, a glob-matched subset, or
+ * the entire fleet. `--dry-run` shows the diff without writing. Multi-
+ * worker writes require `--yes` confirmation.
+ *
+ * Skips Workers whose live settings already match the requested state
+ * (the impl handles this via `skipUnchanged`).
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { requestCLIExit, type UIContext } from '@vibesdotdev/cli/providers';
+import type {
+	ObservabilityImplementation,
+	ObservabilityScope,
+	ObservabilitySettings,
+	InfraObservabilityDescriptor,
+	SetObservabilityResult
+} from '@vibesdotdev/infra-core';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+function readBoolean(v: unknown): boolean {
+	return v === true || v === 'true';
+}
+
+function parseBoolean(raw: string | undefined): boolean | undefined {
+	if (!raw) return undefined;
+	const v = raw.toLowerCase();
+	if (v === 'true' || v === '1' || v === 'on' || v === 'yes') return true;
+	if (v === 'false' || v === '0' || v === 'off' || v === 'no') return false;
+	return undefined;
+}
+
+function formatPct(rate: number | undefined): string {
+	if (rate === undefined) return '—';
+	return `${(rate * 100).toFixed(0)}%`;
+}
+
+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 worker = readString(opts.worker);
+		const filter = readString(opts.filter);
+		const samplingRaw = readString(opts.sampling);
+		const logsEnabledRaw = readString(opts.logs);
+		const tracesEnabledRaw = readString(opts.traces);
+		const providerFilter = readString(opts.provider);
+		const dryRun = readBoolean(opts['dry-run']) || readBoolean(opts.dryRun);
+		const yes = readBoolean(opts.yes);
+		const output = readString(opts.output) ?? 'text';
+
+		// Build the partial settings update.
+		const update: ObservabilitySettings = {};
+		const logsUpdate: NonNullable<ObservabilitySettings['logs']> = { enabled: false };
+		let hasLogsField = false;
+		if (samplingRaw !== undefined) {
+			const sampling = Number(samplingRaw);
+			if (!Number.isFinite(sampling) || sampling < 0 || sampling > 1) {
+				ui.error(`--sampling must be a number in [0, 1]; got "${samplingRaw}".`);
+				requestCLIExit(1);
+				return;
+			}
+			logsUpdate.headSamplingRate = sampling;
+			// Sampling rate change implies logs stay enabled (CF gates head_sampling_rate behind enabled).
+			logsUpdate.enabled = true;
+			hasLogsField = true;
+		}
+		const logsToggle = parseBoolean(logsEnabledRaw);
+		if (logsToggle !== undefined) {
+			logsUpdate.enabled = logsToggle;
+			hasLogsField = true;
+		}
+		if (hasLogsField) update.logs = logsUpdate;
+
+		const tracesToggle = parseBoolean(tracesEnabledRaw);
+		if (tracesToggle !== undefined) {
+			update.traces = { enabled: tracesToggle };
+		}
+
+		if (!update.logs && !update.traces) {
+			ui.error('Nothing to change. Pass --sampling, --logs, or --traces.');
+			requestCLIExit(1);
+			return;
+		}
+
+		if (!runtime.hasKind('infra/observability')) {
+			ui.error('No infra/observability kind registered.');
+			requestCLIExit(1);
+			return;
+		}
+		const descriptors = runtime.assets('infra/observability').descriptors() as InfraObservabilityDescriptor[];
+		const target = providerFilter
+			? descriptors.find((d) => d.adapter === providerFilter || d.id === providerFilter)
+			: descriptors[0];
+		if (!target) {
+			ui.error('No matching observability provider.');
+			requestCLIExit(1);
+			return;
+		}
+
+		const scope: ObservabilityScope = worker
+			? { kind: 'worker', workerName: worker }
+			: { kind: 'account-wide', ...(filter ? { filter } : {}) };
+
+		const impl = (await runtime
+			.query('infra/observability')
+			.withId(target.id)
+			.resolve()) as ObservabilityImplementation;
+
+		// Multi-worker writes need confirmation (unless --yes).
+		if (scope.kind === 'account-wide' && !yes && !dryRun) {
+			ui.warn(
+				`About to update observability on every Worker matching ${
+					filter ? `glob "${filter}"` : 'all workers'
+				}.\nRe-run with --yes to confirm, or --dry-run to preview.`
+			);
+			requestCLIExit(0);
+			return;
+		}
+
+		if (dryRun) {
+			// Use getStatus to compute the diff, then print without writing.
+			const snapshots = await impl.getStatus(scope);
+			ui.info(`Dry run — ${snapshots.length} worker(s) in scope.`);
+			for (const s of snapshots) {
+				const beforeSample = s.settings.logs?.headSamplingRate;
+				const afterSample = update.logs?.headSamplingRate ?? beforeSample;
+				const change = beforeSample !== afterSample
+					? `sampling ${formatPct(beforeSample)} → ${formatPct(afterSample)}`
+					: '(no change)';
+				ui.info(`  ${s.workerName}: ${change}`);
+			}
+			return;
+		}
+
+		let result: SetObservabilityResult;
+		try {
+			result = await impl.set({ scope, settings: update });
+		} catch (err) {
+			ui.error(`Apply failed: ${err instanceof Error ? err.message : String(err)}`);
+			requestCLIExit(1);
+			return;
+		}
+
+		if (output === 'json') {
+			ui.json(result);
+			return;
+		}
+
+		ui.success(`Applied. changed=${result.changed.length} unchanged=${result.unchanged.length} failed=${result.failed.length}`);
+		for (const c of result.changed) {
+			const beforeRate = c.before.logs?.headSamplingRate;
+			const afterRate = c.after.logs?.headSamplingRate;
+			ui.info(`  ${c.workerName}: sampling ${formatPct(beforeRate)} → ${formatPct(afterRate)}`);
+		}
+		if (result.unchanged.length > 0) {
+			ui.info(`\nUnchanged (already at target): ${result.unchanged.join(', ')}`);
+		}
+		if (result.failed.length > 0) {
+			ui.error('\nFailed:');
+			for (const f of result.failed) ui.error(`  ${f.workerName}: ${f.error}`);
+			requestCLIExit(1);
+		}
+	}
+};

package/src/cli/observability/infra-observability-status.cli-command.descriptor.ts

@@ -0,0 +1,35 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-observability.status',
+	kind: 'cli/command',
+	name: 'status',
+	description: 'Read observability config (sampling, logs, traces) across Workers',
+	group: 'infra-observability',
+	options: [
+		{
+			flags: '--worker <name>',
+			description: 'Scope to a single Worker (omit for fleet-wide sweep)'
+		},
+		{
+			flags: '--filter <glob>',
+			description: 'Glob to narrow the fleet sweep (e.g. "vibes-*")'
+		},
+		{
+			flags: '--provider <id>',
+			description: 'Provider impl id (default: cloudflare-workers-observability)'
+		},
+		{
+			flags: '--environment <name>',
+			description: 'Vibes environment for secret resolution (local|dev|staging|production)'
+		},
+		{
+			flags: '-o, --output <format>',
+			description: 'Output format (text|json)',
+			default: 'text'
+		}
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

package/src/cli/observability/infra-observability-status.cli-command.impl.ts

@@ -0,0 +1,124 @@
+/**
+ * `vibes infra observability status [--worker NAME] [--filter GLOB]`
+ *
+ * Reads observability config for one Worker, a glob-matched subset, or
+ * the entire fleet. Renders a table:
+ *
+ *   worker            logs.enabled  logs.sample  traces.enabled  modified
+ *   ----------------  ------------  -----------  --------------  ------------
+ *   vibes-account     true          100%         false           2026-05-22T…
+ *
+ * `--output json` emits the raw ObservabilitySnapshot[] for piping.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { type UIContext } from '@vibesdotdev/cli/providers';
+import type {
+	ObservabilityImplementation,
+	ObservabilitySnapshot,
+	ObservabilityScope,
+	InfraObservabilityDescriptor
+} from '@vibesdotdev/infra-core';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+function formatPct(rate: number | undefined): string {
+	if (rate === undefined) return '—';
+	return `${(rate * 100).toFixed(0)}%`;
+}
+
+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 worker = readString(opts.worker);
+		const filter = readString(opts.filter);
+		const providerFilter = readString(opts.provider);
+		const output = readString(opts.output) ?? 'text';
+
+		if (!runtime.hasKind('infra/observability')) {
+			ui.warn('No infra/observability kind registered. Load infra-cloudflare or a sibling provider plugin.');
+			return;
+		}
+		const descriptors = runtime.assets('infra/observability').descriptors() as InfraObservabilityDescriptor[];
+		const target = providerFilter
+			? descriptors.find((d) => d.adapter === providerFilter || d.id === providerFilter)
+			: descriptors[0];
+		if (!target) {
+			ui.error('No matching observability provider.');
+			return;
+		}
+
+		const scope: ObservabilityScope = worker
+			? { kind: 'worker', workerName: worker }
+			: { kind: 'account-wide', ...(filter ? { filter } : {}) };
+
+		let snapshots: ObservabilitySnapshot[];
+		try {
+			const impl = (await runtime
+				.query('infra/observability')
+				.withId(target.id)
+				.resolve()) as ObservabilityImplementation;
+			snapshots = await impl.getStatus(scope);
+		} catch (err) {
+			ui.error(`Failed to read observability: ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
+
+		if (output === 'json') {
+			ui.json(snapshots);
+			return;
+		}
+
+		if (snapshots.length === 0) {
+			ui.info('No workers in scope.');
+			return;
+		}
+
+		// Compute column widths.
+		const nameWidth = Math.max(6, ...snapshots.map((s) => s.workerName.length));
+		ui.info(
+			`  ${'worker'.padEnd(nameWidth)}  ${'logs'.padEnd(6)}  ${'sample'.padEnd(7)}  ${'traces'.padEnd(7)}  modified`
+		);
+		ui.info(`  ${'-'.repeat(nameWidth)}  ------  -------  -------  --------------------`);
+		for (const s of snapshots) {
+			const logsEnabled = s.settings.logs?.enabled ?? false;
+			const logsSample = formatPct(s.settings.logs?.headSamplingRate);
+			const tracesEnabled = s.settings.traces?.enabled ?? false;
+			const modified = s.modifiedAt ? s.modifiedAt.slice(0, 19) : '—';
+			ui.info(
+				`  ${s.workerName.padEnd(nameWidth)}  ${String(logsEnabled).padEnd(6)}  ${logsSample.padEnd(7)}  ${String(tracesEnabled).padEnd(7)}  ${modified}`
+			);
+		}
+
+		// Surface a fleet-wide summary so the gap is impossible to miss.
+		const samples = snapshots
+			.map((s) => s.settings.logs?.headSamplingRate)
+			.filter((r): r is number => typeof r === 'number');
+		if (samples.length > 0) {
+			const min = Math.min(...samples);
+			const max = Math.max(...samples);
+			const avg = samples.reduce((a, b) => a + b, 0) / samples.length;
+			ui.info(
+				`\nFleet logs head-sampling: min=${formatPct(min)} avg=${formatPct(avg)} max=${formatPct(max)} ` +
+					`(${snapshots.length} workers scanned)`
+			);
+			if (max >= 1) {
+				const overSampled = snapshots
+					.filter((s) => (s.settings.logs?.headSamplingRate ?? 0) >= 1)
+					.map((s) => s.workerName);
+				ui.warn(
+					`\n${overSampled.length} worker(s) at 100% sampling — eligible for tuning:\n  ${overSampled.join('\n  ')}`
+				);
+				ui.info(
+					'\nRun `vibes infra observability set --sampling 0.1 --filter "vibes-*"` to drop ' +
+						'customer-facing workers to 10% (recommended before accepting the new CF Workers ' +
+						'Observability pricing).'
+				);
+			}
+		}
+	}
+};

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

@@ -0,0 +1,12 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-observability',
+	kind: 'cli/group',
+	name: 'observability',
+	description: 'Provider-agnostic observability config — sampling, logs, traces, exports',
+	parent: 'infra',
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

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

@@ -0,0 +1,36 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-deploy.regenerate',
+	kind: 'cli/command',
+	name: 'regenerate',
+	description:
+		'Regenerate wrangler.jsonc from deployment.config.ts for managed apps (or check for drift)',
+	group: 'infra-deploy',
+	arguments: [
+		{
+			name: 'path',
+			description: 'App directory (defaults to cwd; ignored when --all is set)',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{
+			flags: '--all',
+			description: 'Regenerate every managed app under <root> (defaults to cwd)'
+		},
+		{
+			flags: '--root <dir>',
+			description: 'Root directory to scan when --all is set (defaults to cwd)'
+		},
+		{
+			flags: '--check',
+			description: 'Read-only drift detection; exit 1 if any managed app is out of sync'
+		},
+		{ flags: '-o, --output <format>', description: 'Output format (text|json)', default: 'text' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

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

@@ -0,0 +1,103 @@
+import { relative, resolve } from 'node:path';
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { UIContext } from '@vibesdotdev/cli/providers';
+import { regenerateAll, regenerateApp, regenExitCode, type RegenResult } from '../../regenerate.ts';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+function readBoolean(v: unknown): boolean {
+	return v === true || v === 'true';
+}
+
+function statusGlyph(status: RegenResult['status']): string {
+	switch (status) {
+		case 'unchanged':
+			return '·';
+		case 'updated':
+			return '✎';
+		case 'drift':
+			return '✗';
+		case 'skipped':
+			return '–';
+		case 'error':
+			return '!';
+	}
+}
+
+function summarize(results: RegenResult[]): Record<RegenResult['status'], number> {
+	const counts: Record<RegenResult['status'], number> = {
+		unchanged: 0,
+		updated: 0,
+		drift: 0,
+		skipped: 0,
+		error: 0
+	};
+	for (const r of results) counts[r.status] += 1;
+	return counts;
+}
+
+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 all = readBoolean(opts.all);
+		const check = readBoolean(opts.check);
+		const output = readString(opts.output) ?? 'text';
+		const mode = check ? 'check' : 'write';
+
+		const results: RegenResult[] = [];
+		if (all) {
+			const root = resolve(readString(opts.root) ?? process.cwd());
+			const r = await regenerateAll(root, { mode });
+			results.push(...r);
+		} else {
+			const path = readString(args.path) ?? process.cwd();
+			results.push(await regenerateApp(resolve(path), { mode }));
+		}
+
+		if (output === 'json') {
+			ui.json({
+				mode,
+				results: results.map((r) => ({
+					appId: r.appId,
+					appDir: relative(process.cwd(), r.appDir) || '.',
+					wranglerJsoncPath: relative(process.cwd(), r.wranglerJsoncPath),
+					status: r.status,
+					workerName: r.workerName,
+					reason: r.reason,
+					diff: r.diff
+				})),
+				summary: summarize(results)
+			});
+		} else {
+			for (const r of results) {
+				const path = relative(process.cwd(), r.wranglerJsoncPath);
+				const glyph = statusGlyph(r.status);
+				const tail =
+					r.status === 'drift'
+						? ` (drift; run without --check to rewrite)`
+						: r.status === 'skipped'
+							? ` (skipped: ${r.reason ?? 'not managed'})`
+							: r.status === 'error'
+								? ` (error: ${r.reason ?? 'unknown'})`
+								: '';
+				ui.log(`  ${glyph} ${r.appId.padEnd(20)} ${path}${tail}`);
+				if (r.status === 'drift' && r.diff) {
+					for (const line of r.diff.split('\n')) ui.log(`      ${line}`);
+				}
+			}
+			const counts = summarize(results);
+			const summary = Object.entries(counts)
+				.filter(([, n]) => n > 0)
+				.map(([k, n]) => `${n} ${k}`)
+				.join(', ');
+			if (summary) ui.info(`Summary: ${summary} (mode=${mode})`);
+		}
+
+		const code = regenExitCode(results, mode);
+		if (code !== 0) process.exitCode = code;
+	}
+};

package/src/cli/rum/infra-rum-status.cli-command.descriptor.ts

@@ -0,0 +1,27 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-rum.status',
+	kind: 'cli/command',
+	name: 'status',
+	description: 'List configured RUM sites + injection mode across providers',
+	group: 'infra-rum',
+	options: [
+		{
+			flags: '--provider <id>',
+			description: 'Provider impl id (default: cloudflare-web-analytics)'
+		},
+		{
+			flags: '--environment <name>',
+			description: 'Vibes environment for secret resolution (local|dev|staging|production)'
+		},
+		{
+			flags: '-o, --output <format>',
+			description: 'Output format (text|json)',
+			default: 'text'
+		}
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

package/src/cli/rum/infra-rum-status.cli-command.impl.ts

@@ -0,0 +1,112 @@
+/**
+ * `vibes infra rum status`
+ *
+ * Lists configured RUM sites across registered providers, plus the
+ * declared injection mode + privacy posture from the descriptor.
+ * Flags the "auto-injection but SSR Workers" gap that bit us earlier.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import { type UIContext } from '@vibesdotdev/cli/providers';
+import type {
+	RumImplementation,
+	RumSiteSnapshot,
+	InfraRumDescriptor
+} from '@vibesdotdev/infra-core/kinds';
+
+function readString(v: unknown): string | undefined {
+	return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+
+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 providerFilter = readString(opts.provider);
+		const output = readString(opts.output) ?? 'text';
+
+		if (!runtime.hasKind('infra/rum')) {
+			ui.warn('No infra/rum kind registered.');
+			return;
+		}
+		const descriptors = runtime.assets('infra/rum').descriptors() as InfraRumDescriptor[];
+		const candidates = providerFilter
+			? descriptors.filter((d) => d.adapter === providerFilter || d.id === providerFilter)
+			: descriptors;
+		if (candidates.length === 0) {
+			ui.info('No infra/rum providers registered.');
+			return;
+		}
+
+		interface ProviderReport {
+			descriptorId: string;
+			adapter: string;
+			declaredInjection: string;
+			declaredHostnames: string[];
+			sites: RumSiteSnapshot[];
+			error?: string;
+		}
+
+		const reports: ProviderReport[] = [];
+		for (const d of candidates) {
+			try {
+				const impl = (await runtime
+					.query('infra/rum')
+					.withId(d.id)
+					.resolve()) as RumImplementation;
+				const sites = await impl.listSites();
+				reports.push({
+					descriptorId: d.id,
+					adapter: d.adapter,
+					declaredInjection: d.injection,
+					declaredHostnames: d.hostnames,
+					sites
+				});
+			} catch (err) {
+				reports.push({
+					descriptorId: d.id,
+					adapter: d.adapter,
+					declaredInjection: d.injection,
+					declaredHostnames: d.hostnames,
+					sites: [],
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+
+		if (output === 'json') {
+			ui.json(reports);
+			return;
+		}
+
+		for (const r of reports) {
+			ui.info(`\n[${r.adapter}] (${r.descriptorId})`);
+			ui.info(`  injection: ${r.declaredInjection}`);
+			ui.info(`  declared hostnames: ${r.declaredHostnames.join(', ')}`);
+			if (r.error) {
+				ui.error(`  ${r.error}`);
+				continue;
+			}
+			if (r.sites.length === 0) {
+				ui.warn('  (no sites configured on provider)');
+				continue;
+			}
+			for (const s of r.sites) {
+				ui.info(
+					`  ${s.enabled ? '✓' : '✗'} site_tag=${s.siteTag}  hosts=${s.hostnames.join(',')}  ` +
+						`injection=${s.injection ?? '?'}  created=${(s.createdAt ?? '?').slice(0, 10)}`
+				);
+			}
+			// Flag the SSR-injection gap clearly.
+			if (r.declaredInjection === 'provider-auto' || r.sites.some((s) => s.injection === 'provider-auto')) {
+				ui.warn(
+					'\n  ⚠ provider-auto injection only fires on origin/cache responses. SvelteKit ' +
+						'SSR Workers will report 0 page views unless the beacon is also injected at ' +
+						'render time (use injection: "sveltekit-hook" + the cloudflare-web-analytics ' +
+						'SvelteKit handle).'
+				);
+			}
+		}
+	}
+};

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

@@ -0,0 +1,12 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-rum',
+	kind: 'cli/group',
+	name: 'rum',
+	description: 'Real User Monitoring (beacon-based front-end telemetry) — CF Web Analytics, Sentry, …',
+	parent: 'infra',
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});

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

@@ -0,0 +1,49 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export default createRuntimeAsset({
+	id: 'infra-deploy.run',
+	kind: 'cli/command',
+	name: 'run',
+	description: 'Build and deploy the app in <path> (defaults to cwd)',
+	group: 'infra-deploy',
+	arguments: [
+		{
+			name: 'path',
+			description: 'Path to app directory containing deployment.config.ts',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{ flags: '--skip-build', description: 'Skip build step (deploy pre-built output)' },
+		{
+			flags: '--skip-d1-migrations',
+			description: 'Skip D1 migration replay for this deploy (Workers only)'
+		},
+		{ flags: '--dry-run', description: 'Show what would be deployed, without uploading' },
+		{
+			flags: '--workspace-root <dir>',
+			description: 'Override workspace root (default: process.cwd())'
+		},
+		{
+			flags: '--environment <name>',
+			description: 'Target Vibes environment for deploy credential resolution'
+		},
+		{ flags: '--branch <name>', description: 'Deploy branch (default: main)', default: 'main' },
+		{
+			flags: '--wrangler-env <name>',
+			description: 'Wrangler environment name (Workers only)'
+		},
+		{
+			flags: '--do-app-id <id>',
+			description: 'Existing DigitalOcean App id (update instead of create)'
+		},
+		{ flags: '--do-region <slug>', description: 'DO region slug (default: nyc)' },
+		{ flags: '--do-git-repo <url>', description: 'DO App source git repo URL' },
+		{ flags: '--do-git-branch <name>', description: 'DO App source branch (default: main)' },
+		{ flags: '-o, --output <format>', description: 'Output format (text|json)', default: 'text' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer', 'cloud'],
+	enabled: true
+});