livetap 0.1.5 → 0.2.0

package/src/server/watchers/manager.ts

@@ -1,13 +1,14 @@
 /**
  * Watcher Manager — CRUD + evaluation loops for expression watchers.
- * Stores definitions in Redis hashes. Runs evaluator loops in-process.
+ * Stores definitions in-memory. Evaluates via StreamStore subscriptions.
  */
 
-import Redis from 'ioredis'
 import { mkdirSync, appendFileSync, statSync, writeFileSync, readFileSync, unlinkSync } from 'fs'
 import { resolve } from 'path'
 import { homedir } from 'os'
+import type { StreamStore, StreamEntry } from '../stream-store.js'
 import type { WatcherCondition, WatcherDefinition, WatcherInfo, WatcherAlert, WatcherAction } from './types.js'
+import { resolveDotPath } from './engine.js'
 import { VALID_OPS } from './types.js'
 import { evaluateWatcher, extractMatchedValues, formatExpression } from './engine.js'
 
@@ -24,15 +25,13 @@ const MAX_LOG_SIZE = 512 * 1024 // 512KB
 export type AlertCallback = (alert: WatcherAlert) => void
 
 export class WatcherManager {
-  private redisUrl: string
-  private loops = new Map<string, { abort: AbortController; reader: Redis }>()
+  private store: StreamStore
+  private subscriptions = new Map<string, () => void>() // watcherId → unsubscribe
   private info = new Map<string, WatcherInfo>()
   private onAlert: AlertCallback
-  private redis: Redis
 
-  constructor(redis: Redis, redisUrl: string, onAlert: AlertCallback) {
-    this.redis = redis
-    this.redisUrl = redisUrl
+  constructor(store: StreamStore, onAlert: AlertCallback) {
+    this.store = store
     this.onAlert = onAlert
     mkdirSync(LOG_DIR, { recursive: true })
   }
@@ -73,9 +72,6 @@ export class WatcherManager {
       updatedAt: now,
     }
 
-    // Store in flat hash (globally unique watcher IDs)
-    await this.redis.hset('livetap:watchers', id, JSON.stringify(def))
-
     const info: WatcherInfo = { ...def, matchCount: 0, entriesChecked: 0 }
     this.info.set(id, info)
 
@@ -135,10 +131,6 @@ export class WatcherManager {
     info.updatedAt = new Date().toISOString()
     info.status = 'running'
 
-    // Persist
-    const def: WatcherDefinition = { ...info }
-    await this.redis.hset('livetap:watchers', watcherId, JSON.stringify(def))
-
     this.writeLog(watcherId, `UPDATED conditions=${formatExpression(info.conditions, info.match)} cooldown=${info.cooldown}s`)
     this.startLoop(watcherId, streamKey, info)
 
@@ -162,7 +154,6 @@ export class WatcherManager {
 
     this.stopLoop(watcherId)
     this.info.delete(watcherId)
-    await this.redis.hdel('livetap:watchers', watcherId)
 
     // Delete log file
     try { unlinkSync(resolve(LOG_DIR, `${watcherId}.log`)) } catch { /* ok */ }
@@ -178,114 +169,93 @@ export class WatcherManager {
   }
 
   private startLoop(watcherId: string, streamKey: string, def: WatcherDefinition) {
-    const abort = new AbortController()
-    const reader = new Redis(this.redisUrl)
-    this.loops.set(watcherId, { abort, reader })
-
     const info = this.info.get(watcherId)!
     let lastAlertTime = 0
     let checkpointTime = Date.now()
-    const fieldNotFoundThrottle = new Map<string, number>() // field → last logged time
+    const fieldNotFoundThrottle = new Map<string, number>()
+
+    const onEntry = (entry: StreamEntry) => {
+      try {
+        info.entriesChecked++
+        info.lastChecked = new Date().toISOString()
+
+        const fields = entry.fields
 
-    const run = async () => {
-      let lastId = '$'
-      while (!abort.signal.aborted) {
+        // Parse payload: use parsed JSON object if available, otherwise raw fields
+        let payload: any
         try {
-          const result = await reader.xread('BLOCK', 2000, 'STREAMS', streamKey, lastId)
-          if (!result || abort.signal.aborted) continue
-
-          for (const [, entries] of result) {
-            for (const [id, fieldArray] of entries) {
-              lastId = id
-              info.entriesChecked++
-              info.lastChecked = new Date().toISOString()
-
-              // Parse fields
-              const fields: Record<string, string> = {}
-              for (let i = 0; i < fieldArray.length; i += 2) {
-                fields[fieldArray[i]] = fieldArray[i + 1]
-              }
-
-              // Parse payload: try JSON first, fall back to raw fields
-              let payload: any
-              try {
-                payload = JSON.parse(fields.payload ?? '{}')
-              } catch {
-                // Plain text — use raw Redis fields as the payload
-                // This allows conditions like { field: "payload", op: "contains", value: "ERROR" }
-                payload = fields
-              }
-
-              // Log missing fields (throttled: once per field per minute)
-              for (const c of def.conditions) {
-                const val = resolveDotPathImport(payload, c.field)
-                if (val === undefined) {
-                  const last = fieldNotFoundThrottle.get(c.field) ?? 0
-                  if (Date.now() - last > 60_000) {
-                    this.writeLog(watcherId, `FIELD_NOT_FOUND ${c.field} in entry ${id}`)
-                    fieldNotFoundThrottle.set(c.field, Date.now())
-                  }
-                }
-              }
-
-              // Evaluate
-              const matched = evaluateWatcher(payload, def)
-              if (matched) {
-                const now = Date.now()
-                if (now - lastAlertTime >= def.cooldown * 1000) {
-                  lastAlertTime = now
-                  info.matchCount++
-                  info.lastMatch = new Date().toISOString()
-
-                  const matchedValues = extractMatchedValues(payload, def.conditions)
-                  const expression = formatExpression(def.conditions, def.match)
-
-                  this.writeLog(watcherId, `MATCH ${Object.entries(matchedValues).map(([k, v]) => `${k}=${v}`).join(' ')} action=${typeof def.action === 'string' ? def.action : JSON.stringify(def.action)}`)
-
-                  const alert: WatcherAlert = {
-                    watcherId,
-                    connectionId: def.connectionId,
-                    expression,
-                    matchedValues,
-                    entry: fields,
-                    ts: now,
-                  }
-
-                  // Execute action
-                  await this.executeAction(def.action, alert)
-                  this.onAlert(alert)
-                } else {
-                  const remaining = Math.round((def.cooldown * 1000 - (Date.now() - lastAlertTime)) / 1000)
-                  this.writeLog(watcherId, `SUPPRESSED ${formatExpression(def.conditions, def.match)} (cooldown ${remaining}s remaining)`)
-                }
-              }
-
-              // Checkpoint every 5 minutes
-              if (Date.now() - checkpointTime > 5 * 60 * 1000) {
-                this.writeLog(watcherId, `CHECKPOINT entries_checked=${info.entriesChecked} matches=${info.matchCount}`)
-                checkpointTime = Date.now()
-              }
+          const parsed = JSON.parse(fields.payload ?? '{}')
+          // Only use parsed result if it's an object (has addressable fields).
+          // Primitives (numbers, strings, booleans) fall through to raw fields
+          // so "payload" remains addressable for regex/contains/numeric conditions.
+          payload = (typeof parsed === 'object' && parsed !== null) ? parsed : fields
+        } catch {
+          // Not valid JSON — use raw fields as the payload
+          payload = fields
+        }
+
+        // Log missing fields (throttled: once per field per minute)
+        for (const c of def.conditions) {
+          const val = resolveDotPath(payload, c.field)
+          if (val === undefined) {
+            const last = fieldNotFoundThrottle.get(c.field) ?? 0
+            if (Date.now() - last > 60_000) {
+              this.writeLog(watcherId, `FIELD_NOT_FOUND ${c.field} in entry ${entry.id}`)
+              fieldNotFoundThrottle.set(c.field, Date.now())
             }
           }
-        } catch (err) {
-          if (!abort.signal.aborted) {
-            this.writeLog(watcherId, `ERROR ${(err as Error).message}`)
-            await new Promise((r) => setTimeout(r, 1000))
+        }
+
+        // Evaluate
+        const matched = evaluateWatcher(payload, def)
+        if (matched) {
+          const now = Date.now()
+          if (now - lastAlertTime >= def.cooldown * 1000) {
+            lastAlertTime = now
+            info.matchCount++
+            info.lastMatch = new Date().toISOString()
+
+            const matchedValues = extractMatchedValues(payload, def.conditions)
+            const expression = formatExpression(def.conditions, def.match)
+
+            this.writeLog(watcherId, `MATCH ${Object.entries(matchedValues).map(([k, v]) => `${k}=${v}`).join(' ')} action=${typeof def.action === 'string' ? def.action : JSON.stringify(def.action)}`)
+
+            const alert: WatcherAlert = {
+              watcherId,
+              connectionId: def.connectionId,
+              expression,
+              matchedValues,
+              entry: fields,
+              ts: now,
+            }
+
+            this.executeAction(def.action, alert)
+            this.onAlert(alert)
+          } else {
+            const remaining = Math.round((def.cooldown * 1000 - (Date.now() - lastAlertTime)) / 1000)
+            this.writeLog(watcherId, `SUPPRESSED ${formatExpression(def.conditions, def.match)} (cooldown ${remaining}s remaining)`)
           }
         }
+
+        // Checkpoint every 5 minutes
+        if (Date.now() - checkpointTime > 5 * 60 * 1000) {
+          this.writeLog(watcherId, `CHECKPOINT entries_checked=${info.entriesChecked} matches=${info.matchCount}`)
+          checkpointTime = Date.now()
+        }
+      } catch (err) {
+        this.writeLog(watcherId, `ERROR ${(err as Error).message}`)
       }
-      reader.disconnect()
     }
 
-    run()
+    const unsub = this.store.subscribe(streamKey, onEntry)
+    this.subscriptions.set(watcherId, unsub)
   }
 
   private stopLoop(watcherId: string) {
-    const loop = this.loops.get(watcherId)
-    if (loop) {
-      loop.abort.abort()
-      loop.reader.disconnect()
-      this.loops.delete(watcherId)
+    const unsub = this.subscriptions.get(watcherId)
+    if (unsub) {
+      unsub()
+      this.subscriptions.delete(watcherId)
     }
     const info = this.info.get(watcherId)
     if (info) info.status = 'stopped'
@@ -342,13 +312,9 @@ export class WatcherManager {
   }
 
   async stopAll() {
-    for (const id of this.loops.keys()) {
+    for (const id of this.subscriptions.keys()) {
       this.stopLoop(id)
     }
   }
 }
 
-// Import from engine to avoid circular
-function resolveDotPathImport(obj: any, path: string): any {
-  return path.split('.').reduce((o, k) => o?.[k], obj)
-}

package/src/shared/catalog-generators.ts

@@ -4,6 +4,11 @@
 
 import { CLI_COMMANDS, type CatalogCommand } from './command-catalog.js'
 import { TOOLS } from '../mcp/tools.js'
+import { readFileSync } from 'fs'
+import { resolve } from 'path'
+
+const PKG = JSON.parse(readFileSync(resolve(import.meta.dir, '../../package.json'), 'utf-8'))
+const VERSION: string = PKG.version
 
 /**
  * Generate human-readable --help text.
@@ -51,19 +56,19 @@ export function generateHelpText(): string {
 export function generateLlmHelp(): object {
   return {
     name: 'LiveTap',
-    version: '0.1.4',
+    version: VERSION,
     description: 'Push live data streams into your AI coding agent',
     setup: {
       steps: [
         'Step 1: npm install livetap (skip if already installed)',
-        'Step 2: npx livetap setup (creates .mcp.json in project root — do NOT create it manually)',
+        'Step 2: npx livetap setup (creates .mcp.json and starts the daemon — do NOT create .mcp.json manually)',
         'Step 3: Tell user to restart Claude Code: claude --dangerously-load-development-channels server:livetap --continue',
         'Step 4: After restart, use create_connection to connect, read_stream to sample, create_watcher to alert',
       ],
       do_not: [
         'Do NOT add livetap to ~/.claude/mcp.json — it goes in .mcp.json in the project root',
         'Do NOT configure livetap as type:http — it is a stdio MCP server (command + args)',
-        'Do NOT start the daemon manually — the MCP proxy auto-starts it on Claude restart',
+        'Do NOT worry about the daemon — setup starts it, and the MCP proxy auto-starts it if needed',
         'Do NOT guess field names — always read_stream first to see actual payload structure',
         'Do NOT use npm init — use the existing project directory',
       ],
@@ -107,6 +112,7 @@ WORKFLOW:
 4. MANAGE:
    - ${connectionTools.join(', ')} — manage connections
    - ${watcherTools.join(', ')} — manage watchers
+   - status — check daemon health, uptime, active connections and watchers
    - Watcher IDs (w_xxx) are globally unique. No connectionId needed for get/update/delete.
 
 CHANNEL EVENTS:
@@ -133,9 +139,11 @@ DATA SHAPE BY SOURCE:
 - IMPORTANT: always use read_stream first to see the actual field names. Do NOT guess — the field is "payload", not "line" or "message".
 
 TIPS:
+- The daemon auto-starts when needed. If a tool returns "daemon was restarted", just retry your request.
 - Watcher IDs (w_xxx) are globally unique. You don't need the connectionId to get, update, or delete a watcher.
 - Common MQTT brokers: broker.emqx.io (public demo), test.mosquitto.org (public test).
 - For regex watchers, use the "matches" operator: { field: "payload", op: "matches", value: "ERROR|FATAL" }
 - If a field path doesn't exist in the payload, the condition evaluates to false (no crash, no error).
+- Fields with dots in the key name (like OBIS codes "2.8.0") are looked up as literal keys first, then as dot-paths.
 `.trim()
 }

package/src/shared/command-catalog.ts

@@ -26,13 +26,13 @@ export const CLI_COMMANDS: CatalogCommand[] = [
   {
     name: 'setup',
     usage: 'livetap setup',
-    description: 'Configure .mcp.json for Claude Code and print restart instructions. Run this after npm install.',
+    description: 'Configure .mcp.json, start the daemon, and print restart instructions. Run this after npm install.',
   },
   // --- Daemon ---
   {
     name: 'start',
     usage: 'livetap start',
-    description: 'Start the livetap daemon (embedded Redis + HTTP API)',
+    description: 'Start the livetap daemon (HTTP API)',
     flags: [
       { name: '--port', type: 'number', default: 8788, description: 'Daemon port (env: LIVETAP_PORT)' },
       { name: '--foreground', type: 'boolean', description: 'Run in foreground (don\'t detach)' },

package/src/server/redis.ts

@@ -1,62 +0,0 @@
-/**
- * Embedded Redis lifecycle manager.
- * Uses the `redis-server` npm package which bundles a Redis binary.
- */
-
-import RedisServer from 'redis-server'
-import Redis from 'ioredis'
-
-export interface RedisManager {
-  port: number
-  url: string
-  client: Redis
-  stop(): Promise<void>
-}
-
-/**
- * Start an embedded redis-server on the given port (or random free port).
- * Returns a manager with a connected ioredis client.
- */
-export async function startRedis(preferredPort?: number): Promise<RedisManager> {
-  const port = preferredPort ?? await findFreePort()
-
-  const server = new RedisServer({ port })
-
-  await new Promise<void>((resolve, reject) => {
-    server.open((err: Error | null) => {
-      if (err) reject(err)
-      else resolve()
-    })
-  })
-
-  const url = `redis://127.0.0.1:${port}`
-  const client = new Redis(url, { maxRetriesPerRequest: 3, lazyConnect: false })
-
-  await client.ping()
-
-  return {
-    port,
-    url,
-    client,
-    async stop() {
-      client.disconnect()
-      await new Promise<void>((resolve, reject) => {
-        server.close((err: Error | null) => {
-          if (err) reject(err)
-          else resolve()
-        })
-      })
-    },
-  }
-}
-
-async function findFreePort(): Promise<number> {
-  const server = Bun.listen({
-    hostname: '127.0.0.1',
-    port: 0,
-    socket: { data() {} },
-  })
-  const port = server.port
-  server.stop()
-  return port
-}