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

package/src/mcp-content/schemas/social.ts

@@ -19,7 +19,7 @@ export const tables = {
       allowsFollowers: State.SQLite.boolean({ default: true }),
     },
   }),
-  
+
   posts: State.SQLite.table({
     name: 'posts',
     columns: {
@@ -34,7 +34,7 @@ export const tables = {
       deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   follows: State.SQLite.table({
     name: 'follows',
     columns: {
@@ -45,7 +45,7 @@ export const tables = {
       approvedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   likes: State.SQLite.table({
     name: 'likes',
     columns: {
@@ -54,7 +54,7 @@ export const tables = {
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   // Aggregate tables for performance (eventually consistent)
   postStats: State.SQLite.table({
     name: 'post_stats',
@@ -66,9 +66,9 @@ export const tables = {
       lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   userStats: State.SQLite.table({
-    name: 'user_stats', 
+    name: 'user_stats',
     columns: {
       userId: State.SQLite.text({ primaryKey: true }),
       followerCount: State.SQLite.integer({ default: 0 }),
@@ -77,7 +77,7 @@ export const tables = {
       lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   // Client-side state for UI
   feedState: State.SQLite.clientDocument({
     name: 'feedState',
@@ -86,8 +86,8 @@ export const tables = {
       lastRefresh: Schema.Date,
       scrollPosition: Schema.Number,
     }),
-    default: { 
-      id: SessionIdSymbol, 
+    default: {
+      id: SessionIdSymbol,
       value: { currentFeed: 'home', lastRefresh: new Date(), scrollPosition: 0 }
     },
   }),
@@ -105,7 +105,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   userProfileUpdated: Events.synced({
     name: 'v1.UserProfileUpdated',
     schema: Schema.Struct({
@@ -115,7 +115,7 @@ export const events = {
       avatarUrl: Schema.NullOr(Schema.String),
     }),
   }),
-  
+
   userPrivacySettingsChanged: Events.synced({
     name: 'v1.UserPrivacySettingsChanged',
     schema: Schema.Struct({
@@ -124,7 +124,7 @@ export const events = {
       allowsFollowers: Schema.Boolean,
     }),
   }),
-  
+
   userLastActiveUpdated: Events.synced({
     name: 'v1.UserLastActiveUpdated',
     schema: Schema.Struct({
@@ -132,7 +132,7 @@ export const events = {
       lastActiveAt: Schema.Date,
     }),
   }),
-  
+
   // Post events
   postCreated: Events.synced({
     name: 'v1.PostCreated',
@@ -146,7 +146,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   postEdited: Events.synced({
     name: 'v1.PostEdited',
     schema: Schema.Struct({
@@ -155,7 +155,7 @@ export const events = {
       editedAt: Schema.Date,
     }),
   }),
-  
+
   postDeleted: Events.synced({
     name: 'v1.PostDeleted',
     schema: Schema.Struct({
@@ -163,7 +163,7 @@ export const events = {
       deletedAt: Schema.Date,
     }),
   }),
-  
+
   // Social interaction events
   followRequested: Events.synced({
     name: 'v1.FollowRequested',
@@ -173,7 +173,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   followApproved: Events.synced({
     name: 'v1.FollowApproved',
     schema: Schema.Struct({
@@ -182,7 +182,7 @@ export const events = {
       approvedAt: Schema.Date,
     }),
   }),
-  
+
   unfollowed: Events.synced({
     name: 'v1.Unfollowed',
     schema: Schema.Struct({
@@ -190,7 +190,7 @@ export const events = {
       followingId: Schema.String,
     }),
   }),
-  
+
   postLiked: Events.synced({
     name: 'v1.PostLiked',
     schema: Schema.Struct({
@@ -199,7 +199,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   postUnliked: Events.synced({
     name: 'v1.PostUnliked',
     schema: Schema.Struct({
@@ -207,7 +207,7 @@ export const events = {
       postId: Schema.String,
     }),
   }),
-  
+
   // Local UI state
   feedStateUpdated: tables.feedState.set,
 }
@@ -219,85 +219,85 @@ const materializers = State.SQLite.materializers(events, {
     tables.users.insert({ id, username, email, displayName, createdAt }),
     tables.userStats.insert({ userId: id, lastUpdated: createdAt }),
   ],
-  
+
   'v1.UserProfileUpdated': ({ id, displayName, bio, avatarUrl }) =>
     tables.users.update({ displayName, bio, avatarUrl }).where({ id }),
-    
+
   'v1.UserPrivacySettingsChanged': ({ id, isPrivate, allowsFollowers }) =>
     tables.users.update({ isPrivate, allowsFollowers }).where({ id }),
-    
+
   'v1.UserLastActiveUpdated': ({ id, lastActiveAt }) =>
     tables.users.update({ lastActiveAt }).where({ id }),
-    
+
   // Post materializers
   'v1.PostCreated': ({ id, authorId, content, mediaUrls, replyToId, visibility, createdAt }) => [
-    tables.posts.insert({ 
-      id, 
-      authorId, 
-      content, 
+    tables.posts.insert({
+      id,
+      authorId,
+      content,
       mediaUrls: mediaUrls ? JSON.stringify(mediaUrls) : null,
-      replyToId, 
-      visibility, 
-      createdAt 
+      replyToId,
+      visibility,
+      createdAt
     }),
     tables.postStats.insert({ postId: id, lastUpdated: createdAt }),
     // Update user post count
-    tables.userStats.update({ 
+    tables.userStats.update({
       postCount: tables.userStats.select('postCount').where({ userId: authorId }).scalar() + 1,
       lastUpdated: createdAt
     }).where({ userId: authorId }),
   ],
-  
+
   'v1.PostEdited': ({ id, content, editedAt }) =>
     tables.posts.update({ content, editedAt }).where({ id }),
-    
+
   'v1.PostDeleted': ({ id, deletedAt }) =>
     tables.posts.update({ deletedAt }).where({ id }),
-    
+
   // Follow materializers
   'v1.FollowRequested': ({ followerId, followingId, createdAt }) =>
     tables.follows.insert({ followerId, followingId, status: 'pending', createdAt }),
-    
+
   'v1.FollowApproved': ({ followerId, followingId, approvedAt }) => [
     tables.follows.update({ status: 'active', approvedAt }).where({ followerId, followingId }),
     // Update follower counts
-    tables.userStats.update({ 
+    tables.userStats.update({
       followerCount: tables.userStats.select('followerCount').where({ userId: followingId }).scalar() + 1,
       lastUpdated: approvedAt
     }).where({ userId: followingId }),
-    tables.userStats.update({ 
+    tables.userStats.update({
       followingCount: tables.userStats.select('followingCount').where({ userId: followerId }).scalar() + 1,
       lastUpdated: approvedAt
     }).where({ userId: followerId }),
   ],
-  
+
   'v1.Unfollowed': ({ followerId, followingId }) => [
     tables.follows.delete().where({ followerId, followingId }),
     // Update follower counts (eventual consistency)
-    tables.userStats.update({ 
+    tables.userStats.update({
       followerCount: Math.max(0, tables.userStats.select('followerCount').where({ userId: followingId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ userId: followingId }),
-    tables.userStats.update({ 
+    tables.userStats.update({
       followingCount: Math.max(0, tables.userStats.select('followingCount').where({ userId: followerId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ userId: followerId }),
   ],
-  
+
   // Like materializers (idempotent)
   'v1.PostLiked': ({ userId, postId, createdAt }) => [
     tables.likes.insert({ userId, postId, createdAt }),
     // Update like count
-    tables.postStats.update({ 
+    tables.postStats.update({
       likeCount: tables.postStats.select('likeCount').where({ postId }).scalar() + 1,
       lastUpdated: createdAt
     }).where({ postId }),
   ],
-  
+
   'v1.PostUnliked': ({ userId, postId }) => [
     tables.likes.delete().where({ userId, postId }),
     // Update like count
-    tables.postStats.update({ 
+    tables.postStats.update({
       likeCount: Math.max(0, tables.postStats.select('likeCount').where({ postId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ postId }),
@@ -317,8 +317,8 @@ export const schema = makeSchema({ events, state })
 //     .join(tables.follows, 'authorId', 'followingId')
 //     .join(tables.users, 'authorId', 'id')
 //     .leftJoin(tables.postStats, 'id', 'postId')
-//     .where({ 
-//       followerId: userId, 
+//     .where({
+//       followerId: userId,
 //       'follows.status': 'active',
 //       'posts.deletedAt': null,
 //       'posts.visibility': ['public', 'followers']

package/src/mcp-content/schemas/todo.ts

@@ -34,8 +34,8 @@ export const tables = {
   // Client-only state for UI (not synced)
   uiState: State.SQLite.clientDocument({
     name: 'uiState',
-    schema: Schema.Struct({ 
-      newTodoText: Schema.String, 
+    schema: Schema.Struct({
+      newTodoText: Schema.String,
       filter: Schema.Literal('all', 'active', 'completed'),
       selectedTags: Schema.Array(Schema.String)
     }),
@@ -48,8 +48,8 @@ export const events = {
   // Todo events
   todoCreated: Events.synced({
     name: 'v1.TodoCreated',
-    schema: Schema.Struct({ 
-      id: Schema.String, 
+    schema: Schema.Struct({
+      id: Schema.String,
       title: Schema.String,
       createdAt: Schema.Date,
       position: Schema.Number
@@ -60,7 +60,7 @@ export const events = {
     schema: Schema.Struct({ id: Schema.String }),
   }),
   todoUncompleted: Events.synced({
-    name: 'v1.TodoUncompleted', 
+    name: 'v1.TodoUncompleted',
     schema: Schema.Struct({ id: Schema.String }),
   }),
   todoTitleChanged: Events.synced({
@@ -76,16 +76,16 @@ export const events = {
     schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
   }),
   todosCleared: Events.synced({
-    name: 'v1.TodosCleared', 
+    name: 'v1.TodosCleared',
     schema: Schema.Struct({ deletedAt: Schema.Date }),
   }),
-  
+
   // Tag events
   tagCreated: Events.synced({
     name: 'v1.TagCreated',
-    schema: Schema.Struct({ 
-      id: Schema.String, 
-      name: Schema.String, 
+    schema: Schema.Struct({
+      id: Schema.String,
+      name: Schema.String,
       color: Schema.NullOr(Schema.String),
       createdAt: Schema.Date
     }),
@@ -94,7 +94,7 @@ export const events = {
     name: 'v1.TagDeleted',
     schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
   }),
-  
+
   // Todo-Tag relationship events
   todoTagged: Events.synced({
     name: 'v1.TodoTagged',
@@ -104,7 +104,7 @@ export const events = {
     name: 'v1.TodoUntagged',
     schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String }),
   }),
-  
+
   // UI state events (local only)
   uiStateSet: tables.uiState.set,
 }
@@ -112,39 +112,39 @@ export const events = {
 // Materializers - Map events to state changes with conflict-free semantics
 const materializers = State.SQLite.materializers(events, {
   // Todo materializers
-  'v1.TodoCreated': ({ id, title, createdAt, position }) => 
+  'v1.TodoCreated': ({ id, title, createdAt, position }) =>
     tables.todos.insert({ id, title, completed: false, createdAt, position }),
-    
-  'v1.TodoCompleted': ({ id }) => 
+
+  'v1.TodoCompleted': ({ id }) =>
     tables.todos.update({ completed: true }).where({ id }),
-    
-  'v1.TodoUncompleted': ({ id }) => 
+
+  'v1.TodoUncompleted': ({ id }) =>
     tables.todos.update({ completed: false }).where({ id }),
-    
-  'v1.TodoTitleChanged': ({ id, title }) => 
+
+  'v1.TodoTitleChanged': ({ id, title }) =>
     tables.todos.update({ title }).where({ id }),
-    
-  'v1.TodoReordered': ({ id, position }) => 
+
+  'v1.TodoReordered': ({ id, position }) =>
     tables.todos.update({ position }).where({ id }),
-    
-  'v1.TodoDeleted': ({ id, deletedAt }) => 
+
+  'v1.TodoDeleted': ({ id, deletedAt }) =>
     tables.todos.update({ deletedAt }).where({ id }),
-    
-  'v1.TodosCleared': ({ deletedAt }) => 
+
+  'v1.TodosCleared': ({ deletedAt }) =>
     tables.todos.update({ deletedAt }).where({ completed: true, deletedAt: null }),
-    
-  // Tag materializers  
-  'v1.TagCreated': ({ id, name, color, createdAt }) => 
+
+  // Tag materializers
+  'v1.TagCreated': ({ id, name, color, createdAt }) =>
     tables.tags.insert({ id, name, color, createdAt }),
-    
-  'v1.TagDeleted': ({ id, deletedAt }) => 
+
+  'v1.TagDeleted': ({ id, deletedAt }) =>
     tables.tags.update({ deletedAt }).where({ id }),
-    
+
   // Todo-Tag relationship materializers
-  'v1.TodoTagged': ({ todoId, tagId, createdAt }) => 
+  'v1.TodoTagged': ({ todoId, tagId, createdAt }) =>
     tables.todoTags.insert({ todoId, tagId, createdAt }),
-    
-  'v1.TodoUntagged': ({ todoId, tagId }) => 
+
+  'v1.TodoUntagged': ({ todoId, tagId }) =>
     tables.todoTags.delete().where({ todoId, tagId }),
 })
 
@@ -153,7 +153,7 @@ const state = State.SQLite.makeState({ tables, materializers })
 export const schema = makeSchema({ events, state })
 
 // Example usage:
-// 
+//
 // import { queryDb, dispatchEvent } from '@livestore/livestore'
 // import { schema, events, tables } from './schema.js'
 //

package/src/mcp-runtime/runtime.ts

@@ -0,0 +1,147 @@
+import { makeAdapter as makeNodeAdapter } from '@livestore/adapter-node'
+import { UnknownError } from '@livestore/common'
+import { LiveStoreEvent, SystemTables } from '@livestore/common/schema'
+import type { Store } from '@livestore/livestore'
+import { createStorePromise } from '@livestore/livestore'
+import { Effect, FetchHttpClient, Layer, Option, Schema } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+
+import { loadModuleConfig } from '../module-loader.ts'
+
+/** Currently connected store */
+let store: Store<any> | undefined
+
+/** Layer providing FileSystem and HttpClient for module loading */
+const ModuleLoaderLayer = Layer.mergeAll(PlatformNode.NodeFileSystem.layer, FetchHttpClient.layer)
+
+/**
+ * Dynamically imports a module that exports a `makeStore({ storeId }): Promise<Store>` function,
+ * calls it with the provided storeId, and caches the Store instance for subsequent tool calls.
+ */
+export const init = ({
+  configPath,
+  storeId,
+  clientId,
+  sessionId,
+}: {
+  configPath: string
+  storeId: string
+  clientId?: string
+  sessionId?: string
+}): Effect.Effect<Store<any>, UnknownError> =>
+  Effect.gen(function* () {
+    if (storeId === '' || typeof storeId !== 'string') {
+      return yield* UnknownError.make({ cause: new Error('Invalid storeId: expected a non-empty string') })
+    }
+
+    const { schema, syncBackendConstructor, syncPayloadSchema, syncPayload } = yield* loadModuleConfig({ configPath })
+
+    // Build Node adapter internally
+    const adapter = makeNodeAdapter({
+      storage: { type: 'in-memory' },
+      ...(clientId !== undefined && clientId !== '' ? { clientId } : {}),
+      ...(sessionId !== undefined && sessionId !== '' ? { sessionId } : {}),
+      sync: {
+        backend: syncBackendConstructor,
+        initialSyncOptions: { _tag: 'Blocking', timeout: 5000 },
+        onSyncError: 'shutdown',
+      },
+    })
+
+    // Create the store
+    const s = yield* Effect.promise(() =>
+      createStorePromise({
+        schema,
+        storeId,
+        adapter,
+        disableDevtools: true,
+        ...(syncPayload !== undefined ? { syncPayload } : {}),
+        syncPayloadSchema,
+      }),
+    )
+
+    // Replace existing store if any
+    if (store !== undefined) {
+      yield* Effect.promise(async () => {
+        try {
+          await store!.shutdownPromise()
+        } catch {}
+      })
+    }
+
+    store = s
+    return store
+  }).pipe(Effect.provide(ModuleLoaderLayer), Effect.withSpan('mcp-runtime:init'))
+
+export const getStore = Effect.sync(() => Option.fromNullishOr(store))
+
+export const status = Effect.gen(function* () {
+  const opt = yield* getStore
+  if (opt._tag === 'None') {
+    return {
+      _tag: 'disconnected' as const,
+    }
+  }
+  const s = opt.value
+  const tableCounts = Array.from(s.schema.state.sqlite.tables.keys())
+    .filter((name) => !SystemTables.isStateSystemTable(name))
+    .reduce(
+      (acc, name) => {
+        acc[name] = s.query(s.schema.state.sqlite.tables.get(name)!.count())
+        return acc
+      },
+      {} as Record<string, number>,
+    )
+
+  return {
+    _tag: 'connected' as const,
+    storeId: s.storeId,
+    clientId: s.clientId,
+    sessionId: s.sessionId,
+    tableCounts,
+  }
+}).pipe(Effect.withSpan('mcp-runtime:status'))
+
+export const query = Effect.fn('mcp-runtime:query')(function* ({
+  sql,
+  bindValues,
+}: {
+  sql: string
+  bindValues?: readonly any[] | Record<string, unknown>
+}) {
+  const opt = yield* getStore
+  if (opt._tag === 'None') {
+    return yield* Effect.die(new Error('LiveStore not connected. Call livestore_instance_connect first.'))
+  }
+  const s = opt.value
+
+  const rows = s.query<Array<Record<string, unknown>>>({ query: sql, bindValues: (bindValues as any) ?? [] })
+  const jsonRows = rows.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v as Schema.Json])))
+  return { rows: jsonRows, rowCount: jsonRows.length }
+})
+
+export const commit = Effect.fn('mcp-runtime:commit')(function* ({
+  events,
+}: {
+  events: ReadonlyArray<{ name: string; args: Schema.Json }>
+}) {
+  const opt = yield* getStore
+  if (opt._tag === 'None') {
+    return yield* Effect.die(new Error('LiveStore not connected. Call livestore_instance_connect first.'))
+  }
+  const s = opt.value
+  const InputEventSchema = LiveStoreEvent.Input.makeSchema(s.schema) as Schema.Codec<any>
+  const decoded = events.map((e) => Schema.decodeSync(InputEventSchema)(e))
+  s.commit(...decoded)
+  return { committed: decoded.length }
+})
+
+export const disconnect = Effect.promise(async () => {
+  if (store !== undefined) {
+    try {
+      await store.shutdownPromise()
+    } catch {}
+    store = undefined
+  }
+  return { _tag: 'disconnected' as const }
+}).pipe(Effect.withSpan('mcp-runtime:disconnect'))

package/src/module-loader.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared module loading utility for CLI and MCP.
+ * Loads and validates user config modules that export schema, syncBackend, and optional syncPayload.
+ */
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import type { SyncBackend } from '@livestore/common'
+import { UnknownError } from '@livestore/common'
+import { isLiveStoreSchema, type LiveStoreSchema } from '@livestore/common/schema'
+import { shouldNeverHappen } from '@livestore/utils'
+import { Effect, FileSystem, Schema } from '@livestore/utils/effect'
+
+export interface ModuleConfig {
+  schema: LiveStoreSchema
+  syncBackendConstructor: SyncBackend.SyncBackendConstructor
+  syncPayloadSchema: Schema.Codec<Schema.Json, Schema.Json>
+  syncPayload: Schema.Json | undefined
+}
+
+/**
+ * Loads and validates a user config module.
+ * The module must export:
+ * - `schema`: A valid LiveStore schema
+ * - `syncBackend`: A sync backend constructor function
+ * - `syncPayloadSchema` (optional): Schema for validating syncPayload
+ * - `syncPayload` (optional): Payload data for the sync backend
+ */
+export const loadModuleConfig = ({
+  configPath,
+}: {
+  configPath: string
+}): Effect.Effect<ModuleConfig, UnknownError, FileSystem.FileSystem> =>
+  Effect.gen(function* () {
+    const abs = path.isAbsolute(configPath) === true ? configPath : path.resolve(process.cwd(), configPath)
+
+    const fs = yield* FileSystem.FileSystem
+    const exists = yield* fs.exists(abs).pipe(UnknownError.mapToUnknownError)
+    if (exists === false) {
+      return yield* 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?.schema
+    if (isLiveStoreSchema(schema) === false) {
+      return yield* UnknownError.make({
+        cause: `Module at ${abs} must export a valid LiveStore 'schema'`,
+        note: `Ex: export { schema } from './src/livestore/schema.ts'`,
+      })
+    }
+
+    const syncBackendConstructor = mod?.syncBackend
+    if (typeof syncBackendConstructor !== 'function') {
+      return yield* UnknownError.make({
+        cause: `Module at ${abs} must export a 'syncBackend' constructor`,
+        note: `Ex: export const syncBackend = makeWsSync({ url })`,
+      })
+    }
+
+    const syncPayloadSchemaExport = mod?.syncPayloadSchema
+    const syncPayloadSchema =
+      syncPayloadSchemaExport === undefined
+        ? Schema.Json
+        : Schema.isSchema(syncPayloadSchemaExport) === true
+          ? (syncPayloadSchemaExport as Schema.Codec<Schema.Json, Schema.Json>)
+          : shouldNeverHappen(
+              `Exported 'syncPayloadSchema' from ${abs} must be an Effect Schema (received ${typeof syncPayloadSchemaExport}).`,
+            )
+
+    const syncPayloadExport = mod?.syncPayload
+    const syncPayload = yield* (
+      syncPayloadExport === undefined
+        ? Effect.succeed<Schema.Json | undefined>(undefined)
+        : Schema.decodeUnknownEffect(syncPayloadSchema)(syncPayloadExport)
+    ).pipe(UnknownError.mapToUnknownError)
+
+    return {
+      schema,
+      syncBackendConstructor,
+      syncPayloadSchema,
+      syncPayload,
+    }
+  }).pipe(Effect.withSpan('module-loader:loadModuleConfig'))