@livestore/cli 0.4.0-dev.9 → 0.5.0-dev.0

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

@@ -0,0 +1,112 @@
+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 Queue, Schema } from '@livestore/utils/effect'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+class DynamicImportError extends Schema.TaggedError<DynamicImportError>()('DynamicImportError', {
+  cause: Schema.Defect(),
+  path: Schema.String,
+}) {}
+
+// Use package-local temp directory for test config files to ensure proper module resolution
+const tmpDir = path.join(__dirname, '.tmp-test-configs')
+
+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 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, Queue } from '@livestore/utils/effect'
+
+export const mockBackend = await Effect.runPromise(Effect.scoped(makeMockSyncBackend({ startConnected: true })))
+export const connectionEvents = await Effect.runPromise(Queue.make<'connect' | 'disconnect'>())
+
+export { schema }
+
+export const syncBackend = (_args) =>
+  mockBackend.makeSyncBackend.pipe(
+    Effect.tap(() => Queue.offer(connectionEvents, 'connect')),
+    Effect.map((backend) => {
+      const disconnect = backend.disconnect ?? Effect.void
+      return {
+        ...backend,
+        disconnect: disconnect.pipe(Effect.tap(() => Queue.offer(connectionEvents, '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) => new DynamicImportError({ cause, path: tempPath }),
+    })) as {
+      mockBackend: MockSyncBackend
+      connectionEvents: Queue.Queue<'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.catch(() => 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,218 @@
+import { Effect, FetchHttpClient, Layer, Queue, 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: Queue.Queue<'connect' | 'disconnect'>,
+  ): Effect.Effect<ReadonlyArray<'connect' | 'disconnect'>> =>
+    Stream.fromQueue(mailbox).pipe(Stream.take(2), Stream.runCollect)
+
+  Vitest.live('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.live('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.result)
+
+      expect(result._tag).toBe('Failure')
+      if (result._tag === 'Failure') {
+        expect(result.failure._tag).toBe('ImportError')
+      }
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.live('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.live('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)
+      expect(pushedEvents.map((event) => event.seqNum)).toHaveLength(importBatch.length)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.live('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)
+      expect(pushedEvents).toHaveLength(1)
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+
+  Vitest.live('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.result)
+
+      expect(result._tag).toBe('Failure')
+      if (result._tag === 'Failure') {
+        expect(result.failure._tag).toBe('ImportError')
+      }
+
+      const lifecycle = yield* expectConnectLifecycle(connectionEvents)
+      expect(lifecycle).toEqual(['connect', 'disconnect'])
+    }).pipe(withTestCtx(test)),
+  )
+})

package/src/bin.ts

@@ -1,24 +1,26 @@
 #!/usr/bin/env node
 
 import { liveStoreVersion } from '@livestore/common'
-import { Console, Effect, FetchHttpClient, Layer, Logger, LogLevel } from '@livestore/utils/effect'
+import { Console, Effect, FetchHttpClient, Layer, Logger, References } from '@livestore/utils/effect'
 import { Cli, PlatformNode } from '@livestore/utils/node'
+
 import { command } from './cli.ts'
 
 const cli = Cli.Command.run(command, {
-  name: 'livestore',
   version: liveStoreVersion,
 })
 
-const showExperimentalWarning = Console.log('⚠️  Warning: LiveStore CLI is experimental and under active development')
+const showExperimentalWarning = Console.error('⚠️  Warning: LiveStore CLI is experimental and under active development')
 
 const layer = Layer.mergeAll(
-  PlatformNode.NodeContext.layer,
+  PlatformNode.NodeServices.layer,
   FetchHttpClient.layer,
-  Logger.minimumLogLevel(LogLevel.Info),
+  Layer.succeed(References.MinimumLogLevel, 'Info'),
+  // Keep stdout available for command data and protocol transports such as MCP stdio.
+  Layer.succeed(Logger.LogToStderr, true),
 )
 
 Effect.gen(function* () {
   yield* showExperimentalWarning
-  return yield* cli(process.argv)
+  return yield* cli
 }).pipe(Effect.provide(layer), PlatformNode.NodeRuntime.runMain)

package/src/cli.ts

@@ -1,10 +1,9 @@
 import { Cli } from '@livestore/utils/node'
+
+import { syncCommand } from './commands/import-export.ts'
 import { mcpCommand } from './commands/mcp.ts'
-import { newProjectCommand } from './commands/new-project.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, newProjectCommand]))
-
-if (import.meta.main) {
-}
+  verbose: Cli.Flag.boolean('verbose').pipe(Cli.Flag.withDefault(false)),
+}).pipe(Cli.Command.withSubcommands([mcpCommand, createCommand, syncCommand]))

package/src/commands/__fixtures__/mcp-protocol-server.ts

@@ -0,0 +1,12 @@
+import { McpServer } from 'effect/unstable/ai'
+
+import { Effect, Layer } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+
+import { supportedMcpProtocols } from '../mcp-protocols.ts'
+
+McpServer.layerStdio({
+  name: 'livestore-mcp-protocol-test',
+  version: '0.0.0',
+  protocols: supportedMcpProtocols,
+}).pipe(Layer.provide(PlatformNode.NodeStdio.layer), Layer.launch, Effect.scoped, PlatformNode.NodeRuntime.runMain)

package/src/commands/import-export.ts

@@ -0,0 +1,283 @@
+import path from 'node:path'
+
+import type { UnknownError } from '@livestore/common'
+import { Console, Effect, FileSystem, type HttpClient, Schema, type Scope } from '@livestore/utils/effect'
+import { Cli } from '@livestore/utils/node'
+
+import * as SyncOps from '../sync-operations.ts'
+
+const jsonStringifyPretty = (value: SyncOps.ExportFile) => JSON.stringify(value, null, 2)
+const jsonParse = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))
+
+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) === true ? outputPath : path.resolve(process.cwd(), outputPath)
+
+    yield* fs.writeFileString(absOutputPath, jsonStringifyPretty(result.data)).pipe(
+      Effect.mapError(
+        (cause) =>
+          new SyncOps.ExportError({
+            cause,
+            note: `Failed to write export file: ${String(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) === true ? 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: ${String(cause)}`,
+          }),
+      ),
+    )
+    if (exists === false) {
+      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: ${String(cause)}`,
+          }),
+      ),
+    )
+
+    const parsedContent = yield* Effect.try({
+      try: () => jsonParse(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 === true) {
+      if (force !== true) {
+        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 === true) {
+      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.Flag.string('config').pipe(
+      Cli.Flag.withAlias('c'),
+      Cli.Flag.withDescription('Path to the config module that exports schema and syncBackend'),
+    ),
+    storeId: Cli.Flag.string('store-id').pipe(
+      Cli.Flag.withAlias('i'),
+      Cli.Flag.withDescription('Store identifier'),
+    ),
+    clientId: Cli.Flag.string('client-id').pipe(
+      Cli.Flag.withDefault('cli-export'),
+      Cli.Flag.withDescription('Client identifier for the sync connection'),
+    ),
+    output: Cli.Argument.string('file').pipe(Cli.Argument.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.Flag.string('config').pipe(
+      Cli.Flag.withAlias('c'),
+      Cli.Flag.withDescription('Path to the config module that exports schema and syncBackend'),
+    ),
+    storeId: Cli.Flag.string('store-id').pipe(
+      Cli.Flag.withAlias('i'),
+      Cli.Flag.withDescription('Store identifier'),
+    ),
+    clientId: Cli.Flag.string('client-id').pipe(
+      Cli.Flag.withDefault('cli-import'),
+      Cli.Flag.withDescription('Client identifier for the sync connection'),
+    ),
+    force: Cli.Flag.boolean('force').pipe(
+      Cli.Flag.withAlias('f'),
+      Cli.Flag.withDefault(false),
+      Cli.Flag.withDescription('Force import even if store ID does not match'),
+    ),
+    dryRun: Cli.Flag.boolean('dry-run').pipe(
+      Cli.Flag.withDefault(false),
+      Cli.Flag.withDescription('Validate the import file without actually importing'),
+    ),
+    input: Cli.Argument.string('file').pipe(Cli.Argument.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 === true) yield* Console.log(`   Force: enabled`)
+    if (dryRun === true) 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'),
+)