@vibesdotdev/storage 0.0.1

package/src/cli/commands/sync/pull/storage.sync.pull.cli-command.descriptor.ts

@@ -0,0 +1,28 @@
+import type { CLICommandAssetDescriptor } from '@vibesdotdev/runtime/schemas/asset';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'storage.sync.pull',
+	name: 'pull',
+	description: 'Pull cloud storage manifests to local',
+	group: 'storage.sync',
+	arguments: [
+		{
+			name: 'manifest-id',
+			description: 'Manifest ID to pull (omit for all)',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{ flags: '--force', description: 'Force overwrite local even if local has changes' },
+		{ flags: '--dry-run', description: 'Show what would be synced without making changes' },
+		{ flags: '--json', description: 'Output results as JSON' }
+	],
+	aliases: [],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/cli/commands/sync/pull/storage.sync.pull.cli-command.impl.ts

@@ -0,0 +1,171 @@
+/**
+ * vibes storage sync pull [manifest-id]
+ *
+ * Pulls cloud data to local for storage manifests AND sync-bridges.
+ * Uses pullFromCloud() for storage manifests and SyncBridge.execute() for bridges.
+ *
+ * The manifest-id argument matches both manifest IDs and bridge IDs.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { StorageCliUIContext as UIContext } from '../../../types';
+import { pullFromCloud } from '../../../../sync/cloud-pull';
+import type { CloudPullOptions } from '../../../../sync/schemas/cloud-pull';
+import type { SyncBridgeDescriptor } from '../../../../schemas/sync-bridge-descriptor';
+import type { StorageRecordDescriptor } from '../../../../schemas/record';
+import { SyncBridge } from '../../../../sync/sync-bridge';
+import { resolveSyncTarget } from '../../../../sync/resolve-sync-target';
+import {
+	createRecordSyncBridgeDescriptor,
+	isSyncableStorageRecord
+} from '../../../../sync/record-sync-bridge';
+
+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 targetId = args['manifest-id'] as string | undefined;
+		const force = opts.force as boolean | undefined;
+		const dryRun = opts.dryRun as boolean | undefined;
+
+		try {
+			// ── Sync Bridges ──
+			const allBridges = runtime
+				.query('storage/sync-bridge')
+				.descriptors() as SyncBridgeDescriptor[];
+			const allRecords = runtime.query('storage/record').descriptors() as StorageRecordDescriptor[];
+			const eligibleRecords = allRecords.filter(isSyncableStorageRecord);
+			const recordTargets = targetId
+				? eligibleRecords.filter((descriptor) => descriptor.id === targetId)
+				: eligibleRecords;
+			const syntheticRecordBridges = recordTargets.map(createRecordSyncBridgeDescriptor);
+
+			const isBridgeOnly =
+				targetId &&
+				(allBridges.some((bridge) => bridge.id === targetId) ||
+					eligibleRecords.some((descriptor) => descriptor.id === targetId));
+
+			// ── Storage Manifests ──
+			if (!isBridgeOnly) {
+				const pullOpts: CloudPullOptions = {
+					force: force ?? false,
+					dryRun: dryRun ?? false
+				};
+
+				if (targetId) {
+					pullOpts.manifestIds = [targetId];
+				}
+
+				const result = await pullFromCloud(pullOpts);
+
+				if (dryRun && result.details.length > 0) {
+					ui.info('[dry-run] No manifest changes were written.');
+				}
+
+				for (const detail of result.details) {
+					switch (detail.action) {
+						case 'pulled':
+							ui.success(`Pulled: ${detail.manifestId}`);
+							break;
+						case 'skipped':
+							ui.info(`Skipped: ${detail.manifestId} — ${detail.message ?? 'already in-sync'}`);
+							break;
+						case 'conflict':
+							ui.warn(`Conflict: ${detail.manifestId} — ${detail.message}`);
+							break;
+						case 'error':
+							ui.error(`Error: ${detail.manifestId} — ${detail.message}`);
+							break;
+					}
+				}
+
+				if (!targetId && result.details.length > 0) {
+					ui.info(
+						`Manifests: ${result.pulled} pulled, ${result.skipped} skipped, ${result.conflicts} conflicts, ${result.errors} errors`
+					);
+				}
+			}
+
+			// ── Sync Bridges ──
+			const bridgeTargets = targetId ? allBridges.filter((b) => b.id === targetId) : allBridges;
+			const syncTargets = [...syntheticRecordBridges, ...bridgeTargets];
+
+			if (syncTargets.length > 0) {
+				const { syncTarget, apiToken } = await resolveSyncTarget();
+
+				if (!syncTarget || syncTarget === 'unknown') {
+					ui.error('No sync target configured. Set VIBES_API_URL or select an environment.');
+				} else {
+					for (const bridgeDesc of syncTargets) {
+						try {
+							const bridge = new SyncBridge(bridgeDesc);
+							const bridgeResult = await bridge.execute(
+								syncTarget,
+								{
+									dryRun: dryRun ?? false,
+									force: force ?? false,
+									direction: 'pull'
+								},
+								apiToken
+							);
+
+							for (const detail of bridgeResult.details) {
+								const label = `${bridgeDesc.id}:${detail.entityId}`;
+
+								if (!dryRun) {
+									switch (detail.action) {
+										case 'pulled':
+											ui.success(`Pulled: ${label}`);
+											break;
+										case 'skipped':
+											ui.info(`Skipped: ${label} — ${detail.message ?? 'in sync'}`);
+											break;
+										case 'conflict':
+											ui.warn(`Conflict: ${label} — ${detail.message}`);
+											break;
+										case 'error':
+											ui.error(`Error: ${label} — ${detail.message}`);
+											break;
+									}
+								} else {
+									ui.info(`[dry-run] ${label}: ${detail.action} — ${detail.message ?? ''}`);
+								}
+							}
+
+							const { pushed, pulled, skipped, conflicts, errors } = bridgeResult;
+							ui.info(
+								`Sync ${bridgeDesc.id}: ${pulled} pulled, ${pushed} pushed, ${skipped} skipped, ${conflicts} conflicts, ${errors} errors`
+							);
+						} catch (e) {
+							const msg = (e as Error).message;
+							ui.error(`Sync ${bridgeDesc.id} failed: ${msg}`);
+						}
+					}
+				}
+			}
+
+			// Check if nothing was found at all
+			if (targetId) {
+				const manifests = runtime.query('storage/manifest').descriptors() as Array<{
+					id: string;
+					allowedAdapters?: string[];
+					enabled?: boolean;
+				}>;
+				const manifestMatch = manifests.some(
+					(d) =>
+						d.id === targetId &&
+						d.enabled !== false &&
+						d.allowedAdapters?.includes('storage.cloud-api')
+				);
+				const bridgeMatch = allBridges.some((b) => b.id === targetId);
+				const recordMatch = eligibleRecords.some((descriptor) => descriptor.id === targetId);
+				if (!manifestMatch && !bridgeMatch && !recordMatch) {
+					ui.warn(`'${targetId}' not found as a manifest, record, or sync-bridge.`);
+				}
+			}
+		} catch (e) {
+			ui.error(`Pull failed: ${e}`);
+			process.exit(1);
+		}
+	}
+};

package/src/cli/commands/sync/push/storage.sync.push.cli-command.descriptor.ts

@@ -0,0 +1,28 @@
+import type { CLICommandAssetDescriptor } from '@vibesdotdev/runtime/schemas/asset';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'storage.sync.push',
+	name: 'push',
+	description: 'Push local storage manifests to cloud',
+	group: 'storage.sync',
+	arguments: [
+		{
+			name: 'manifest-id',
+			description: 'Manifest ID to push (omit for all)',
+			required: false,
+			variadic: false
+		}
+	],
+	options: [
+		{ flags: '--force', description: 'Force re-push even if already in-sync' },
+		{ flags: '--dry-run', description: 'Show what would be synced without making changes' },
+		{ flags: '--json', description: 'Output results as JSON' }
+	],
+	aliases: [],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/cli/commands/sync/push/storage.sync.push.cli-command.impl.ts

@@ -0,0 +1,213 @@
+/**
+ * vibes storage sync push [manifest-id]
+ *
+ * Pushes local data to the cloud API for storage manifests AND sync-bridges.
+ * Uses syncManifest() for storage manifests and SyncBridge.execute() for bridges.
+ *
+ * The manifest-id argument matches both manifest IDs and bridge IDs.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { StorageCliUIContext as UIContext } from '../../../types';
+import { syncManifest } from '../../../../sync/sync-manifest';
+import {
+	loadSyncState,
+	saveSyncState,
+	computeHash,
+	getManifestSyncState,
+	markSynced,
+	markConflict,
+	markError,
+	markLocalAhead,
+	markRemoteAhead
+} from '../../../../sync/sync-state.consumer';
+import type { SyncHelpers } from '../../../../sync/schemas/sync-helpers';
+import type { SyncBridgeDescriptor } from '../../../../schemas/sync-bridge-descriptor';
+import type { StorageRecordDescriptor } from '../../../../schemas/record';
+import { SyncBridge } from '../../../../sync/sync-bridge';
+import { resolveSyncTarget } from '../../../../sync/resolve-sync-target';
+import {
+	createRecordSyncBridgeDescriptor,
+	isSyncableStorageRecord
+} from '../../../../sync/record-sync-bridge';
+
+interface ManifestDescriptor {
+	id: string;
+	allowedAdapters?: string[];
+	enabled?: boolean;
+}
+
+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 targetId = args['manifest-id'] as string | undefined;
+		const force = opts.force as boolean | undefined;
+		const dryRun = opts.dryRun as boolean | undefined;
+
+		try {
+			// ── Storage Manifests ──
+			const descriptors = runtime.query('storage/manifest').descriptors() as ManifestDescriptor[];
+
+			const eligible = descriptors.filter(
+				(d) => d.enabled !== false && d.allowedAdapters?.includes('storage.cloud-api')
+			);
+
+			const manifestTargets = targetId ? eligible.filter((d) => d.id === targetId) : eligible;
+
+			const recordDescriptors = runtime
+				.query('storage/record')
+				.descriptors() as StorageRecordDescriptor[];
+			const eligibleRecords = recordDescriptors.filter(isSyncableStorageRecord);
+			const recordTargets = targetId
+				? eligibleRecords.filter((descriptor) => descriptor.id === targetId)
+				: eligibleRecords;
+
+			// ── Sync Bridges ──
+			const allBridges = runtime
+				.query('storage/sync-bridge')
+				.descriptors() as SyncBridgeDescriptor[];
+
+			const bridgeTargets = targetId ? allBridges.filter((b) => b.id === targetId) : allBridges;
+
+			if (
+				manifestTargets.length === 0 &&
+				bridgeTargets.length === 0 &&
+				recordTargets.length === 0
+			) {
+				ui.warn(
+					targetId
+						? `'${targetId}' not found as a manifest, record, or sync-bridge.`
+						: 'No manifests, records, or sync-bridges have cloud sync enabled.'
+				);
+				return;
+			}
+
+			const syncState = await loadSyncState();
+			const helpers: SyncHelpers = {
+				computeHash,
+				getManifestSyncState,
+				markSynced,
+				markConflict,
+				markError,
+				markLocalAhead,
+				markRemoteAhead,
+				dryRun: dryRun ?? false
+			};
+
+			const results: Array<{ manifestId: string; action: string; message?: string }> = [];
+
+			// Push storage manifests
+			for (const descriptor of manifestTargets) {
+				try {
+					const result = await syncManifest(descriptor.id, syncState, helpers);
+					results.push(result);
+
+					if (!dryRun) {
+						switch (result.action) {
+							case 'pushed':
+								ui.success(`Pushed: ${descriptor.id}`);
+								break;
+							case 'pulled':
+								ui.info(`Pulled (remote was newer): ${descriptor.id}`);
+								break;
+							case 'conflict':
+								ui.warn(`Conflict: ${descriptor.id} — ${result.message}`);
+								break;
+							case 'skipped':
+								ui.info(`Skipped: ${descriptor.id} — ${result.message}`);
+								break;
+							case 'error':
+								ui.error(`Error: ${descriptor.id} — ${result.message}`);
+								break;
+						}
+					} else {
+						ui.info(`[dry-run] ${descriptor.id}: ${result.action} — ${result.message ?? ''}`);
+					}
+				} catch (e) {
+					const msg = (e as Error).message;
+					ui.error(`Failed to sync ${descriptor.id}: ${msg}`);
+					results.push({ manifestId: descriptor.id, action: 'error', message: msg });
+				}
+			}
+
+			// Push sync bridges and syncable records
+			const syntheticRecordBridges = recordTargets.map(createRecordSyncBridgeDescriptor);
+			const syncTargets = [...syntheticRecordBridges, ...bridgeTargets];
+			if (syncTargets.length > 0) {
+				const { syncTarget, apiToken } = await resolveSyncTarget();
+
+				if (!syncTarget || syncTarget === 'unknown') {
+					ui.error('No sync target configured. Set VIBES_API_URL or select an environment.');
+				} else {
+					for (const bridgeDesc of syncTargets) {
+						try {
+							const bridge = new SyncBridge(bridgeDesc);
+							const bridgeResult = await bridge.execute(
+								syncTarget,
+								{
+									dryRun: dryRun ?? false,
+									force: force ?? false,
+									direction: 'push'
+								},
+								apiToken
+							);
+
+							// Report per-entity results
+							for (const detail of bridgeResult.details) {
+								const label = `${bridgeDesc.id}:${detail.entityId}`;
+								results.push({
+									manifestId: label,
+									action: detail.action,
+									message: detail.message
+								});
+
+								if (!dryRun) {
+									switch (detail.action) {
+										case 'pushed':
+											ui.success(`Pushed: ${label}`);
+											break;
+										case 'skipped':
+											ui.info(`Skipped: ${label} — ${detail.message ?? 'in sync'}`);
+											break;
+										case 'conflict':
+											ui.warn(`Conflict: ${label} — ${detail.message}`);
+											break;
+										case 'error':
+											ui.error(`Error: ${label} — ${detail.message}`);
+											break;
+									}
+								} else {
+									ui.info(`[dry-run] ${label}: ${detail.action} — ${detail.message ?? ''}`);
+								}
+							}
+
+							// Summary line
+							const { pushed, skipped, conflicts, errors } = bridgeResult;
+							ui.info(
+								`Sync ${bridgeDesc.id}: ${pushed} pushed, ${skipped} skipped, ${conflicts} conflicts, ${errors} errors`
+							);
+						} catch (e) {
+							const msg = (e as Error).message;
+							ui.error(`Sync ${bridgeDesc.id} failed: ${msg}`);
+							results.push({ manifestId: bridgeDesc.id, action: 'error', message: msg });
+						}
+					}
+				}
+			}
+
+			if (!dryRun) {
+				const persistedState = await loadSyncState();
+				syncState.manifests = { ...persistedState.manifests, ...syncState.manifests };
+				await saveSyncState(syncState);
+			}
+
+			if (opts.json) {
+				ui.render(results, { format: 'json' });
+			}
+		} catch (e) {
+			ui.error(`Push failed: ${e}`);
+			process.exit(1);
+		}
+	}
+};

package/src/cli/commands/sync/resolve/storage.sync.resolve.cli-command.descriptor.ts

@@ -0,0 +1,22 @@
+import type { CLICommandAssetDescriptor } from '@vibesdotdev/runtime/schemas/asset';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'storage.sync.resolve',
+	name: 'resolve',
+	description: 'Resolve a storage manifest sync conflict',
+	group: 'storage.sync',
+	arguments: [
+		{ name: 'manifest-id', description: 'Manifest ID to resolve', required: true, variadic: false }
+	],
+	options: [
+		{ flags: '--keep <which>', description: 'Keep local or remote version (default: local)' },
+		{ flags: '--json', description: 'Output result as JSON' }
+	],
+	aliases: [],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/cli/commands/sync/resolve/storage.sync.resolve.cli-command.impl.ts

@@ -0,0 +1,129 @@
+/**
+ * vibes storage sync resolve <manifest-id>
+ *
+ * Resolves a sync conflict by keeping either local or remote version.
+ * When --keep=local, re-pushes local data and marks as in-sync.
+ * When --keep=remote, re-pulls remote data and marks as in-sync.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { StorageCliUIContext as UIContext } from '../../../types';
+import {
+	loadSyncState,
+	saveSyncState,
+	getManifestSyncState,
+	markSynced
+} from '../../../../sync/sync-state.consumer';
+import { syncManifest } from '../../../../sync/sync-manifest';
+import { pullFromCloud } from '../../../../sync/cloud-pull';
+import type { SyncHelpers } from '../../../../sync/schemas/sync-helpers';
+import {
+	computeHash,
+	markConflict,
+	markError,
+	markLocalAhead,
+	markRemoteAhead
+} from '../../../../sync/sync-state.consumer';
+
+interface ManifestDescriptor {
+	id: string;
+	allowedAdapters?: string[];
+	enabled?: boolean;
+}
+
+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 manifestId = args['manifest-id'] as string;
+		const keep = (opts.keep as string | undefined) ?? 'local';
+
+		if (keep !== 'local' && keep !== 'remote') {
+			ui.error(`Invalid --keep value: '${keep}'. Must be 'local' or 'remote'.`);
+			process.exit(1);
+		}
+
+		try {
+			const syncState = await loadSyncState();
+			const manifestState = getManifestSyncState(syncState, manifestId);
+
+			if (manifestState.syncStatus !== 'conflict') {
+				ui.warn(
+					`Manifest '${manifestId}' is not in conflict (status: ${manifestState.syncStatus}).`
+				);
+				return;
+			}
+
+			// Verify the manifest exists and is cloud-eligible
+			const descriptors = runtime.query('storage/manifest').descriptors() as ManifestDescriptor[];
+			const descriptor = descriptors.find(
+				(d) =>
+					d.id === manifestId &&
+					d.enabled !== false &&
+					d.allowedAdapters?.includes('storage.cloud-api')
+			);
+
+			if (!descriptor) {
+				ui.error(`Manifest '${manifestId}' not found or not cloud-sync eligible.`);
+				return;
+			}
+
+			let result: { action: string; message?: string };
+
+			if (keep === 'local') {
+				// Re-push local version (force sync with push preference)
+				const helpers: SyncHelpers = {
+					computeHash,
+					getManifestSyncState,
+					markSynced,
+					markConflict,
+					markError,
+					markLocalAhead,
+					markRemoteAhead,
+					dryRun: false
+				};
+
+				result = await syncManifest(manifestId, syncState, helpers);
+
+				if (result.action === 'pushed' || result.action === 'skipped') {
+					// Force mark as synced if the sync itself skipped but we resolved
+					const hash = manifestState.localHash ?? '';
+					markSynced(syncState, manifestId, hash, 'push');
+					result = { action: 'resolved', message: 'Kept local version, pushed to cloud' };
+				}
+			} else {
+				// Pull remote version (force overwrite local)
+				const pullResult = await pullFromCloud({
+					manifestIds: [manifestId],
+					force: true,
+					dryRun: false
+				});
+
+				const detail = pullResult.details.find((d) => d.manifestId === manifestId);
+				if (detail?.action === 'pulled') {
+					result = { action: 'resolved', message: 'Kept remote version, overwrote local' };
+				} else {
+					result = {
+						action: detail?.action ?? 'error',
+						message: detail?.message ?? 'Failed to pull remote version'
+					};
+				}
+			}
+
+			await saveSyncState(syncState);
+
+			if (result.action === 'resolved') {
+				ui.success(`Resolved: ${manifestId} — ${result.message}`);
+			} else {
+				ui.error(`Resolution failed: ${manifestId} — ${result.message}`);
+			}
+
+			if (opts.json) {
+				ui.render({ manifestId, keep, ...result }, { format: 'json' });
+			}
+		} catch (e) {
+			ui.error(`Resolve failed: ${e}`);
+			process.exit(1);
+		}
+	}
+};

package/src/cli/commands/sync/status/storage.sync.status.cli-command.descriptor.ts

@@ -0,0 +1,17 @@
+import type { CLICommandAssetDescriptor } from '@vibesdotdev/runtime/schemas/asset';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'storage.sync.status',
+	name: 'status',
+	description: 'Show synchronization status for all storage manifests',
+	group: 'storage.sync',
+	arguments: [],
+	options: [{ flags: '--json', description: 'Output as JSON' }],
+	aliases: [],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;