livetap 0.1.5 → 0.2.0

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
         }
       })
     })

package/src/server/connections/webhook.ts

@@ -1,28 +1,28 @@
 /**
  * Webhook Ingestor — HTTP endpoint that accepts POSTs and writes
- * payloads to a Redis Stream with rolling retention.
+ * payloads to a stream with rolling retention.
  */
 
-import type Redis from 'ioredis'
+import type { StreamStore } from '../stream-store.js'
 import type { Subscriber, ConnectionStatus } from '../types.js'
 
 export interface WebhookIngestorOpts {
   streamKey: string
-  redis: Redis
+  store: StreamStore
   retentionMs?: number
   onMessage?: () => void
 }
 
 export class WebhookIngestor implements Subscriber {
   private streamKey: string
-  private redis: Redis
+  private store: StreamStore
   private retentionMs: number
   private onMessage: (() => void) | undefined
   private state: ConnectionStatus['runtimeState'] = 'disconnected'
 
   constructor(opts: WebhookIngestorOpts) {
     this.streamKey = opts.streamKey
-    this.redis = opts.redis
+    this.store = opts.store
     this.retentionMs = opts.retentionMs ?? 5 * 60 * 1000
     this.onMessage = opts.onMessage
   }
@@ -39,12 +39,11 @@ export class WebhookIngestor implements Subscriber {
    * Ingest a webhook payload. Called by the HTTP API route handler.
    */
   async ingest(body: string, headers?: Record<string, string>): Promise<void> {
-    const fields: string[] = ['payload', body]
-    if (headers?.['content-type']) fields.push('content_type', headers['content-type'])
+    const fields: Record<string, string> = { payload: body }
+    if (headers?.['content-type']) fields.content_type = headers['content-type']
 
-    await this.redis.xadd(this.streamKey, '*', ...fields)
-    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?.()
   }
 

package/src/server/connections/websocket.ts

@@ -1,15 +1,15 @@
 /**
  * WebSocket Subscriber — connects to a remote WebSocket and writes
- * messages to a Redis Stream with rolling retention + reconnection.
+ * messages to a stream with rolling retention + reconnection.
  */
 
-import type Redis from 'ioredis'
+import type { StreamStore } from '../stream-store.js'
 import type { WebSocketConnectionConfig, Subscriber, ConnectionStatus } from '../types.js'
 
 export interface WsSubscriberOpts {
   config: WebSocketConnectionConfig
   streamKey: string
-  redis: Redis
+  store: StreamStore
   retentionMs?: number
   onMessage?: () => void
 }
@@ -18,7 +18,7 @@ export class WsSubscriber implements Subscriber {
   private ws: WebSocket | null = null
   private config: WebSocketConnectionConfig
   private streamKey: string
-  private redis: Redis
+  private store: StreamStore
   private retentionMs: number
   private onMessage: (() => void) | undefined
   private state: ConnectionStatus['runtimeState'] = 'disconnected'
@@ -31,7 +31,7 @@ export class WsSubscriber implements Subscriber {
   constructor(opts: WsSubscriberOpts) {
     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
   }
@@ -65,15 +65,14 @@ export class WsSubscriber implements Subscriber {
       }
     }
 
-    this.ws.onmessage = async (event) => {
+    this.ws.onmessage = (event) => {
       try {
         const fields = this.parseMessage(event.data)
-        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 {
-        // Redis write failure
+        // Write failure
       }
     }
 

package/src/server/index.ts

@@ -3,7 +3,7 @@
  * Manages connections, streams, and watchers.
  */
 
-import { startRedis, type RedisManager } from './redis.js'
+import { StreamStore } from './stream-store.js'
 import { ConnectionManager } from './connection-manager.js'
 import { WatcherManager } from './watchers/manager.js'
 import type { WatcherAlert } from './watchers/types.js'
@@ -11,7 +11,7 @@ import type { StreamEntry } from './types.js'
 
 const PORT = parseInt(process.env.LIVETAP_PORT || '8788')
 
-let redis: RedisManager
+let store: StreamStore
 let manager: ConnectionManager
 let watchers: WatcherManager
 
@@ -26,11 +26,10 @@ function broadcastSSE(alert: WatcherAlert) {
 }
 
 async function boot() {
-  redis = await startRedis()
-  console.error(`[livetap] Redis started on port ${redis.port}`)
+  store = new StreamStore()
 
-  manager = new ConnectionManager(redis.client, redis.url)
-  watchers = new WatcherManager(redis.client, redis.url, broadcastSSE)
+  manager = new ConnectionManager(store)
+  watchers = new WatcherManager(store, broadcastSSE)
 
   Bun.serve({
     port: PORT,
@@ -60,7 +59,6 @@ async function boot() {
         return json({
           status: 'running',
           port: PORT,
-          redisPort: redis.port,
           connections: manager.list(),
           uptime: process.uptime(),
         })
@@ -128,7 +126,7 @@ async function boot() {
         const maxEntries = parseInt(url.searchParams.get('maxEntries') ?? '50')
 
         try {
-          const entries = await readBackfill(record.streamKey, backfillSeconds, maxEntries)
+          const entries = readBackfill(record.streamKey, backfillSeconds, maxEntries)
           return json({ entries, totalEntries: entries.length })
         } catch (err) {
           return json({ error: (err as Error).message }, 500)
@@ -221,16 +219,13 @@ async function boot() {
   console.error(`[livetap] daemon listening on http://127.0.0.1:${PORT}`)
 }
 
-async function readBackfill(streamKey: string, backfillSeconds: number, maxEntries: number): Promise<StreamEntry[]> {
-  const since = (Date.now() - backfillSeconds * 1000).toString()
-  const raw = await redis.client.xrange(streamKey, since, '+', 'COUNT', maxEntries)
-  return raw.map(([id, fieldArray]) => {
-    const fields: Record<string, string> = {}
-    for (let i = 0; i < fieldArray.length; i += 2) {
-      fields[fieldArray[i]] = fieldArray[i + 1]
-    }
-    return { id, fields, ts: parseInt(id.split('-')[0]) }
-  })
+function readBackfill(streamKey: string, backfillSeconds: number, maxEntries: number): StreamEntry[] {
+  const sinceMs = Date.now() - backfillSeconds * 1000
+  return store.range(streamKey, sinceMs, maxEntries).map((e) => ({
+    id: e.id,
+    fields: e.fields,
+    ts: parseInt(e.id.split('-')[0]),
+  }))
 }
 
 function json(data: unknown, status = 200) {
@@ -245,7 +240,7 @@ async function shutdown() {
   console.error('[livetap] shutting down...')
   await watchers.stopAll()
   await manager.destroyAll()
-  await redis.stop()
+  store.stop()
   process.exit(0)
 }
 

package/src/server/stream-store.ts

@@ -0,0 +1,128 @@
+/**
+ * In-memory stream store — replaces Redis for stream buffering.
+ * Provides append, range, trim, len, del, and subscribe (EventEmitter).
+ */
+
+import { EventEmitter } from 'events'
+
+export interface StreamEntry {
+  id: string // "{timestamp}-{seq}"
+  fields: Record<string, string>
+}
+
+export class StreamStore {
+  private streams = new Map<string, StreamEntry[]>()
+  private seqCounters = new Map<string, number>()
+  private emitter = new EventEmitter()
+
+  constructor() {
+    this.emitter.setMaxListeners(1000)
+  }
+
+  /**
+   * Append an entry to a stream. Returns the generated ID.
+   * Equivalent to Redis XADD streamKey * field1 val1 field2 val2
+   */
+  append(streamKey: string, fields: Record<string, string>): string {
+    const ts = Date.now()
+    const seq = this.seqCounters.get(streamKey) ?? 0
+    this.seqCounters.set(streamKey, seq + 1)
+    const id = `${ts}-${seq}`
+
+    const entry: StreamEntry = { id, fields }
+
+    let stream = this.streams.get(streamKey)
+    if (!stream) {
+      stream = []
+      this.streams.set(streamKey, stream)
+    }
+    stream.push(entry)
+
+    this.emitter.emit(streamKey, entry)
+    return id
+  }
+
+  /**
+   * Read entries from a stream in a time range.
+   * Equivalent to Redis XRANGE streamKey since + COUNT count
+   */
+  range(streamKey: string, sinceMs: number, count?: number): StreamEntry[] {
+    const stream = this.streams.get(streamKey)
+    if (!stream) return []
+
+    const sinceStr = String(sinceMs)
+    const filtered = stream.filter((e) => {
+      const entryTs = e.id.split('-')[0]
+      return entryTs >= sinceStr
+    })
+
+    return count ? filtered.slice(0, count) : filtered
+  }
+
+  /**
+   * Trim entries older than minTs.
+   * Equivalent to Redis XTRIM streamKey MINID ~ minTs
+   */
+  trim(streamKey: string, minTs: number): void {
+    const stream = this.streams.get(streamKey)
+    if (!stream) return
+
+    const minStr = String(minTs)
+    // Find first entry that's >= minTs
+    let cutIndex = 0
+    for (let i = 0; i < stream.length; i++) {
+      const entryTs = stream[i].id.split('-')[0]
+      if (entryTs >= minStr) break
+      cutIndex = i + 1
+    }
+    if (cutIndex > 0) {
+      stream.splice(0, cutIndex)
+    }
+  }
+
+  /**
+   * Get entry count for a stream.
+   * Equivalent to Redis XLEN streamKey
+   */
+  len(streamKey: string): number {
+    return this.streams.get(streamKey)?.length ?? 0
+  }
+
+  /**
+   * Delete a stream entirely.
+   * Equivalent to Redis DEL streamKey
+   */
+  del(streamKey: string): void {
+    this.streams.delete(streamKey)
+    this.seqCounters.delete(streamKey)
+    this.emitter.removeAllListeners(streamKey)
+  }
+
+  /**
+   * Subscribe to new entries on a stream.
+   * Replaces Redis XREAD BLOCK — zero-latency, event-driven.
+   * Returns an unsubscribe function.
+   */
+  subscribe(streamKey: string, callback: (entry: StreamEntry) => void): () => void {
+    this.emitter.on(streamKey, callback)
+    return () => {
+      this.emitter.off(streamKey, callback)
+    }
+  }
+
+  /**
+   * Check if a stream exists.
+   */
+  has(streamKey: string): boolean {
+    return this.streams.has(streamKey)
+  }
+
+  /**
+   * Stop the store — clean up all data and listeners.
+   */
+  stop(): void {
+    this.streams.clear()
+    this.seqCounters.clear()
+    this.emitter.removeAllListeners()
+  }
+}

package/src/server/watchers/engine.ts

@@ -6,10 +6,15 @@
 import type { WatcherCondition, WatcherDefinition } from './types.js'
 
 /**
- * Resolve a dot-separated path into a nested object.
- * Returns undefined if any segment is missing.
+ * Resolve a field path into an object.
+ * First tries the path as a literal key (handles keys like "2.8.0"),
+ * then falls back to dot-separated nested access (handles "sensors.temperature.value").
  */
 export function resolveDotPath(obj: any, path: string): any {
+  if (obj == null) return undefined
+  // Try literal key first (handles OBIS codes like "2.8.0", "32.7.0")
+  if (path in obj) return obj[path]
+  // Fall back to dot-path traversal
   return path.split('.').reduce((o, k) => o?.[k], obj)
 }