livetap 0.1.5 → 0.2.1

package/src/cli/status.ts

@@ -2,11 +2,16 @@
  * livetap status — Show daemon, connections, and watchers.
  */
 
-import { isDaemonRunning, daemonJson } from './daemon-client.js'
+import { isDaemonRunning, daemonJson, readPid } from './daemon-client.js'
 
 export async function run(args: string[]) {
   if (!(await isDaemonRunning())) {
-    console.log('livetap is not running. Use "livetap start" to begin.')
+    const pid = readPid()
+    if (pid) {
+      console.log(`livetap daemon is not responding (stale PID ${pid}). Try "livetap start".`)
+    } else {
+      console.log('livetap is not running. Use "livetap start" or "livetap setup" to begin.')
+    }
     return
   }
 
@@ -19,8 +24,7 @@ export async function run(args: string[]) {
   }
 
   const uptime = formatUptime(data.uptime)
-  console.log(`livetap daemon running on :${data.port} (uptime ${uptime})`)
-  console.log(`Redis: localhost:${data.redisPort}\n`)
+  console.log(`livetap daemon running on :${data.port} (uptime ${uptime})\n`)
 
   const conns = data.connections || []
   if (conns.length === 0) {
@@ -34,6 +38,20 @@ export async function run(args: string[]) {
     }
     console.log()
   }
+
+  // Fetch watcher count
+  try {
+    const watchers = await daemonJson('/watchers')
+    if (watchers.length > 0) {
+      const running = watchers.filter((w: any) => w.status === 'running').length
+      console.log(`Watchers (${watchers.length}, ${running} running)`)
+      for (const w of watchers) {
+        const expr = w.conditions?.map((c: any) => `${c.field} ${c.op} ${c.value}`).join(w.match === 'all' ? ' AND ' : ' OR ') ?? ''
+        console.log(`  ${w.id}  ${w.status.padEnd(8)} ${expr.slice(0, 50)}`)
+      }
+      console.log()
+    }
+  } catch { /* no watchers endpoint or error */ }
 }
 
 function formatUptime(seconds: number): string {

package/src/cli/stop.ts

@@ -2,45 +2,32 @@
  * livetap stop — Stop the daemon.
  */
 
-import { resolve } from 'path'
-import { homedir } from 'os'
-import { existsSync, readFileSync, unlinkSync } from 'fs'
-import { isDaemonRunning, getDaemonUrl } from './daemon-client.js'
-
-const STATE_PATH = resolve(homedir(), '.livetap', 'state.json')
+import { isDaemonRunning, readPid, isPidAlive, cleanPidFile, getDaemonPort } from './daemon-client.js'
 
 export async function run(_args: string[]) {
-  if (!(await isDaemonRunning())) {
-    // Try reading PID from state file
-    if (existsSync(STATE_PATH)) {
-      try {
-        const state = JSON.parse(readFileSync(STATE_PATH, 'utf-8'))
-        try { process.kill(state.pid, 'SIGTERM') } catch { /* already dead */ }
-        unlinkSync(STATE_PATH)
-        console.log('livetap daemon stopped (cleaned up stale state)')
-      } catch {
-        unlinkSync(STATE_PATH)
-      }
-    } else {
-      console.log('livetap is not running.')
-    }
+  const pid = readPid()
+  const running = await isDaemonRunning()
+
+  if (!running && !pid) {
+    console.log('livetap is not running.')
     return
   }
 
-  // Read state for PID
-  let pid: number | undefined
-  if (existsSync(STATE_PATH)) {
-    try {
-      const state = JSON.parse(readFileSync(STATE_PATH, 'utf-8'))
-      pid = state.pid
-    } catch { /* malformed */ }
+  if (!running && pid) {
+    // PID file exists but daemon isn't responding
+    if (isPidAlive(pid)) {
+      // Process exists but not responding on port — might be something else
+      console.log(`Warning: PID ${pid} exists but daemon is not responding on :${getDaemonPort()}`)
+      try { process.kill(pid, 'SIGTERM') } catch { /* ok */ }
+    }
+    cleanPidFile()
+    console.log('livetap daemon stopped (cleaned up stale state)')
+    return
   }
 
-  // Send SIGTERM
+  // Daemon is running — send SIGTERM via PID or wait for port to close
   if (pid) {
-    try {
-      process.kill(pid, 'SIGTERM')
-    } catch { /* already gone */ }
+    try { process.kill(pid, 'SIGTERM') } catch { /* already gone */ }
   }
 
   // Wait for shutdown
@@ -55,10 +42,6 @@ export async function run(_args: string[]) {
     if (pid) try { process.kill(pid, 'SIGKILL') } catch { /* ok */ }
   }
 
-  // Clean up state
-  if (existsSync(STATE_PATH)) {
-    try { unlinkSync(STATE_PATH) } catch { /* ok */ }
-  }
-
+  cleanPidFile()
   console.log('livetap daemon stopped')
 }

package/src/mcp/channel.ts

@@ -10,15 +10,18 @@
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { readFileSync } from 'fs'
 import { registerTools } from './tools.js'
 import { generateInstructions } from '../shared/catalog-generators.js'
 
+const PKG = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url).pathname, 'utf-8'))
+
 const DAEMON_PORT = parseInt(process.env.LIVETAP_PORT || '8788')
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`
 
 const INSTRUCTIONS = generateInstructions()
 
-async function waitForDaemon(maxWaitMs = 10_000): Promise<boolean> {
+async function waitForDaemon(maxWaitMs = 30_000): Promise<boolean> {
   const deadline = Date.now() + maxWaitMs
   while (Date.now() < deadline) {
     try {
@@ -37,13 +40,15 @@ async function autoStartDaemon(): Promise<boolean> {
     if (res.ok) return true
   } catch { /* not running */ }
 
-  // Auto-start the daemon
+  // Auto-start via CLI (single code path — resolves paths correctly from any CWD)
+  const startScript = new URL('../../bin/livetap.ts', import.meta.url).pathname
   console.error('[livetap-mcp] Daemon not running, auto-starting...')
-  Bun.spawn(['bun', 'src/server/index.ts'], {
+  const proc = Bun.spawn(['bun', startScript, 'start'], {
     env: { ...process.env, LIVETAP_PORT: String(DAEMON_PORT) },
     stdout: 'ignore',
     stderr: 'ignore',
   })
+  proc.unref()
 
   return waitForDaemon()
 }
@@ -51,7 +56,11 @@ async function autoStartDaemon(): Promise<boolean> {
 async function connectToSSE(mcp: Server) {
   try {
     const res = await fetch(`${DAEMON_URL}/events`)
-    if (!res.ok || !res.body) return
+    if (!res.ok || !res.body) {
+      // Daemon not ready — retry
+      setTimeout(() => connectToSSE(mcp), 5000)
+      return
+    }
 
     const reader = res.body.getReader()
     const decoder = new TextDecoder()
@@ -85,9 +94,10 @@ async function connectToSSE(mcp: Server) {
         }
       }
     }
+    // Clean disconnect (daemon died or restarted) — retry
+    setTimeout(() => connectToSSE(mcp), 5000)
   } catch {
-    // SSE connection failed — daemon may not support /events yet (Phase 3)
-    // Silently retry after delay
+    // SSE connection error — retry after delay
     setTimeout(() => connectToSSE(mcp), 5000)
   }
 }
@@ -95,11 +105,11 @@ async function connectToSSE(mcp: Server) {
 async function main() {
   const daemonReady = await autoStartDaemon()
   if (!daemonReady) {
-    console.error('[livetap-mcp] WARNING: Could not connect to daemon. Tools may fail.')
+    console.error('[livetap-mcp] WARNING: Could not connect to daemon. Tools will auto-retry on first call.')
   }
 
   const mcp = new Server(
-    { name: 'LiveTap', version: '0.1.4' },
+    { name: 'LiveTap', version: PKG.version },
     {
       capabilities: {
         experimental: { 'claude/channel': {} },
@@ -118,4 +128,12 @@ async function main() {
   connectToSSE(mcp)
 }
 
+// Prevent unhandled errors from crashing the proxy process
+process.on('unhandledRejection', (err) => {
+  console.error('[livetap-mcp] unhandled rejection:', err)
+})
+process.on('uncaughtException', (err) => {
+  console.error('[livetap-mcp] uncaught exception:', err)
+})
+
 main()

package/src/mcp/tools.ts

@@ -3,173 +3,14 @@
  * Registers tools on an MCP Server that proxy to the daemon HTTP API.
  */
 
-import { z } from 'zod'
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
 
-export const TOOLS = [
-  {
-    name: 'create_connection',
-    description: 'Create a data connection. MQTT: connects to a broker and subscribes to topics. WebSocket: connects to a remote WS URL. Webhook: creates an HTTP ingest endpoint.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        type: { type: 'string', enum: ['mqtt', 'webhook', 'websocket', 'file'], description: 'Source type', default: 'mqtt' },
-        name: { type: 'string', description: 'Display name for the connection' },
-        broker: { type: 'string', description: 'MQTT broker hostname (required for mqtt)' },
-        port: { type: 'number', description: 'Broker port (default 1883 for mqtt)', default: 1883 },
-        tls: { type: 'boolean', description: 'Use TLS (default false)', default: false },
-        username: { type: 'string', description: 'MQTT username', default: '' },
-        password: { type: 'string', description: 'MQTT password', default: '' },
-        topics: { type: 'array', items: { type: 'string' }, description: 'MQTT topic filters (required for mqtt)' },
-        url: { type: 'string', description: 'WebSocket URL (required for websocket)' },
-        headers: { type: 'object', description: 'WebSocket auth headers' },
-        handshake: { type: 'string', description: 'Message to send after WS connect (e.g. subscription JSON)' },
-        path: { type: 'string', description: 'Absolute file path to tail (required for file type, e.g. "/var/log/app.log")' },
-      },
-    },
-  },
-  {
-    name: 'list_connections',
-    description: 'List all active connections with their status, message rate, and buffered count.',
-    inputSchema: { type: 'object' as const, properties: {} },
-  },
-  {
-    name: 'get_connection',
-    description: 'Get detailed status of a specific connection.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        connectionId: { type: 'string', description: 'The connection ID (e.g. "conn_a1b2c3d4")' },
-      },
-      required: ['connectionId'],
-    },
-  },
-  {
-    name: 'destroy_connection',
-    description: 'Destroy a connection — stops the source subscriber, cleans up the Redis stream.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        connectionId: { type: 'string', description: 'The connection ID to destroy' },
-      },
-      required: ['connectionId'],
-    },
-  },
-  {
-    name: 'read_stream',
-    description: "Read recent entries from a connection's live stream. Use this to inspect what data is flowing through a connection and understand the payload structure before creating watchers.",
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        connectionId: { type: 'string', description: 'The connection ID to read from' },
-        backfillSeconds: { type: 'number', description: 'Include entries from the last N seconds (default 60)', default: 60 },
-        maxEntries: { type: 'number', description: 'Max entries to return (default 10)', default: 10 },
-      },
-      required: ['connectionId'],
-    },
-  },
-  {
-    name: 'create_watcher',
-    description: 'Create an expression-based watcher on a connection. The watcher evaluates structured conditions against each stream entry and fires an alert when conditions match. ALWAYS use read_stream first to understand the data shape and field paths.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        connectionId: { type: 'string', description: 'The connection ID to watch' },
-        conditions: {
-          type: 'array',
-          description: 'Array of conditions: [{field: "dot.path", op: ">", value: 50}]. Supported ops: >, <, >=, <=, ==, !=, contains, matches (regex)',
-          items: {
-            type: 'object',
-            properties: {
-              field: { type: 'string', description: 'Dot-path into the JSON payload (e.g. "sensors.temperature.value")' },
-              op: { type: 'string', enum: ['>', '<', '>=', '<=', '==', '!=', 'contains', 'matches'], description: 'Comparison operator. "matches" takes a regex pattern string.' },
-              value: { description: 'Value to compare against (number, string, or boolean)' },
-            },
-            required: ['field', 'op', 'value'],
-          },
-        },
-        match: { type: 'string', enum: ['all', 'any'], description: 'How to combine conditions: "all" (AND) or "any" (OR). Default: "all"', default: 'all' },
-        action: { description: '"channel_alert" (default), or {webhook: "url"}, or {shell: "command"}', default: 'channel_alert' },
-        cooldown: { type: 'number', description: 'Seconds between repeated alerts. 0 for every match, 60 default. Use 0 for rare events (webhooks), 30-60 for sensors, 300+ for high-frequency streams.', default: 60 },
-      },
-      required: ['connectionId', 'conditions'],
-    },
-  },
-  {
-    name: 'list_watchers',
-    description: 'List watchers. Optionally filter by connectionId. If omitted, lists all watchers.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        connectionId: { type: 'string', description: 'Optional: filter by connection ID' },
-      },
-    },
-  },
-  {
-    name: 'get_watcher',
-    description: 'Get details of a specific watcher including conditions, status, match count, and config.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        watcherId: { type: 'string', description: 'The watcher ID' },
-      },
-      required: ['watcherId'],
-    },
-  },
-  {
-    name: 'get_watcher_logs',
-    description: 'Get evaluation logs from a watcher — shows MATCH, SUPPRESSED, FIELD_NOT_FOUND, and CHECKPOINT events.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        watcherId: { type: 'string', description: 'The watcher ID' },
-        lines: { type: 'number', description: 'Number of log lines to return (default 50)', default: 50 },
-      },
-      required: ['watcherId'],
-    },
-  },
-  {
-    name: 'update_watcher',
-    description: "Update a watcher's conditions, match mode, action, or cooldown. The watcher restarts with the new config.",
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        watcherId: { type: 'string', description: 'The watcher ID' },
-        conditions: { type: 'array', description: 'New conditions array', items: { type: 'object' } },
-        match: { type: 'string', enum: ['all', 'any'] },
-        action: { description: 'New action' },
-        cooldown: { type: 'number', description: 'New cooldown in seconds' },
-      },
-      required: ['watcherId'],
-    },
-  },
-  {
-    name: 'delete_watcher',
-    description: 'Stop and remove a watcher.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        watcherId: { type: 'string', description: 'The watcher ID to delete' },
-      },
-      required: ['watcherId'],
-    },
-  },
-  {
-    name: 'restart_watcher',
-    description: 'Restart a stopped watcher.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        watcherId: { type: 'string', description: 'The watcher ID to restart' },
-      },
-      required: ['watcherId'],
-    },
-  },
-]
+export { TOOLS } from '../shared/canonical/tools.js'
+import { TOOLS } from '../shared/canonical/tools.js'
 
 function text(content: string) {
   return { content: [{ type: 'text' as const, text: content }] }
@@ -179,9 +20,35 @@ function error(content: string) {
   return { content: [{ type: 'text' as const, text: content }], isError: true }
 }
 
+/**
+ * Try to start the daemon via CLI. Returns true if daemon becomes healthy.
+ */
+async function tryStartDaemon(daemonUrl: string): Promise<boolean> {
+  const startScript = new URL('../../bin/livetap.ts', import.meta.url).pathname
+  const port = new URL(daemonUrl).port || '8788'
+  const proc = Bun.spawn(['bun', startScript, 'start'], {
+    env: { ...process.env, LIVETAP_PORT: port },
+    stdout: 'ignore',
+    stderr: 'ignore',
+  })
+  proc.unref()
+
+  // Wait up to 15s for daemon to be ready
+  const deadline = Date.now() + 15_000
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${daemonUrl}/status`)
+      if (res.ok) return true
+    } catch { /* not ready */ }
+    await new Promise((r) => setTimeout(r, 500))
+  }
+  return false
+}
+
 /**
  * Register all livetap MCP tools on the given server.
  * Tools proxy to the daemon HTTP API at the given base URL.
+ * Includes auto-restart + retry on connection failure.
  */
 export function registerTools(server: Server, daemonUrl: string) {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -304,11 +171,40 @@ export function registerTools(server: Server, daemonUrl: string) {
           return text(await res.text())
         }
 
+        case 'status': {
+          const res = await fetch(`${daemonUrl}/status`)
+          if (!res.ok) return error('Daemon not reachable')
+          const status = await res.json()
+          // Also fetch watcher count
+          let watcherCount = 0
+          try {
+            const wr = await fetch(`${daemonUrl}/watchers`)
+            if (wr.ok) {
+              const watchers = await wr.json()
+              watcherCount = watchers.length
+            }
+          } catch { /* ok */ }
+          return text(JSON.stringify({ ...status, watcherCount }, null, 2))
+        }
+
         default:
           return error(`Unknown tool: ${name}`)
       }
     } catch (err) {
-      return error(`livetap daemon error: ${(err as Error).message}. Is the daemon running?`)
+      // Connection failed — try to auto-start daemon and retry
+      const msg = (err as Error).message
+      if (msg.includes('Unable to connect') || msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+        const started = await tryStartDaemon(daemonUrl)
+        if (!started) {
+          return error('livetap daemon could not be started. Run "livetap start" manually.')
+        }
+        // Retry: simple fetch to /status to confirm, then tell agent to retry
+        return text(JSON.stringify({
+          note: 'Daemon was restarted. Please retry your request.',
+          status: 'daemon_restarted',
+        }))
+      }
+      return error(`livetap daemon error: ${msg}`)
     }
   })
 }

package/src/server/connection-manager.ts

@@ -2,7 +2,7 @@
  * Connection Manager — creates, tracks, and destroys data source connections.
  */
 
-import type Redis from 'ioredis'
+import type { StreamStore } from './stream-store.js'
 import type { ConnectionConfig, ConnectionRecord, ConnectionStatus, Subscriber } from './types.js'
 import { MqttSubscriber } from './connections/mqtt.js'
 import { WebhookIngestor } from './connections/webhook.js'
@@ -18,12 +18,10 @@ function generateId(): string {
 
 export class ConnectionManager {
   private connections = new Map<string, ConnectionRecord>()
-  private redis: Redis
-  private redisUrl: string
+  private store: StreamStore
 
-  constructor(redis: Redis, redisUrl: string) {
-    this.redis = redis
-    this.redisUrl = redisUrl
+  constructor(store: StreamStore) {
+    this.store = store
   }
 
   async create(config: ConnectionConfig, name?: string): Promise<ConnectionRecord> {
@@ -51,27 +49,27 @@ export class ConnectionManager {
       record.subscriber = new MqttSubscriber({
         config,
         streamKey,
-        redis: this.redis,
+        store: this.store,
         onMessage,
       })
     } else if (config.type === 'webhook') {
       record.subscriber = new WebhookIngestor({
         streamKey,
-        redis: this.redis,
+        store: this.store,
         onMessage,
       })
     } else if (config.type === 'websocket') {
       record.subscriber = new WsSubscriber({
         config,
         streamKey,
-        redis: this.redis,
+        store: this.store,
         onMessage,
       })
     } else if (config.type === 'file') {
       record.subscriber = new FileSubscriber({
         config,
         streamKey,
-        redis: this.redis,
+        store: this.store,
         onMessage,
       })
     } else {
@@ -88,10 +86,8 @@ export class ConnectionManager {
     }, 5000)
 
     // Buffered count tracking (every 5s)
-    record.bufferedInterval = setInterval(async () => {
-      try {
-        record.bufferedCount = await this.redis.xlen(streamKey)
-      } catch { /* ignore */ }
+    record.bufferedInterval = setInterval(() => {
+      record.bufferedCount = this.store.len(streamKey)
     }, 5000)
 
     this.connections.set(id, record)
@@ -119,7 +115,7 @@ export class ConnectionManager {
     if (record.bufferedInterval) clearInterval(record.bufferedInterval)
 
     await record.subscriber.stop()
-    await this.redis.del(record.streamKey)
+    this.store.del(record.streamKey)
     this.connections.delete(id)
     return true
   }

package/src/server/connections/file.ts

@@ -1,18 +1,18 @@
 /**
  * File Tailing Subscriber — watches a file for new lines (tail -f behavior)
- * and writes each line to a Redis Stream with rolling retention.
+ * and writes each line to a stream with rolling retention.
  * Auto-detects JSON vs plain text per line.
  */
 
 import { watch, type FSWatcher } from 'fs'
 import { open, stat, type FileHandle } from 'fs/promises'
-import type Redis from 'ioredis'
+import type { StreamStore } from '../stream-store.js'
 import type { FileConnectionConfig, Subscriber, ConnectionStatus } from '../types.js'
 
 export interface FileSubscriberOpts {
   config: FileConnectionConfig
   streamKey: string
-  redis: Redis
+  store: StreamStore
   retentionMs?: number
   onMessage?: () => void
 }
@@ -20,7 +20,7 @@ export interface FileSubscriberOpts {
 export class FileSubscriber implements Subscriber {
   private config: FileConnectionConfig
   private streamKey: string
-  private redis: Redis
+  private store: StreamStore
   private retentionMs: number
   private onMessage: (() => void) | undefined
   private state: ConnectionStatus['runtimeState'] = 'disconnected'
@@ -35,7 +35,7 @@ export class FileSubscriber implements Subscriber {
   constructor(opts: FileSubscriberOpts) {
     this.config = opts.config
     this.streamKey = opts.streamKey
-    this.redis = opts.redis
+    this.store = opts.store
     this.retentionMs = opts.retentionMs ?? 5 * 60 * 1000
     this.onMessage = opts.onMessage
   }
@@ -98,9 +98,8 @@ export class FileSubscriber implements Subscriber {
           fields = { payload: line, format: 'text' }
         }
 
-        await this.redis.xadd(this.streamKey, '*', ...Object.entries(fields).flat())
-        const minId = Date.now() - this.retentionMs
-        await this.redis.xtrim(this.streamKey, 'MINID', '~', minId.toString())
+        this.store.append(this.streamKey, fields)
+        this.store.trim(this.streamKey, Date.now() - this.retentionMs)
         this.onMessage?.()
       }
     } catch (err) {

package/src/server/connections/mqtt.ts

@@ -1,16 +1,16 @@
 /**
  * MQTT Subscriber — connects to an MQTT broker and writes messages
- * to a Redis Stream with rolling retention.
+ * to a stream with rolling retention.
  */
 
 import mqtt from 'mqtt'
-import type Redis from 'ioredis'
+import type { StreamStore } from '../stream-store.js'
 import type { MqttConnectionConfig, Subscriber, ConnectionStatus } from '../types.js'
 
 export interface MqttSubscriberOpts {
   config: MqttConnectionConfig
   streamKey: string
-  redis: Redis
+  store: StreamStore
   retentionMs?: number
   onMessage?: () => void
 }
@@ -19,7 +19,7 @@ export class MqttSubscriber implements Subscriber {
   private client: mqtt.MqttClient | null = null
   private config: MqttConnectionConfig
   private streamKey: string
-  private redis: Redis
+  private store: StreamStore
   private retentionMs: number
   private onMessage: (() => void) | undefined
   private state: ConnectionStatus['runtimeState'] = 'disconnected'
@@ -28,7 +28,7 @@ export class MqttSubscriber implements Subscriber {
   constructor(opts: MqttSubscriberOpts) {
     this.config = opts.config
     this.streamKey = opts.streamKey
-    this.redis = opts.redis
+    this.store = opts.store
     this.retentionMs = opts.retentionMs ?? 5 * 60 * 1000
     this.onMessage = opts.onMessage
   }
@@ -77,14 +77,13 @@ export class MqttSubscriber implements Subscriber {
         this.state = 'reconnecting'
       })
 
-      this.client!.on('message', async (topic, payload) => {
+      this.client!.on('message', (topic, payload) => {
         try {
-          await this.redis.xadd(this.streamKey, '*', 'topic', topic, 'payload', payload.toString())
-          const minId = Date.now() - this.retentionMs
-          await this.redis.xtrim(this.streamKey, 'MINID', '~', minId.toString())
+          this.store.append(this.streamKey, { topic, payload: payload.toString() })
+          this.store.trim(this.streamKey, Date.now() - this.retentionMs)
           this.onMessage?.()
         } catch {
-          // Redis write failure — log but don't crash
+          // Write failure — log but don't crash
         }
       })
     })