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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/cli",
-  "version": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
+  "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-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
-    "@livestore/livestore": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
-    "@livestore/common": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
-    "@livestore/peer-deps": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
-    "@livestore/sync-cf": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c",
-    "@livestore/utils": "0.0.0-snapshot-d8085caf44a1e13adef4e8c199343a8cbca2e45c"
+    "@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-d8085caf44a1e13adef4e8c199343a8cbca2e45c"
+    "@livestore/utils-dev": "0.0.0-snapshot-75de2b24a1fb1df981b56b5d9ec7381ea351e95b"
   },
   "files": [
     "package.json",

package/src/commands/import-export.ts

@@ -1,200 +1,8 @@
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import type { SyncBackend } from '@livestore/common'
-import { UnknownError } from '@livestore/common'
-import { isLiveStoreSchema, LiveStoreEvent } from '@livestore/common/schema'
-import { shouldNeverHappen } from '@livestore/utils'
-import {
-  Cause,
-  Console,
-  Effect,
-  FileSystem,
-  type HttpClient,
-  KeyValueStore,
-  Layer,
-  Option,
-  Schema,
-  type Scope,
-  Stream,
-} from '@livestore/utils/effect'
+import type { UnknownError } from '@livestore/common'
+import { Console, Effect, FileSystem, type HttpClient, type Scope } from '@livestore/utils/effect'
 import { Cli } from '@livestore/utils/node'
-
-/** Connection timeout for sync backend ping (5 seconds) */
-const CONNECTION_TIMEOUT_MS = 5000
-
-/**
- * Schema for the export file format.
- * Contains metadata about the export and an array of events in global encoded format.
- */
-const ExportFileSchema = Schema.Struct({
-  /** Format version for future compatibility */
-  version: Schema.Literal(1),
-  /** Store identifier */
-  storeId: Schema.String,
-  /** ISO timestamp of when the export was created */
-  exportedAt: Schema.String,
-  /** Total number of events in the export */
-  eventCount: Schema.Number,
-  /** Array of events in global encoded format */
-  events: Schema.Array(LiveStoreEvent.Global.Encoded),
-})
-
-type ExportFile = typeof ExportFileSchema.Type
-
-class ConnectionError extends Schema.TaggedError<ConnectionError>()('ConnectionError', {
-  cause: Schema.Defect,
-  note: Schema.String,
-}) {}
-
-class ExportError extends Schema.TaggedError<ExportError>()('ExportError', {
-  cause: Schema.Defect,
-  note: Schema.String,
-}) {}
-
-class ImportError extends Schema.TaggedError<ImportError>()('ImportError', {
-  cause: Schema.Defect,
-  note: Schema.String,
-}) {}
-
-/**
- * Creates a sync backend connection from a user module and verifies connectivity.
- * This is a simplified version of the MCP runtime that only creates the sync backend.
- */
-const makeSyncBackend = ({
-  storePath,
-  storeId,
-  clientId,
-}: {
-  storePath: string
-  storeId: string
-  clientId: string
-}): Effect.Effect<
-  SyncBackend.SyncBackend,
-  UnknownError | ConnectionError,
-  FileSystem.FileSystem | HttpClient.HttpClient | Scope.Scope
-> =>
-  Effect.gen(function* () {
-    const abs = path.isAbsolute(storePath) ? storePath : path.resolve(process.cwd(), storePath)
-
-    const fs = yield* FileSystem.FileSystem
-    const exists = yield* fs.exists(abs).pipe(UnknownError.mapToUnknownError)
-    if (!exists) {
-      return yield* Effect.fail(
-        UnknownError.make({
-          cause: `Store module not found at ${abs}`,
-          note: 'Make sure the path points to a valid LiveStore module',
-        }),
-      )
-    }
-
-    const mod = yield* Effect.tryPromise({
-      try: () => import(pathToFileURL(abs).href),
-      catch: (cause) =>
-        UnknownError.make({
-          cause,
-          note: `Failed to import module at ${abs}`,
-        }),
-    })
-
-    const schema = (mod as any)?.schema
-    if (!isLiveStoreSchema(schema)) {
-      return yield* Effect.fail(
-        UnknownError.make({
-          cause: `Module at ${abs} must export a valid LiveStore 'schema'`,
-          note: `Ex: export { schema } from './src/livestore/schema.ts'`,
-        }),
-      )
-    }
-
-    const syncBackendConstructor = (mod as any)?.syncBackend
-    if (typeof syncBackendConstructor !== 'function') {
-      return yield* Effect.fail(
-        UnknownError.make({
-          cause: `Module at ${abs} must export a 'syncBackend' constructor`,
-          note: `Ex: export const syncBackend = makeWsSync({ url })`,
-        }),
-      )
-    }
-
-    const syncPayloadSchemaExport = (mod as any)?.syncPayloadSchema
-    const syncPayloadSchema =
-      syncPayloadSchemaExport === undefined
-        ? Schema.JsonValue
-        : Schema.isSchema(syncPayloadSchemaExport)
-          ? (syncPayloadSchemaExport as Schema.Schema<any>)
-          : shouldNeverHappen(
-              `Exported 'syncPayloadSchema' from ${abs} must be an Effect Schema (received ${typeof syncPayloadSchemaExport}).`,
-            )
-
-    const syncPayloadExport = (mod as any)?.syncPayload
-    const syncPayload = yield* (
-      syncPayloadExport === undefined
-        ? Effect.succeed<unknown>(undefined)
-        : Schema.decodeUnknown(syncPayloadSchema)(syncPayloadExport)
-    ).pipe(UnknownError.mapToUnknownError)
-
-    /** Simple in-memory key-value store for sync backend state */
-    const kvStore: { backendId: string | undefined } = { backendId: undefined }
-
-    const syncBackend = yield* (syncBackendConstructor as SyncBackend.SyncBackendConstructor)({
-      storeId,
-      clientId,
-      payload: syncPayload,
-    }).pipe(
-      Effect.provide(
-        Layer.succeed(
-          KeyValueStore.KeyValueStore,
-          KeyValueStore.makeStringOnly({
-            get: (_key) => Effect.succeed(Option.fromNullable(kvStore.backendId)),
-            set: (_key, value) =>
-              Effect.sync(() => {
-                kvStore.backendId = value
-              }),
-            clear: Effect.dieMessage('Not implemented'),
-            remove: () => Effect.dieMessage('Not implemented'),
-            size: Effect.dieMessage('Not implemented'),
-          }),
-        ),
-      ),
-      UnknownError.mapToUnknownError,
-    )
-
-    /** Connect to the sync backend */
-    yield* syncBackend.connect.pipe(
-      Effect.mapError(
-        (cause) =>
-          new ConnectionError({
-            cause,
-            note: `Failed to connect to sync backend: ${cause._tag === 'IsOfflineError' ? 'Backend is offline or unreachable' : String(cause)}`,
-          }),
-      ),
-    )
-
-    /** Verify connectivity with a ping (with timeout) */
-    yield* syncBackend.ping.pipe(
-      Effect.timeout(CONNECTION_TIMEOUT_MS),
-      Effect.catchAll((cause) => {
-        if (Cause.isTimeoutException(cause)) {
-          return Effect.fail(
-            new ConnectionError({
-              cause,
-              note: `Connection timeout: Sync backend did not respond within ${CONNECTION_TIMEOUT_MS}ms`,
-            }),
-          )
-        }
-        return Effect.fail(
-          new ConnectionError({
-            cause,
-            note: `Failed to ping sync backend: ${cause._tag === 'IsOfflineError' ? 'Backend is offline or unreachable' : String(cause)}`,
-          }),
-        )
-      }),
-    )
-
-    yield* Console.log(`✓ Connected to sync backend: ${syncBackend.metadata.name}`)
-
-    return syncBackend
-  })
+import * as SyncOps from '../sync-operations.ts'
 
 /**
  * Export events from the sync backend to a JSON file.
@@ -211,61 +19,31 @@ const exportEvents = ({
   outputPath: string
 }): Effect.Effect<
   void,
-  ExportError | UnknownError | ConnectionError,
+  SyncOps.ExportError | SyncOps.ConnectionError | UnknownError,
   FileSystem.FileSystem | HttpClient.HttpClient | Scope.Scope
 > =>
   Effect.gen(function* () {
     yield* Console.log(`Connecting to sync backend...`)
 
-    const syncBackend = yield* makeSyncBackend({ storePath, storeId, clientId })
-
-    yield* Console.log(`Pulling events from sync backend...`)
+    const result = yield* SyncOps.pullEventsFromSyncBackend({ storePath, storeId, clientId })
 
-    const events: LiveStoreEvent.Global.Encoded[] = []
-
-    yield* syncBackend.pull(Option.none(), { live: false }).pipe(
-      Stream.tap((item) =>
-        Effect.sync(() => {
-          for (const { eventEncoded } of item.batch) {
-            events.push(eventEncoded)
-          }
-        }),
-      ),
-      Stream.takeUntil((item) => item.pageInfo._tag === 'NoMore'),
-      Stream.runDrain,
-      Effect.mapError(
-        (cause) =>
-          new ExportError({
-            cause,
-            note: `Failed to pull events from sync backend: ${cause}`,
-          }),
-      ),
-    )
-
-    yield* Console.log(`Pulled ${events.length} events`)
-
-    const exportData: ExportFile = {
-      version: 1,
-      storeId,
-      exportedAt: new Date().toISOString(),
-      eventCount: events.length,
-      events,
-    }
+    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(exportData, null, 2)).pipe(
+    yield* fs.writeFileString(absOutputPath, JSON.stringify(result.data, null, 2)).pipe(
       Effect.mapError(
         (cause) =>
-          new ExportError({
+          new SyncOps.ExportError({
             cause,
             note: `Failed to write export file: ${cause}`,
           }),
       ),
     )
 
-    yield* Console.log(`Exported ${events.length} events to ${absOutputPath}`)
+    yield* Console.log(`Exported ${result.eventCount} events to ${absOutputPath}`)
   }).pipe(Effect.withSpan('cli:export'))
 
 /**
@@ -287,21 +65,27 @@ const importEvents = ({
   dryRun: boolean
 }): Effect.Effect<
   void,
-  ImportError | UnknownError | ConnectionError,
+  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(UnknownError.mapToUnknownError)
+    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* Effect.fail(
-        new ImportError({
-          cause: new Error(`File not found: ${absInputPath}`),
-          note: `Import file does not exist at ${absInputPath}`,
-        }),
-      )
+      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...`)
@@ -309,7 +93,7 @@ const importEvents = ({
     const fileContent = yield* fs.readFileString(absInputPath).pipe(
       Effect.mapError(
         (cause) =>
-          new ImportError({
+          new SyncOps.ImportError({
             cause,
             note: `Failed to read import file: ${cause}`,
           }),
@@ -319,100 +103,48 @@ const importEvents = ({
     const parsedContent = yield* Effect.try({
       try: () => JSON.parse(fileContent),
       catch: (error) =>
-        new ImportError({
+        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)}`,
         }),
     })
 
-    const exportData = yield* Schema.decodeUnknown(ExportFileSchema)(parsedContent).pipe(
-      Effect.mapError(
-        (cause) =>
-          new ImportError({
-            cause: new Error(`Invalid export file format: ${cause}`),
-            note: `Invalid export file format: ${cause}`,
-          }),
-      ),
-    )
+    /** Validate export file format before proceeding */
+    const validation = yield* SyncOps.validateExportData({ data: parsedContent, targetStoreId: storeId })
 
-    if (exportData.storeId !== storeId) {
+    if (validation.storeIdMismatch) {
       if (!force) {
-        return yield* Effect.fail(
-          new ImportError({
-            cause: new Error(`Store ID mismatch: file has '${exportData.storeId}', expected '${storeId}'`),
-            note: `The export file was created for a different store. Use --force to import anyway.`,
-          }),
-        )
+        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 '${exportData.storeId}', importing to '${storeId}' (--force)`)
+      yield* Console.log(
+        `Store ID mismatch: file has '${validation.sourceStoreId}', importing to '${storeId}' (--force)`,
+      )
     }
 
-    yield* Console.log(`Found ${exportData.events.length} events in export file`)
+    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. ${exportData.events.length} events would be imported.`)
+      yield* Console.log(`Dry run complete. ${validation.eventCount} events would be imported.`)
       return
     }
 
     yield* Console.log(`Connecting to sync backend...`)
 
-    const syncBackend = yield* makeSyncBackend({ storePath, storeId, clientId })
-
-    /** Check if events already exist by pulling from the backend first */
-    yield* Console.log(`Checking for existing events...`)
-
-    let existingEventCount = 0
-    yield* syncBackend.pull(Option.none(), { live: false }).pipe(
-      Stream.tap((item) =>
-        Effect.sync(() => {
-          existingEventCount += item.batch.length
-        }),
-      ),
-      Stream.takeUntil((item) => item.pageInfo._tag === 'NoMore'),
-      Stream.runDrain,
-      Effect.mapError(
-        (cause) =>
-          new ImportError({
-            cause,
-            note: `Failed to check existing events: ${cause}`,
-          }),
-      ),
-    )
-
-    if (existingEventCount > 0) {
-      return yield* Effect.fail(
-        new ImportError({
-          cause: new Error(`Sync backend already contains ${existingEventCount} events`),
-          note: `Cannot import into a non-empty sync backend. The sync backend must be empty.`,
-        }),
-      )
-    }
-
-    yield* Console.log(`Pushing ${exportData.events.length} events to sync backend...`)
-
-    /** Push events in batches of 100 (sync backend constraint) */
-    const batchSize = 100
-    let pushed = 0
-
-    for (let i = 0; i < exportData.events.length; i += batchSize) {
-      const batch = exportData.events.slice(i, i + batchSize)
-
-      yield* syncBackend.push(batch).pipe(
-        Effect.mapError(
-          (cause) =>
-            new ImportError({
-              cause,
-              note: `Failed to push events at position ${i}: ${cause}`,
-            }),
-        ),
-      )
-
-      pushed += batch.length
-      yield* Console.log(`  Pushed ${pushed}/${exportData.events.length} events`)
-    }
+    const result = yield* SyncOps.pushEventsToSyncBackend({
+      storePath,
+      storeId,
+      clientId,
+      data: parsedContent,
+      force,
+      dryRun: false,
+    })
 
-    yield* Console.log(`Successfully imported ${exportData.events.length} events`)
+    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(

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

@@ -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),
 )