@livestore/cli 0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6 → 0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/cli",
-  "version": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
+  "version": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -10,18 +10,25 @@
     "livestore": "./dist/bin.js"
   },
   "dependencies": {
+    "@effect/ai": "0.29.0",
     "@effect/ai-openai": "0.32.0",
-    "@livestore/adapter-node": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
-    "@livestore/livestore": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
-    "@livestore/peer-deps": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
-    "@livestore/sync-cf": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
-    "@livestore/common": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6",
-    "@livestore/utils": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6"
+    "@effect/experimental": "0.56.0",
+    "@effect/opentelemetry": "0.58.0",
+    "@effect/platform": "0.92.1",
+    "@effect/rpc": "0.71.1",
+    "@standard-schema/spec": "1.0.0",
+    "effect": "3.18.4",
+    "@livestore/common": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
+    "@livestore/sync-cf": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
+    "@livestore/adapter-node": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
+    "@livestore/livestore": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
+    "@livestore/peer-deps": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8",
+    "@livestore/utils": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8"
   },
   "devDependencies": {
     "@types/node": "24.10.1",
     "typescript": "5.9.2",
-    "@livestore/utils-dev": "0.0.0-snapshot-787c029038cb898b80318bc0495055e6737a40e6"
+    "@livestore/utils-dev": "0.0.0-snapshot-0f27d343553b9bb260543bf20de36d216f53c5d8"
   },
   "files": [
     "package.json",

package/src/__tests__/fixtures/mock-config.ts

@@ -0,0 +1,104 @@
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { Events, makeSchema, State } from '@livestore/common/schema'
+import type { MockSyncBackend } from '@livestore/common/sync'
+import { EventFactory } from '@livestore/common/testing'
+import { Effect, FileSystem, type Mailbox, Schema } from '@livestore/utils/effect'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const items = State.SQLite.table({
+  name: 'items',
+  columns: {
+    id: State.SQLite.text({ primaryKey: true }),
+    title: State.SQLite.text({ default: '', nullable: false }),
+  },
+})
+
+export const events = {
+  itemAdded: Events.synced({
+    name: 'itemAdded',
+    schema: Schema.Struct({ id: Schema.String, title: Schema.String }),
+  }),
+}
+
+const materializers = State.SQLite.materializers(events, {
+  itemAdded: ({ id, title }) => items.insert({ id, title }),
+})
+
+const state = State.SQLite.makeState({
+  tables: { items },
+  materializers,
+})
+
+export const schema = makeSchema({ state, events })
+
+const tmpDir = path.join(process.cwd(), 'tmp', 'cli-sync-tests')
+const schemaModuleUrl = pathToFileURL(path.join(__dirname, 'mock-config.ts')).href
+
+/** Generates a per-test config module exporting schema, a mock backend, and connection event taps. */
+const makeTempConfig = () => {
+  const moduleSource = `
+import { schema } from ${JSON.stringify(schemaModuleUrl)}
+import { makeMockSyncBackend } from '@livestore/common/sync'
+import { Effect, Mailbox } from '@livestore/utils/effect'
+
+export const mockBackend = await Effect.runPromise(Effect.scoped(makeMockSyncBackend({ startConnected: true })))
+export const connectionEvents = await Effect.runPromise(Mailbox.make<'connect' | 'disconnect'>())
+
+export { schema }
+
+export const syncBackend = (_args) =>
+  mockBackend.makeSyncBackend.pipe(
+    Effect.tap(() => connectionEvents.offer('connect')),
+    Effect.map((backend) => {
+      const disconnect = backend.disconnect ?? Effect.void
+      return {
+        ...backend,
+        disconnect: disconnect.pipe(Effect.tap(() => connectionEvents.offer('disconnect'))),
+      }
+    }),
+  )
+`
+
+  return moduleSource
+}
+
+/**
+ * Creates a temporary config module (schema + mock backend) and cleans it up afterwards.
+ * Returns the module path plus handles to the backend and connection event mailbox, keeping lifecycle assertions local to each test.
+ */
+export const useMockConfig = Effect.acquireRelease(
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+
+    yield* fs.makeDirectory(tmpDir, { recursive: true })
+
+    const tempPath = path.join(tmpDir, `mock-config-${Date.now()}-${Math.random().toString(16).slice(2)}.ts`)
+    const moduleSource = makeTempConfig()
+
+    yield* fs.writeFileString(tempPath, moduleSource)
+
+    const mod = (yield* Effect.tryPromise({
+      try: () => import(pathToFileURL(tempPath).href),
+      catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+    })) as {
+      mockBackend: MockSyncBackend
+      connectionEvents: Mailbox.Mailbox<'connect' | 'disconnect'>
+    }
+
+    return { configPath: tempPath, mockBackend: mod.mockBackend, connectionEvents: mod.connectionEvents }
+  }),
+  ({ configPath }) =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+      yield* fs.remove(configPath, { recursive: false }).pipe(Effect.catchAll(() => Effect.void))
+    }),
+)
+
+export const makeEventFactory = () =>
+  EventFactory.makeFactory(events)({
+    client: EventFactory.clientIdentity('cli-test-client'),
+    startSeq: 1,
+    initialParent: 'root',
+  })

package/src/__tests__/sync-operations.test.ts

@@ -0,0 +1,230 @@
+import type { LiveStoreEvent } from '@livestore/common/schema'
+import { Chunk, Effect, FetchHttpClient, Layer, Mailbox, Stream } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import { pullEventsFromSyncBackend, pushEventsToSyncBackend } from '../sync-operations.ts'
+import { makeEventFactory, useMockConfig } from './fixtures/mock-config.ts'
+
+const baseLayer = Layer.mergeAll(PlatformNode.NodeFileSystem.layer, FetchHttpClient.layer)
+const withTestCtx = Vitest.makeWithTestCtx({ makeLayer: () => baseLayer })
+
+/** Each test acquires its own temporary config module via useMockConfig, avoiding shared state. */
+Vitest.describe('sync-operations', { timeout: 10_000 }, () => {
+  const storeId = 'test-store'
+  const clientId = 'test-client'
+
+  /** Collects the connect + disconnect lifecycle emitted by the mock sync backend. */
+  const expectConnectLifecycle = (
+    mailbox: Mailbox.Mailbox<'connect' | 'disconnect'>,
+  ): Effect.Effect<ReadonlyArray<'connect' | 'disconnect'>> =>
+    Mailbox.toStream(mailbox).pipe(
+      Stream.take(2),
+      Stream.runCollect,
+      Effect.map((chunk) => Chunk.toReadonlyArray(chunk)),
+    )
+
+  Vitest.scopedLive('exports events and releases the backend connection', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { mockBackend, connectionEvents, configPath } = yield* useMockConfig
+      const factory = makeEventFactory()
+
+      const batch = [
+        factory.itemAdded.next({ id: 'e1', title: 'First' }),
+        factory.itemAdded.next({ id: 'e2', title: 'Second' }),
+      ]
+
+      yield* mockBackend.advance(...batch)
+
+      const result = yield* pullEventsFromSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+      })
+
+      expect(result.eventCount).toBe(2)
+      expect(result.data.events).toHaveLength(2)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.scopedLive('fails import when backend is not empty', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { mockBackend, connectionEvents, configPath } = yield* useMockConfig
+      const factory = makeEventFactory()
+
+      yield* mockBackend.advance(factory.itemAdded.next({ id: 'existing', title: 'Present' }))
+
+      const importBatch = [
+        factory.itemAdded.next({ id: 'incoming-1', title: 'Incoming' }),
+        factory.itemAdded.next({ id: 'incoming-2', title: 'Incoming 2' }),
+      ]
+
+      const result = yield* pushEventsToSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+        data: {
+          version: 1,
+          storeId,
+          exportedAt: new Date().toISOString(),
+          eventCount: importBatch.length,
+          events: importBatch,
+        },
+        force: false,
+        dryRun: false,
+      }).pipe(Effect.either)
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left._tag).toBe('ImportError')
+      }
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.scopedLive('supports dry-run import and releases backend', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { configPath, connectionEvents } = yield* useMockConfig
+      const factory = makeEventFactory()
+      const importBatch = [factory.itemAdded.next({ id: 'dry-run', title: 'Simulated' })]
+
+      const result = yield* pushEventsToSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+        data: {
+          version: 1,
+          storeId,
+          exportedAt: new Date().toISOString(),
+          eventCount: importBatch.length,
+          events: importBatch,
+        },
+        force: false,
+        dryRun: true,
+      })
+
+      expect(result.dryRun).toBe(true)
+      expect(result.eventCount).toBe(importBatch.length)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.scopedLive('imports events into empty backend with progress and batching', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { mockBackend, configPath, connectionEvents } = yield* useMockConfig
+      const factory = makeEventFactory()
+      const importBatch = Array.from({ length: 120 }, (_, idx) =>
+        factory.itemAdded.next({ id: `id-${idx + 1}`, title: `Item ${idx + 1}` }),
+      )
+
+      const progress: Array<{ pushed: number; total: number }> = []
+
+      const result = yield* pushEventsToSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+        data: {
+          version: 1,
+          storeId,
+          exportedAt: new Date().toISOString(),
+          eventCount: importBatch.length,
+          events: importBatch,
+        },
+        force: false,
+        dryRun: false,
+        onProgress: (pushed, total) => Effect.sync(() => progress.push({ pushed, total })),
+      })
+
+      expect(result.dryRun).toBe(false)
+      expect(result.eventCount).toBe(importBatch.length)
+      expect(progress).toEqual([
+        { pushed: 100, total: 120 },
+        { pushed: 120, total: 120 },
+      ])
+
+      const pushedEvents = yield* mockBackend.pushedEvents.pipe(
+        Stream.take(importBatch.length),
+        Stream.runCollect,
+        Effect.map((chunk: Chunk.Chunk<LiveStoreEvent.Global.Encoded>) => Chunk.toReadonlyArray(chunk)),
+      )
+      expect(pushedEvents.map((event) => event.seqNum)).toHaveLength(importBatch.length)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.scopedLive('allows force import on store ID mismatch', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { mockBackend, configPath, connectionEvents } = yield* useMockConfig
+      const factory = makeEventFactory()
+      const importBatch = [factory.itemAdded.next({ id: 'force-1', title: 'Force' })]
+
+      const result = yield* pushEventsToSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+        data: {
+          version: 1,
+          storeId: 'different-store',
+          exportedAt: new Date().toISOString(),
+          eventCount: importBatch.length,
+          events: importBatch,
+        },
+        force: true,
+        dryRun: false,
+      })
+
+      expect(result.dryRun).toBe(false)
+      expect(result.eventCount).toBe(importBatch.length)
+
+      const pushedEvents = yield* mockBackend.pushedEvents.pipe(
+        Stream.take(1),
+        Stream.runCollect,
+        Effect.map((chunk: Chunk.Chunk<LiveStoreEvent.Global.Encoded>) => Chunk.toReadonlyArray(chunk)),
+      )
+      expect(pushedEvents).toHaveLength(1)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.scopedLive('rejects store ID mismatch without force', (test: Vitest.TestContext) =>
+    Effect.gen(function* () {
+      const { configPath, connectionEvents } = yield* useMockConfig
+      const factory = makeEventFactory()
+      const importBatch = [factory.itemAdded.next({ id: 'mismatch', title: 'Mismatch' })]
+
+      const result = yield* pushEventsToSyncBackend({
+        configPath,
+        storeId,
+        clientId,
+        data: {
+          version: 1,
+          storeId: 'other-store',
+          exportedAt: new Date().toISOString(),
+          eventCount: importBatch.length,
+          events: importBatch,
+        },
+        force: false,
+        dryRun: false,
+      }).pipe(Effect.either)
+
+      expect(result._tag).toBe('Left')
+      if (result._tag === 'Left') {
+        expect(result.left._tag).toBe('ImportError')
+      }
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+})

package/src/cli.ts

@@ -1,7 +1,8 @@
 import { Cli } from '@livestore/utils/node'
+import { syncCommand } from './commands/import-export.ts'
 import { mcpCommand } from './commands/mcp.ts'
 import { createCommand } from './commands/new-project.ts'
 
 export const command = Cli.Command.make('livestore', {
   verbose: Cli.Options.boolean('verbose').pipe(Cli.Options.withDefault(false)),
-}).pipe(Cli.Command.withSubcommands([mcpCommand, createCommand]))
+}).pipe(Cli.Command.withSubcommands([mcpCommand, createCommand, syncCommand]))

package/src/commands/import-export.ts

@@ -0,0 +1,278 @@
+import path from 'node:path'
+import type { UnknownError } from '@livestore/common'
+import { Console, Effect, FileSystem, type HttpClient, type Scope } from '@livestore/utils/effect'
+import { Cli } from '@livestore/utils/node'
+import * as SyncOps from '../sync-operations.ts'
+
+const LARGE_EVENT_WARNING_THRESHOLD = 100_000
+
+/**
+ * Export events from the sync backend to a JSON file.
+ */
+const exportEvents = ({
+  configPath,
+  storeId,
+  clientId,
+  outputPath,
+}: {
+  configPath: string
+  storeId: string
+  clientId: string
+  outputPath: string
+}): Effect.Effect<
+  void,
+  SyncOps.ExportError | SyncOps.ConnectionError | UnknownError,
+  FileSystem.FileSystem | HttpClient.HttpClient | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    yield* Console.log(`Connecting to sync backend...`)
+
+    const result = yield* SyncOps.pullEventsFromSyncBackend({ configPath, storeId, clientId })
+
+    yield* Console.log(`✓ Connected to sync backend: ${result.backendName}`)
+    yield* Console.log(`Pulled ${result.eventCount} events`)
+    if (result.eventCount > LARGE_EVENT_WARNING_THRESHOLD) {
+      yield* Console.log(
+        `Warning: exporting ${result.eventCount} events may consume significant memory. Consider exporting on a machine with enough RAM.`,
+      )
+    }
+
+    const fs = yield* FileSystem.FileSystem
+    const absOutputPath = path.isAbsolute(outputPath) ? outputPath : path.resolve(process.cwd(), outputPath)
+
+    yield* fs.writeFileString(absOutputPath, JSON.stringify(result.data, null, 2)).pipe(
+      Effect.mapError(
+        (cause) =>
+          new SyncOps.ExportError({
+            cause,
+            note: `Failed to write export file: ${cause}`,
+          }),
+      ),
+    )
+
+    yield* Console.log(`Exported ${result.eventCount} events to ${absOutputPath}`)
+  }).pipe(Effect.withSpan('cli:export'))
+
+/**
+ * Import events from a JSON file to the sync backend.
+ */
+const importEvents = ({
+  configPath,
+  storeId,
+  clientId,
+  inputPath,
+  force,
+  dryRun,
+}: {
+  configPath: string
+  storeId: string
+  clientId: string
+  inputPath: string
+  force: boolean
+  dryRun: boolean
+}): Effect.Effect<
+  void,
+  SyncOps.ImportError | SyncOps.ConnectionError | UnknownError,
+  FileSystem.FileSystem | HttpClient.HttpClient | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const absInputPath = path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath)
+
+    const exists = yield* fs.exists(absInputPath).pipe(
+      Effect.mapError(
+        (cause) =>
+          new SyncOps.ImportError({
+            cause,
+            note: `Failed to check file existence: ${cause}`,
+          }),
+      ),
+    )
+    if (!exists) {
+      return yield* new SyncOps.ImportError({
+        cause: new Error(`File not found: ${absInputPath}`),
+        note: `Import file does not exist at ${absInputPath}`,
+      })
+    }
+
+    yield* Console.log(`Reading import file...`)
+
+    const fileContent = yield* fs.readFileString(absInputPath).pipe(
+      Effect.mapError(
+        (cause) =>
+          new SyncOps.ImportError({
+            cause,
+            note: `Failed to read import file: ${cause}`,
+          }),
+      ),
+    )
+
+    const parsedContent = yield* Effect.try({
+      try: () => JSON.parse(fileContent),
+      catch: (error) =>
+        new SyncOps.ImportError({
+          cause: new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`),
+          note: `Invalid JSON in import file: ${error instanceof Error ? error.message : String(error)}`,
+        }),
+    })
+
+    /** Validate export file format before proceeding */
+    const validation = yield* SyncOps.validateExportData({ data: parsedContent, targetStoreId: storeId })
+
+    if (validation.storeIdMismatch) {
+      if (!force) {
+        return yield* new SyncOps.ImportError({
+          cause: new Error(`Store ID mismatch: file has '${validation.sourceStoreId}', expected '${storeId}'`),
+          note: `The export file was created for a different store. Use --force to import anyway.`,
+        })
+      }
+      yield* Console.log(
+        `Store ID mismatch: file has '${validation.sourceStoreId}', importing to '${storeId}' (--force)`,
+      )
+    }
+
+    yield* Console.log(`Found ${validation.eventCount} events in export file`)
+    if (validation.eventCount > LARGE_EVENT_WARNING_THRESHOLD) {
+      yield* Console.log(
+        `Warning: importing ${validation.eventCount} events may consume significant memory. Ensure the machine has enough RAM.`,
+      )
+    }
+
+    if (dryRun) {
+      yield* Console.log(`Dry run - validating import file...`)
+      yield* Console.log(`Dry run complete. ${validation.eventCount} events would be imported.`)
+      return
+    }
+
+    yield* Console.log(`Checking for existing events...`)
+
+    yield* Console.log(`Connecting to sync backend...`)
+    yield* Console.log(`Pushing events to sync backend...`)
+
+    const result = yield* SyncOps.pushEventsToSyncBackend({
+      configPath,
+      storeId,
+      clientId,
+      data: parsedContent,
+      force,
+      dryRun: false,
+      onProgress: (pushed, total) => Console.log(`  Pushed ${pushed}/${total} events`),
+    })
+
+    yield* Console.log(`✓ Connected to sync backend: ${result.backendName ?? 'unknown'}`)
+    yield* Console.log(`Successfully imported ${result.eventCount} events`)
+  }).pipe(Effect.withSpan('cli:import'))
+
+export const exportCommand = Cli.Command.make(
+  'export',
+  {
+    config: Cli.Options.text('config').pipe(
+      Cli.Options.withAlias('c'),
+      Cli.Options.withDescription('Path to the config module that exports schema and syncBackend'),
+    ),
+    storeId: Cli.Options.text('store-id').pipe(
+      Cli.Options.withAlias('i'),
+      Cli.Options.withDescription('Store identifier'),
+    ),
+    clientId: Cli.Options.text('client-id').pipe(
+      Cli.Options.withDefault('cli-export'),
+      Cli.Options.withDescription('Client identifier for the sync connection'),
+    ),
+    output: Cli.Args.text({ name: 'file' }).pipe(Cli.Args.withDescription('Output JSON file path')),
+  },
+  Effect.fn(function* ({
+    config,
+    storeId,
+    clientId,
+    output,
+  }: {
+    config: string
+    storeId: string
+    clientId: string
+    output: string
+  }) {
+    yield* Console.log(`Exporting events from LiveStore...`)
+    yield* Console.log(`   Config: ${config}`)
+    yield* Console.log(`   Store ID: ${storeId}`)
+    yield* Console.log(`   Output: ${output}`)
+    yield* Console.log('')
+
+    yield* exportEvents({
+      configPath: config,
+      storeId,
+      clientId,
+      outputPath: output,
+    }).pipe(Effect.scoped)
+  }),
+).pipe(
+  Cli.Command.withDescription(
+    'Export all events from the sync backend to a JSON file. Useful for backup and migration.',
+  ),
+)
+
+export const importCommand = Cli.Command.make(
+  'import',
+  {
+    config: Cli.Options.text('config').pipe(
+      Cli.Options.withAlias('c'),
+      Cli.Options.withDescription('Path to the config module that exports schema and syncBackend'),
+    ),
+    storeId: Cli.Options.text('store-id').pipe(
+      Cli.Options.withAlias('i'),
+      Cli.Options.withDescription('Store identifier'),
+    ),
+    clientId: Cli.Options.text('client-id').pipe(
+      Cli.Options.withDefault('cli-import'),
+      Cli.Options.withDescription('Client identifier for the sync connection'),
+    ),
+    force: Cli.Options.boolean('force').pipe(
+      Cli.Options.withAlias('f'),
+      Cli.Options.withDefault(false),
+      Cli.Options.withDescription('Force import even if store ID does not match'),
+    ),
+    dryRun: Cli.Options.boolean('dry-run').pipe(
+      Cli.Options.withDefault(false),
+      Cli.Options.withDescription('Validate the import file without actually importing'),
+    ),
+    input: Cli.Args.text({ name: 'file' }).pipe(Cli.Args.withDescription('Input JSON file to import')),
+  },
+  Effect.fn(function* ({
+    config,
+    storeId,
+    clientId,
+    force,
+    dryRun,
+    input,
+  }: {
+    config: string
+    storeId: string
+    clientId: string
+    force: boolean
+    dryRun: boolean
+    input: string
+  }) {
+    yield* Console.log(`Importing events to LiveStore...`)
+    yield* Console.log(`   Config: ${config}`)
+    yield* Console.log(`   Store ID: ${storeId}`)
+    yield* Console.log(`   Input: ${input}`)
+    if (force) yield* Console.log(`   Force: enabled`)
+    if (dryRun) yield* Console.log(`   Dry run: enabled`)
+    yield* Console.log('')
+
+    yield* importEvents({
+      configPath: config,
+      storeId,
+      clientId,
+      inputPath: input,
+      force,
+      dryRun,
+    }).pipe(Effect.scoped)
+  }),
+).pipe(
+  Cli.Command.withDescription('Import events from a JSON file to the sync backend. The sync backend must be empty.'),
+)
+
+export const syncCommand = Cli.Command.make('sync').pipe(
+  Cli.Command.withSubcommands([exportCommand, importCommand]),
+  Cli.Command.withDescription('Import and export events from the sync backend'),
+)