@livestore/cli 0.4.0 → 0.5.0-dev.0

package/src/commands/import-export.ts

@@ -6,8 +6,8 @@ import { Cli } from '@livestore/utils/node'
 
 import * as SyncOps from '../sync-operations.ts'
 
-const jsonStringifyPretty = Schema.encodeSync(Schema.parseJson({ space: 2 }))
-const jsonParse = Schema.decodeUnknownSync(Schema.parseJson())
+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
 
@@ -171,19 +171,19 @@ const importEvents = ({
 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'),
+    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.Options.text('store-id').pipe(
-      Cli.Options.withAlias('i'),
-      Cli.Options.withDescription('Store identifier'),
+    storeId: Cli.Flag.string('store-id').pipe(
+      Cli.Flag.withAlias('i'),
+      Cli.Flag.withDescription('Store identifier'),
     ),
-    clientId: Cli.Options.text('client-id').pipe(
-      Cli.Options.withDefault('cli-export'),
-      Cli.Options.withDescription('Client identifier for the sync connection'),
+    clientId: Cli.Flag.string('client-id').pipe(
+      Cli.Flag.withDefault('cli-export'),
+      Cli.Flag.withDescription('Client identifier for the sync connection'),
     ),
-    output: Cli.Args.text({ name: 'file' }).pipe(Cli.Args.withDescription('Output JSON file path')),
+    output: Cli.Argument.string('file').pipe(Cli.Argument.withDescription('Output JSON file path')),
   },
   Effect.fn(function* ({
     config,
@@ -218,28 +218,28 @@ export const exportCommand = Cli.Command.make(
 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'),
+    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.Options.text('store-id').pipe(
-      Cli.Options.withAlias('i'),
-      Cli.Options.withDescription('Store identifier'),
+    storeId: Cli.Flag.string('store-id').pipe(
+      Cli.Flag.withAlias('i'),
+      Cli.Flag.withDescription('Store identifier'),
     ),
-    clientId: Cli.Options.text('client-id').pipe(
-      Cli.Options.withDefault('cli-import'),
-      Cli.Options.withDescription('Client identifier for the sync connection'),
+    clientId: Cli.Flag.string('client-id').pipe(
+      Cli.Flag.withDefault('cli-import'),
+      Cli.Flag.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'),
+    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.Options.boolean('dry-run').pipe(
-      Cli.Options.withDefault(false),
-      Cli.Options.withDescription('Validate the import file without actually importing'),
+    dryRun: Cli.Flag.boolean('dry-run').pipe(
+      Cli.Flag.withDefault(false),
+      Cli.Flag.withDescription('Validate the import file without actually importing'),
     ),
-    input: Cli.Args.text({ name: 'file' }).pipe(Cli.Args.withDescription('Input JSON file to import')),
+    input: Cli.Argument.string('file').pipe(Cli.Argument.withDescription('Input JSON file to import')),
   },
   Effect.fn(function* ({
     config,

package/src/commands/mcp-coach.ts

@@ -1,36 +1,36 @@
-import { LanguageModel } from '@effect/ai'
+import { AiError, LanguageModel, Prompt, Tool } from 'effect/unstable/ai'
 import { OpenAiClient, OpenAiLanguageModel } from '@effect/ai-openai'
 
-import { AiError, Config, Effect, FetchHttpClient, Layer, Prompt, Schema, Tool } from '@livestore/utils/effect'
+import { Config, Effect, FetchHttpClient, Layer, Schema } from '@livestore/utils/effect'
 
 // Define the coach tool that analyzes LiveStore usage
 export const coachTool = Tool.make('livestore_coach', {
   description:
     'Analyze LiveStore code (schemas, queries, mutations, etc.) and provide AI-powered feedback on best practices, performance, and improvements.',
-  parameters: {
-    code: Schema.String.annotations({
+  parameters: Schema.Struct({
+    code: Schema.String.annotate({
       description: 'The LiveStore code to analyze (TypeScript/JavaScript)',
     }),
     codeType: Schema.optional(
-      Schema.String.annotations({
+      Schema.String.annotate({
         description: "Type of code being analyzed: 'schema', 'query', 'mutation', 'component', or 'general'",
       }),
     ),
-  },
+  }),
   success: Schema.Struct({
-    feedback: Schema.String.annotations({
+    feedback: Schema.String.annotate({
       description: 'AI-generated feedback and recommendations for the code',
     }),
     score: Schema.optional(
-      Schema.Number.annotations({
+      Schema.Number.annotate({
         description: 'Code quality score from 1-10 (optional)',
       }),
     ),
     suggestions: Schema.Array(
-      Schema.String.annotations({
+      Schema.String.annotate({
         description: 'Specific actionable suggestions for improvement',
       }),
-    ).annotations({
+    ).annotate({
       description: 'List of specific improvement suggestions',
     }),
   }),
@@ -58,7 +58,8 @@ type CoachToolResult = {
 export const coachToolHandler: (input: CoachToolHandlerInput) => Effect.Effect<CoachToolResult, AiError.AiError> =
   Effect.fn('mcp-coach-handler')(({ code, codeType }) => {
     const effect = Effect.gen(function* () {
-      const codeTypeContext = codeType !== undefined ? `This is ${codeType} code using LiveStore. ` : 'This is LiveStore code. '
+      const codeTypeContext =
+        codeType !== undefined ? `This is ${codeType} code using LiveStore. ` : 'This is LiveStore code. '
 
       const prompt = Prompt.makeMessage('user', {
         content: [

package/src/commands/mcp-protocols.test.ts

@@ -0,0 +1,76 @@
+import { spawn } from 'node:child_process'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+
+import { supportedMcpProtocols } from './mcp-protocols.ts'
+
+const protocolVersions = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'] as const
+
+Vitest.describe('supportedMcpProtocols', () => {
+  Vitest.it('keeps the fallback protocol newest-first', () => {
+    Vitest.expect(supportedMcpProtocols.map((protocol) => protocol.protocolVersion)).toEqual(protocolVersions)
+  })
+
+  Vitest.it.each(protocolVersions)('negotiates an exact %s stdio initialize offer', async (protocolVersion) => {
+    const response = await initialize(protocolVersion)
+
+    Vitest.expect(response.result?.protocolVersion).toBe(protocolVersion)
+  })
+})
+
+const initialize = (protocolVersion: (typeof protocolVersions)[number]) =>
+  new Promise<InitializeResponse>((resolve, reject) => {
+    const child = spawn('bun', [new URL('./__fixtures__/mcp-protocol-server.ts', import.meta.url).pathname], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGTERM')
+      reject(new Error(`MCP initialize timed out. stdout=${stdout} stderr=${stderr}`))
+    }, 5_000)
+
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk: string) => {
+      stdout += chunk
+      if (stdout.endsWith('\n') === false) return
+
+      try {
+        const response = JSON.parse(stdout.trim()) as InitializeResponse
+        clearTimeout(timeout)
+        child.kill('SIGTERM')
+        resolve(response)
+      } catch (error) {
+        clearTimeout(timeout)
+        child.kill('SIGTERM')
+        reject(error)
+      }
+    })
+    child.stderr.on('data', (chunk: string) => {
+      stderr += chunk
+    })
+    child.on('error', (error) => {
+      clearTimeout(timeout)
+      reject(error)
+    })
+    child.stdin.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion,
+          capabilities: {},
+          clientInfo: { name: 'livestore-mcp-protocol-test', version: '0.0.0' },
+        },
+      })}\n`,
+    )
+  })
+
+interface InitializeResponse {
+  readonly result?: {
+    readonly protocolVersion?: string
+  }
+}

package/src/commands/mcp-protocols.ts

@@ -0,0 +1,12 @@
+import { McpProtocol } from 'effect/unstable/ai'
+
+/**
+ * MCP stdio selects an exact offered version when available and otherwise
+ * falls back to the first adapter, so keep every supported adapter newest-first.
+ */
+export const supportedMcpProtocols = [
+  McpProtocol.v2025_11_25,
+  McpProtocol.v2025_06_18,
+  McpProtocol.v2025_03_26,
+  McpProtocol.v2024_11_05,
+] as const

package/src/commands/mcp-stdio.test.ts

@@ -0,0 +1,93 @@
+import { spawn } from 'node:child_process'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+
+Vitest.describe('mcp server stdio', () => {
+  Vitest.it('reserves stdout for JSON-RPC messages', async () => {
+    const response = await initialize()
+
+    Vitest.expect(response.result?.protocolVersion).toBe('2025-06-18')
+  })
+})
+
+/** Exercises the real CLI entrypoint so root-level warnings and logs cannot corrupt MCP framing. */
+const initialize = () =>
+  new Promise<InitializeResponse>((resolve, reject) => {
+    const child = spawn('bun', [new URL('../bin.ts', import.meta.url).pathname, 'mcp', 'server'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    let stdoutBuffer = ''
+    let stderr = ''
+    let settled = false
+
+    const finish = (result: { readonly response: InitializeResponse } | { readonly error: unknown }) => {
+      if (settled === true) return
+      settled = true
+      clearTimeout(timeout)
+      child.kill('SIGTERM')
+      if ('error' in result) reject(result.error)
+      else resolve(result.response)
+    }
+
+    const timeout = setTimeout(() => {
+      finish({ error: new Error(`MCP initialize timed out. stdout=${stdoutBuffer} stderr=${stderr}`) })
+    }, 5_000)
+
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk: string) => {
+      stdoutBuffer += chunk
+      const lines = stdoutBuffer.split('\n')
+      stdoutBuffer = lines.pop() ?? ''
+
+      for (const line of lines) {
+        if (line.length === 0) continue
+
+        try {
+          const message = JSON.parse(line) as InitializeResponse
+          if (message.jsonrpc !== '2.0') {
+            finish({ error: new Error(`MCP stdout contained a non-JSON-RPC message: ${line}`) })
+            return
+          }
+          if (message.id === 1) {
+            finish({ response: message })
+            return
+          }
+        } catch (error) {
+          finish({ error: new Error(`MCP stdout contained invalid JSON: ${line}`, { cause: error }) })
+          return
+        }
+      }
+    })
+    child.stderr.on('data', (chunk: string) => {
+      stderr += chunk
+    })
+    child.on('error', (error) => {
+      finish({ error })
+    })
+    child.on('exit', (code) => {
+      if (settled === false) {
+        finish({ error: new Error(`MCP server exited before initialize completed (code ${code}). stderr=${stderr}`) })
+      }
+    })
+    child.stdin.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2025-06-18',
+          capabilities: {},
+          clientInfo: { name: 'livestore-mcp-stdio-test', version: '0.0.0' },
+        },
+      })}\n`,
+    )
+  })
+
+interface InitializeResponse {
+  readonly jsonrpc?: unknown
+  readonly id?: unknown
+  readonly result?: {
+    readonly protocolVersion?: string
+  }
+}

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

@@ -1,4 +1,6 @@
-import { Effect, FetchHttpClient, Layer, type Toolkit } from '@livestore/utils/effect'
+import { type Toolkit } from 'effect/unstable/ai'
+
+import { Effect, FetchHttpClient, Layer } from '@livestore/utils/effect'
 import { PlatformNode } from '@livestore/utils/node'
 
 import { blogSchemaContent } from '../mcp-content/schemas/blog.ts'
@@ -59,13 +61,14 @@ export const schema = Schema.create({
         }
 
         // Generate a basic custom schema based on description
-        const tableName = customDescription.toLowerCase().includes('user') === true
-          ? 'users'
-          : customDescription.toLowerCase().includes('product') === true
-            ? 'products'
-            : customDescription.toLowerCase().includes('post') === true
-              ? 'posts'
-              : 'items'
+        const tableName =
+          customDescription.toLowerCase().includes('user') === true
+            ? 'users'
+            : customDescription.toLowerCase().includes('product') === true
+              ? 'products'
+              : customDescription.toLowerCase().includes('post') === true
+                ? 'posts'
+                : 'items'
 
         schemaCode = `// Custom schema based on: ${customDescription}
 import { Schema } from '@livestore/livestore'

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

@@ -0,0 +1,13 @@
+import { Tool } from 'effect/unstable/ai'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+
+import { livestoreToolkit } from './mcp-tools-defs.ts'
+
+Vitest.describe('livestoreToolkit', () => {
+  Vitest.it('exposes MCP-compatible object parameter schemas', () => {
+    for (const tool of Object.values(livestoreToolkit.tools)) {
+      Vitest.expect(Tool.getJsonSchema(tool), tool.name).toMatchObject({ type: 'object' })
+    }
+  })
+})

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

@@ -1,4 +1,6 @@
-import { Schema, Tool, Toolkit } from '@livestore/utils/effect'
+import { Tool, Toolkit } from 'effect/unstable/ai'
+
+import { Schema } from '@livestore/utils/effect'
 
 import { coachTool } from './mcp-coach.ts'
 
@@ -8,32 +10,32 @@ export const livestoreToolkit = Toolkit.make(
   Tool.make('livestore_generate_schema', {
     description:
       'Generate a LiveStore schema for a specific use case. Choose from predefined types (todo, blog, social, ecommerce) or request a custom schema by providing a description.',
-    parameters: {
-      schemaType: Schema.String.annotations({
+    parameters: Schema.Struct({
+      schemaType: Schema.String.annotate({
         description: "Schema type: 'todo', 'blog', 'social', 'ecommerce', or 'custom'",
       }),
       customDescription: Schema.optional(
-        Schema.String.annotations({
+        Schema.String.annotate({
           description:
             "For custom schemas: describe your data model needs (e.g., 'user management system with roles and permissions')",
         }),
       ),
-    },
+    }),
     success: Schema.Struct({
-      schemaCode: Schema.String.annotations({ description: 'The generated LiveStore schema TypeScript code' }),
-      explanation: Schema.String.annotations({ description: 'Brief explanation of the schema structure' }),
+      schemaCode: Schema.String.annotate({ description: 'The generated LiveStore schema TypeScript code' }),
+      explanation: Schema.String.annotate({ description: 'Brief explanation of the schema structure' }),
     }),
   }),
 
   Tool.make('livestore_get_example_schema', {
     description:
       'Get a complete example LiveStore schema with TypeScript code. Returns ready-to-use schema definitions for common application types.',
-    parameters: {
-      type: Schema.String.annotations({ description: "Example type: 'todo', 'blog', 'social', or 'ecommerce'" }),
-    },
+    parameters: Schema.Struct({
+      type: Schema.String.annotate({ description: "Example type: 'todo', 'blog', 'social', or 'ecommerce'" }),
+    }),
     success: Schema.Struct({
-      schemaCode: Schema.String.annotations({ description: 'The complete LiveStore schema code' }),
-      description: Schema.String.annotations({ description: 'Description of what this schema models' }),
+      schemaCode: Schema.String.annotate({ description: 'The complete LiveStore schema code' }),
+      description: Schema.String.annotate({ description: 'Description of what this schema models' }),
     }),
   })
     .annotate(Tool.Readonly, true)
@@ -86,27 +88,27 @@ Returns on success:
     "eventNames": ["<event-name-1>", "<event-name-2>", "..."]
   }
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         description: 'Path to a module that exports named variables: schema and syncBackend',
       }),
-      storeId: Schema.String.annotations({ description: 'Required store id for the LiveStore instance.' }),
+      storeId: Schema.String.annotate({ description: 'Required store id for the LiveStore instance.' }),
       clientId: Schema.optional(
-        Schema.String.annotations({ description: 'Optional client id for the LiveStore instance.' }),
+        Schema.String.annotate({ description: 'Optional client id for the LiveStore instance.' }),
       ),
       sessionId: Schema.optional(
-        Schema.String.annotations({ description: 'Optional session id for the LiveStore instance.' }),
+        Schema.String.annotate({ description: 'Optional session id for the LiveStore instance.' }),
       ),
-    },
+    }),
     success: Schema.Struct({
       storeId: Schema.String,
       clientId: Schema.String,
       sessionId: Schema.String,
       schemaInfo: Schema.Struct({
-        tableNames: Schema.Array(Schema.String).annotations({
+        tableNames: Schema.Array(Schema.String).annotate({
           description: 'Non-system table names in the connected schema',
         }),
-        eventNames: Schema.Array(Schema.String).annotations({
+        eventNames: Schema.Array(Schema.String).annotate({
           description: 'Canonical event names defined by the connected schema',
         }),
       }),
@@ -137,17 +139,17 @@ Returns on success:
   "rows": [{ "col": "value" }],
   "rowCount": 1
 }`,
-    parameters: {
-      sql: Schema.String.annotations({ description: 'The SQL query to execute' }),
-      bindValues: Schema.Union(
-        Schema.Array(Schema.JsonValue),
-        Schema.Record({ key: Schema.String, value: Schema.JsonValue }),
-      ).annotations({
+    parameters: Schema.Struct({
+      sql: Schema.String.annotate({ description: 'The SQL query to execute' }),
+      bindValues: Schema.Union([
+        Schema.Array(Schema.Json),
+        Schema.Record(Schema.String, Schema.Json),
+      ]).annotate({
         description: 'Bind values for the SQL query (array or record). Record keys must not start with $.',
       }),
-    },
+    }),
     success: Schema.Struct({
-      rows: Schema.Array(Schema.Record({ key: Schema.String, value: Schema.JsonValue })),
+      rows: Schema.Array(Schema.Record(Schema.String, Schema.Json)),
       rowCount: Schema.Number,
     }),
   }).annotate(Tool.Destructive, false),
@@ -176,16 +178,16 @@ Example parameters:
 
 Returns on success:
 { "committed": 1 }`,
-    parameters: {
+    parameters: Schema.Struct({
       events: Schema.Array(
         Schema.Struct({
-          name: Schema.String.annotations({ description: 'The name of the event' }),
-          args: Schema.JsonValue.annotations({
+          name: Schema.String.annotate({ description: 'The name of the event' }),
+          args: Schema.Json.annotate({
             description: 'The arguments for the event as a non-stringified JSON value',
           }),
         }),
       ),
-    },
+    }),
     success: Schema.Struct({ committed: Schema.Number }),
   }).annotate(Tool.Destructive, true),
 
@@ -205,18 +207,18 @@ Returns when not connected:
 {
   "_tag": "disconnected"
 }`,
-    parameters: {},
-    success: Schema.Union(
+    parameters: Tool.EmptyParams,
+    success: Schema.Union([
       Schema.TaggedStruct('connected', {
         storeId: Schema.String,
         clientId: Schema.String,
         sessionId: Schema.String,
-        tableCounts: Schema.Record({ key: Schema.String, value: Schema.Number }).annotations({
+        tableCounts: Schema.Record(Schema.String, Schema.Number).annotate({
           description: 'Tables in the LiveStore instance with their row count',
         }),
       }),
       Schema.TaggedStruct('disconnected', {}),
-    ),
+    ]),
   }).annotate(Tool.Readonly, true),
 
   Tool.make('livestore_instance_disconnect', {
@@ -224,7 +226,7 @@ Returns when not connected:
 
 Example success:
 { "_tag": "disconnected" }`,
-    parameters: {},
+    parameters: Tool.EmptyParams,
     success: Schema.TaggedStruct('disconnected', {}),
   }),
 
@@ -253,18 +255,18 @@ Returns on success:
   "exportedAt": "2024-01-15T10:30:00.000Z",
   "data": { "version": 1, "storeId": "my-store", ... }
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         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)' })),
-    },
+      storeId: Schema.String.annotate({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotate({ 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)' }),
+      data: Schema.Json.annotate({ description: 'The export file data (can be saved or passed to import)' }),
     }),
   }).annotate(Tool.Readonly, true),
 
@@ -295,20 +297,20 @@ Returns on success:
   "eventCount": 127,
   "dryRun": false
 }`,
-    parameters: {
-      configPath: Schema.String.annotations({
+    parameters: Schema.Struct({
+      configPath: Schema.String.annotate({
         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({
+      storeId: Schema.String.annotate({ description: 'Store identifier' }),
+      clientId: Schema.optional(Schema.String.annotate({ description: 'Client identifier (default: mcp-import)' })),
+      data: Schema.Json.annotate({
         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' }),
+        Schema.Boolean.annotate({ description: 'Force import even if store ID does not match' }),
       ),
-      dryRun: Schema.optional(Schema.Boolean.annotations({ description: 'Validate without actually importing' })),
-    },
+      dryRun: Schema.optional(Schema.Boolean.annotate({ description: 'Validate without actually importing' })),
+    }),
     success: Schema.Struct({
       storeId: Schema.String,
       eventCount: Schema.Number,

package/src/commands/mcp.ts

@@ -1,4 +1,6 @@
-import { Effect, Layer, Logger, McpServer } from '@livestore/utils/effect'
+import { McpServer } from 'effect/unstable/ai'
+
+import { Effect, Layer, Logger } from '@livestore/utils/effect'
 import { Cli, PlatformNode } from '@livestore/utils/node'
 
 import { architectureContent } from '../mcp-content/architecture.ts'
@@ -11,6 +13,7 @@ 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 { toolHandlers } from './mcp-tool-handlers.ts'
+import { supportedMcpProtocols } from './mcp-protocols.ts'
 // Tools imports
 import { livestoreToolkit } from './mcp-tools-defs.ts'
 
@@ -84,12 +87,12 @@ const mcpServerCommand = Cli.Command.make(
     return yield* McpServer.layerStdio({
       name: 'livestore-mcp',
       version: '0.1.0',
-      stdin: PlatformNode.NodeStream.stdin,
-      stdout: PlatformNode.NodeSink.stdout,
+      protocols: supportedMcpProtocols,
     }).pipe(
       Layer.provide(LivestoreResources),
       Layer.provide(LivestoreTools),
-      Layer.provide(Logger.add(Logger.prettyLogger({ stderr: true }))),
+      Layer.provide(Logger.layer([Logger.consolePretty({ stderr: true })])),
+      Layer.provide(PlatformNode.NodeStdio.layer),
       Layer.launch,
     )
   }),