@livestore/cli 0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c → 0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/cli",
-  "version": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
+  "version": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -11,17 +11,17 @@
   },
   "dependencies": {
     "@effect/ai-openai": "0.32.0",
-    "@livestore/adapter-node": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
-    "@livestore/livestore": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
-    "@livestore/common": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
-    "@livestore/peer-deps": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
-    "@livestore/sync-cf": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c",
-    "@livestore/utils": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c"
+    "@livestore/adapter-node": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
+    "@livestore/common": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
+    "@livestore/peer-deps": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
+    "@livestore/livestore": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
+    "@livestore/sync-cf": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b",
+    "@livestore/utils": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b"
   },
   "devDependencies": {
     "@types/node": "24.10.1",
     "typescript": "5.9.2",
-    "@livestore/utils-dev": "0.0.0-snapshot-b38bc9fa61134ae035254562c7155b3f381d5f6c"
+    "@livestore/utils-dev": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b"
   },
   "files": [
     "package.json",

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,262 @@
+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'
+
+/**
+ * Export events from the sync backend to a JSON file.
+ */
+const exportEvents = ({
+  storePath,
+  storeId,
+  clientId,
+  outputPath,
+}: {
+  storePath: 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({ storePath, storeId, clientId })
+
+    yield* Console.log(`✓ Connected to sync backend`)
+    yield* Console.log(`Pulled ${result.eventCount} events`)
+
+    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 = ({
+  storePath,
+  storeId,
+  clientId,
+  inputPath,
+  force,
+  dryRun,
+}: {
+  storePath: 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 (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(`Connecting to sync backend...`)
+
+    const result = yield* SyncOps.pushEventsToSyncBackend({
+      storePath,
+      storeId,
+      clientId,
+      data: parsedContent,
+      force,
+      dryRun: false,
+    })
+
+    yield* Console.log(`✓ Connected to sync backend`)
+    yield* Console.log(`Successfully imported ${result.eventCount} events`)
+  }).pipe(Effect.withSpan('cli:import'))
+
+export const exportCommand = Cli.Command.make(
+  'export',
+  {
+    store: Cli.Options.text('store').pipe(
+      Cli.Options.withAlias('s'),
+      Cli.Options.withDescription('Path to the store 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* ({
+    store,
+    storeId,
+    clientId,
+    output,
+  }: {
+    store: string
+    storeId: string
+    clientId: string
+    output: string
+  }) {
+    yield* Console.log(`Exporting events from LiveStore...`)
+    yield* Console.log(`   Store: ${store}`)
+    yield* Console.log(`   Store ID: ${storeId}`)
+    yield* Console.log(`   Output: ${output}`)
+    yield* Console.log('')
+
+    yield* exportEvents({
+      storePath: store,
+      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',
+  {
+    store: Cli.Options.text('store').pipe(
+      Cli.Options.withAlias('s'),
+      Cli.Options.withDescription('Path to the store 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* ({
+    store,
+    storeId,
+    clientId,
+    force,
+    dryRun,
+    input,
+  }: {
+    store: string
+    storeId: string
+    clientId: string
+    force: boolean
+    dryRun: boolean
+    input: string
+  }) {
+    yield* Console.log(`Importing events to LiveStore...`)
+    yield* Console.log(`   Store: ${store}`)
+    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({
+      storePath: store,
+      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'),
+)

package/src/commands/mcp-tool-handlers.ts

@@ -1,12 +1,17 @@
-import { Effect } from '@livestore/utils/effect'
+import { Effect, FetchHttpClient, Layer } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
 import { blogSchemaContent } from '../mcp-content/schemas/blog.ts'
 import { ecommerceSchemaContent } from '../mcp-content/schemas/ecommerce.ts'
 import { socialSchemaContent } from '../mcp-content/schemas/social.ts'
 import { todoSchemaContent } from '../mcp-content/schemas/todo.ts'
 import * as Runtime from '../mcp-runtime/runtime.ts'
+import * as SyncOps from '../sync-operations.ts'
 import { coachToolHandler } from './mcp-coach.ts'
 import { livestoreToolkit } from './mcp-tools-defs.ts'
 
+/** Layer providing FileSystem and HttpClient for sync operations */
+const SyncOpsLayer = Layer.mergeAll(PlatformNode.NodeFileSystem.layer, FetchHttpClient.layer)
+
 // Tool handlers using Tim Smart's pattern
 export const toolHandlers: any = livestoreToolkit.of({
   livestore_coach: coachToolHandler,
@@ -156,4 +161,32 @@ export const schema = Schema.create({
   livestore_instance_disconnect: Effect.fnUntraced(function* () {
     return yield* Runtime.disconnect
   }),
+
+  // Sync export - pull all events from sync backend
+  livestore_sync_export: Effect.fnUntraced(function* ({ storePath, storeId, clientId }) {
+    const result = yield* SyncOps.pullEventsFromSyncBackend({
+      storePath,
+      storeId,
+      clientId: clientId ?? 'mcp-export',
+    }).pipe(Effect.scoped, Effect.provide(SyncOpsLayer), Effect.orDie)
+
+    return {
+      storeId: result.storeId,
+      eventCount: result.eventCount,
+      exportedAt: result.exportedAt,
+      data: result.data,
+    }
+  }),
+
+  // Sync import - push events to sync backend
+  livestore_sync_import: Effect.fnUntraced(function* ({ storePath, storeId, clientId, data, force, dryRun }) {
+    return yield* SyncOps.pushEventsToSyncBackend({
+      storePath,
+      storeId,
+      clientId: clientId ?? 'mcp-import',
+      data,
+      force: force ?? false,
+      dryRun: dryRun ?? false,
+    }).pipe(Effect.scoped, Effect.provide(SyncOpsLayer), Effect.orDie)
+  }),
 })

package/src/commands/mcp-tools-defs.ts

@@ -63,13 +63,13 @@ export const syncPayload = { authToken: process.env.LIVESTORE_SYNC_AUTH_TOKEN ??
 
 Connect parameters:
 {
-  "storePath": "<path-to-your-mcp-module>.ts",
+  "storePath": "livestore-cli.config.ts",
   "storeId": "<store-id>"
 }
 
 Optional identifiers to group client state on the server:
 {
-  "storePath": "<path-to-your-mcp-module>.ts",
+  "storePath": "livestore-cli.config.ts",
   "storeId": "<store-id>",
   "clientId": "<client-id>",
   "sessionId": "<session-id>"
@@ -226,4 +226,92 @@ Example success:
     parameters: {},
     success: Schema.TaggedStruct('disconnected', {}),
   }),
+
+  Tool.make('livestore_sync_export', {
+    description: `Export all events from a sync backend to JSON data.
+
+This tool connects directly to the sync backend (without creating a full LiveStore instance) and pulls all events. Useful for backup, migration, and debugging.
+
+Module contract (same as livestore_instance_connect):
+\`\`\`ts
+export { schema } from './src/livestore/schema.ts'
+export const syncBackend = makeWsSync({ url: process.env.LIVESTORE_SYNC_URL ?? 'ws://localhost:8787' })
+export const syncPayload = { authToken: process.env.LIVESTORE_SYNC_AUTH_TOKEN }
+\`\`\`
+
+Example parameters:
+{
+  "storePath": "livestore-cli.config.ts",
+  "storeId": "my-store"
+}
+
+Returns on success:
+{
+  "storeId": "my-store",
+  "eventCount": 127,
+  "exportedAt": "2024-01-15T10:30:00.000Z",
+  "data": { "version": 1, "storeId": "my-store", ... }
+}`,
+    parameters: {
+      storePath: Schema.String.annotations({
+        description: 'Path to a module that exports schema and syncBackend',
+      }),
+      storeId: Schema.String.annotations({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotations({ description: 'Client identifier (default: mcp-export)' })),
+    },
+    success: Schema.Struct({
+      storeId: Schema.String,
+      eventCount: Schema.Number,
+      exportedAt: Schema.String,
+      data: Schema.JsonValue.annotations({ description: 'The export file data (can be saved or passed to import)' }),
+    }),
+  }).annotate(Tool.Readonly, true),
+
+  Tool.make('livestore_sync_import', {
+    description: `Import events from export data to a sync backend.
+
+This tool connects directly to the sync backend and pushes events. The sync backend must be empty.
+
+Example parameters:
+{
+  "storePath": "livestore-cli.config.ts",
+  "storeId": "my-store",
+  "data": { "version": 1, "storeId": "my-store", "events": [...] }
+}
+
+With options:
+{
+  "storePath": "livestore-cli.config.ts",
+  "storeId": "my-store",
+  "data": { ... },
+  "force": true,  // Import even if store ID doesn't match
+  "dryRun": true  // Validate without importing
+}
+
+Returns on success:
+{
+  "storeId": "my-store",
+  "eventCount": 127,
+  "dryRun": false
+}`,
+    parameters: {
+      storePath: Schema.String.annotations({
+        description: 'Path to a module that exports schema and syncBackend',
+      }),
+      storeId: Schema.String.annotations({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotations({ description: 'Client identifier (default: mcp-import)' })),
+      data: Schema.JsonValue.annotations({
+        description: 'The export data to import (from livestore_sync_export or a file)',
+      }),
+      force: Schema.optional(
+        Schema.Boolean.annotations({ description: 'Force import even if store ID does not match' }),
+      ),
+      dryRun: Schema.optional(Schema.Boolean.annotations({ description: 'Validate without actually importing' })),
+    },
+    success: Schema.Struct({
+      storeId: Schema.String,
+      eventCount: Schema.Number,
+      dryRun: Schema.Boolean,
+    }),
+  }).annotate(Tool.Destructive, true),
 )