livetap 0.1.0

package/src/cli/stop.ts

@@ -0,0 +1,64 @@
+/**
+ * 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')
+
+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.')
+    }
+    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 */ }
+  }
+
+  // Send SIGTERM
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM')
+    } catch { /* already gone */ }
+  }
+
+  // Wait for shutdown
+  const deadline = Date.now() + 5000
+  while (Date.now() < deadline) {
+    if (!(await isDaemonRunning())) break
+    await new Promise((r) => setTimeout(r, 300))
+  }
+
+  // Force kill if still running
+  if (await isDaemonRunning()) {
+    if (pid) try { process.kill(pid, 'SIGKILL') } catch { /* ok */ }
+  }
+
+  // Clean up state
+  if (existsSync(STATE_PATH)) {
+    try { unlinkSync(STATE_PATH) } catch { /* ok */ }
+  }
+
+  console.log('livetap daemon stopped')
+}

package/src/cli/tap.ts

@@ -0,0 +1,94 @@
+/**
+ * livetap tap <uri|file.json> — Connect to a data source.
+ */
+
+import { existsSync, readFileSync } from 'fs'
+import { daemonFetch } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  const source = args[0]
+  if (!source) {
+    console.error('Usage: livetap tap <uri|file.json|webhook>')
+    console.error('  livetap tap mqtt://broker.emqx.io:1883/sensors/#')
+    console.error('  livetap tap wss://stream.example.com/prices')
+    console.error('  livetap tap webhook')
+    console.error('  livetap tap connection.json')
+    process.exit(1)
+  }
+
+  const nameIdx = args.indexOf('--name')
+  const name = nameIdx !== -1 ? args[nameIdx + 1] : undefined
+
+  let config: any
+
+  if (source === 'webhook') {
+    config = { type: 'webhook' }
+  } else if (source.endsWith('.json') && existsSync(source)) {
+    config = JSON.parse(readFileSync(source, 'utf-8'))
+  } else if (source.startsWith('mqtt://') || source.startsWith('mqtts://')) {
+    config = parseMqttUri(source)
+  } else if (source.startsWith('ws://') || source.startsWith('wss://')) {
+    config = { type: 'websocket', url: source }
+  } else if (source.startsWith('file://')) {
+    const path = source.slice(7) // strip file://
+    if (!path.startsWith('/')) {
+      console.error('file:// path must be absolute (e.g. file:///var/log/app.log)')
+      process.exit(1)
+    }
+    config = { type: 'file', path }
+  } else {
+    console.error(`Unknown source format: ${source}`)
+    console.error('Expected: mqtt://..., wss://..., file:///path, webhook, or a .json file')
+    process.exit(1)
+  }
+
+  const body: any = { ...config }
+  if (name) body.name = name
+
+  const res = await daemonFetch('/connections', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+
+  const data = await res.json()
+
+  if (!res.ok) {
+    console.error(`Error: ${data.error}`)
+    process.exit(1)
+  }
+
+  console.log(`Tapped: ${data.connectionId} (${config.type} → ${summarize(config)})`)
+  if (data.ingestUrl) {
+    console.log(`Ingest URL: ${data.ingestUrl}`)
+  }
+}
+
+function parseMqttUri(uri: string): any {
+  // URL() mangles MQTT wildcards (# and +), so parse manually for the path
+  const url = new URL(uri)
+  const tls = url.protocol === 'mqtts:'
+
+  // Extract topic from the raw URI (after host:port/)
+  const hostEnd = uri.indexOf('/', uri.indexOf('//') + 2)
+  const rawTopic = hostEnd !== -1 ? uri.slice(hostEnd + 1) : ''
+
+  return {
+    type: 'mqtt',
+    broker: url.hostname,
+    port: parseInt(url.port) || (tls ? 8883 : 1883),
+    tls,
+    credentials: {
+      username: decodeURIComponent(url.username || ''),
+      password: decodeURIComponent(url.password || ''),
+    },
+    topics: rawTopic ? [rawTopic] : [],
+  }
+}
+
+function summarize(config: any): string {
+  if (config.type === 'mqtt') return `${config.broker}/${config.topics?.[0] ?? ''}`
+  if (config.type === 'websocket') return config.url
+  if (config.type === 'file') return config.path
+  return 'webhook ingest'
+}

package/src/cli/taps.ts

@@ -0,0 +1,32 @@
+/**
+ * livetap taps — List active taps.
+ */
+
+import { isDaemonRunning, daemonJson } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  if (!(await isDaemonRunning())) {
+    console.log('livetap is not running. Use "livetap start" first.')
+    return
+  }
+
+  const jsonMode = args.includes('--json')
+  const data = await daemonJson('/connections')
+
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2))
+    return
+  }
+
+  if (data.length === 0) {
+    console.log('No active taps. Use "livetap tap <uri>" to connect.')
+    return
+  }
+
+  console.log(`Active taps (${data.length}):\n`)
+  for (const c of data) {
+    const rate = `${c.msgPerSec} msg/s`
+    const buf = `${c.bufferedCount} buffered`
+    console.log(`  ${c.connectionId}  ${c.type.padEnd(9)} ${(c.summary || '').slice(0, 40).padEnd(42)} ${rate.padStart(10)}  ${buf}`)
+  }
+}

package/src/cli/untap.ts

@@ -0,0 +1,23 @@
+/**
+ * livetap untap <connectionId> — Remove a tap.
+ */
+
+import { daemonFetch } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  const id = args[0]
+  if (!id) {
+    console.error('Usage: livetap untap <connectionId>')
+    process.exit(1)
+  }
+
+  const res = await daemonFetch(`/connections/${id}`, { method: 'DELETE' })
+  const data = await res.json()
+
+  if (!res.ok) {
+    console.error(`Error: ${data.error}`)
+    process.exit(1)
+  }
+
+  console.log(`Untapped: ${id}`)
+}

package/src/cli/unwatch.ts

@@ -0,0 +1,23 @@
+/**
+ * livetap unwatch <watcherId> — Remove a watcher.
+ */
+
+import { daemonFetch } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  const id = args[0]
+  if (!id) {
+    console.error('Usage: livetap unwatch <watcherId>')
+    process.exit(1)
+  }
+
+  const res = await daemonFetch(`/watchers/${id}`, { method: 'DELETE' })
+  const data = await res.json()
+
+  if (!res.ok) {
+    console.error(`Error: ${data.error}`)
+    process.exit(1)
+  }
+
+  console.log(`Unwatched: ${id}`)
+}

package/src/cli/watch.ts

@@ -0,0 +1,91 @@
+/**
+ * livetap watch <connectionId> "expression" — Create a watcher.
+ */
+
+import { daemonFetch } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  const connId = args[0]
+  const exprStr = args[1]
+
+  if (!connId || !exprStr) {
+    console.error('Usage: livetap watch <connectionId> "field > value"')
+    console.error('  livetap watch conn_abc "temperature > 50"')
+    console.error('  livetap watch conn_abc "temp > 50 AND humidity > 90"')
+    console.error('  livetap watch conn_abc "temp > 50 OR smoke > 0.05"')
+    process.exit(1)
+  }
+
+  const cooldownIdx = args.indexOf('--cooldown')
+  const cooldown = cooldownIdx !== -1 ? parseInt(args[cooldownIdx + 1]) : 60
+
+  const { conditions, match } = parseExpression(exprStr)
+
+  // Parse action flag
+  const actionIdx = args.indexOf('--action')
+  let action: any = 'channel_alert'
+  if (actionIdx !== -1) {
+    const actionStr = args[actionIdx + 1]
+    if (actionStr.startsWith('webhook:')) {
+      action = { webhook: actionStr.slice(8) }
+    } else if (actionStr.startsWith('shell:')) {
+      action = { shell: actionStr.slice(6) }
+    } else {
+      action = actionStr
+    }
+  }
+
+  const res = await daemonFetch('/watchers', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ connectionId: connId, conditions, match, action, cooldown }),
+  })
+
+  const data = await res.json()
+
+  if (!res.ok) {
+    console.error(`Error: ${data.error}`)
+    process.exit(1)
+  }
+
+  console.log(`Watcher created: ${data.id} (${data.expression}, cooldown ${cooldown}s)`)
+}
+
+function parseExpression(expr: string): { conditions: any[]; match: 'all' | 'any' } {
+  let match: 'all' | 'any' = 'all'
+  let parts: string[]
+
+  if (expr.includes(' AND ')) {
+    parts = expr.split(' AND ').map((s) => s.trim())
+    match = 'all'
+  } else if (expr.includes(' OR ')) {
+    parts = expr.split(' OR ').map((s) => s.trim())
+    match = 'any'
+  } else {
+    parts = [expr.trim()]
+  }
+
+  const conditions = parts.map((part) => {
+    // Match: field op value
+    const m = part.match(/^(.+?)\s*(>=|<=|!=|>|<|==|contains|matches)\s*(.+)$/)
+    if (!m) {
+      console.error(`Cannot parse condition: "${part}"`)
+      console.error('Expected format: "field op value" (e.g. "temperature > 50")')
+      process.exit(1)
+    }
+
+    const field = m[1].trim()
+    const op = m[2].trim()
+    let value: any = m[3].trim()
+
+    // Parse value type
+    if (value === 'true') value = true
+    else if (value === 'false') value = false
+    else if (!isNaN(Number(value))) value = Number(value)
+    else value = value.replace(/^["']|["']$/g, '') // strip quotes
+
+    return { field, op, value }
+  })
+
+  return { conditions, match }
+}

package/src/cli/watchers.ts

@@ -0,0 +1,116 @@
+/**
+ * livetap watchers [connectionId] — List watchers.
+ */
+
+import { isDaemonRunning, daemonJson } from './daemon-client.js'
+
+export async function run(args: string[]) {
+  if (!(await isDaemonRunning())) {
+    console.log('livetap is not running. Use "livetap start" first.')
+    return
+  }
+
+  const jsonMode = args.includes('--json')
+
+  // --logs <watcherId> — show watcher logs
+  const logsIdx = args.indexOf('--logs')
+  if (logsIdx !== -1) {
+    const watcherId = args[logsIdx + 1]
+    if (!watcherId) {
+      console.error('Usage: livetap watchers --logs <watcherId>')
+      process.exit(1)
+    }
+    const data = await daemonJson(`/watchers/${watcherId}/logs`)
+    if (jsonMode) {
+      console.log(JSON.stringify(data, null, 2))
+    } else {
+      console.log(`Logs for ${watcherId}:\n`)
+      for (const line of data.logs || []) {
+        console.log(`  ${line}`)
+      }
+      if (!data.logs?.length) console.log('  (no logs yet)')
+    }
+    return
+  }
+
+  // Filter args: anything that doesn't start with - and isn't after a flag
+  const positional = args.filter((a) => !a.startsWith('-'))
+  const arg = positional[0]
+
+  // If it looks like a watcher ID, show that watcher's details
+  if (arg?.startsWith('w_')) {
+    const info = await daemonJson(`/watchers/${arg}`)
+    if (info.error) {
+      console.error(`Error: ${info.error}`)
+      return
+    }
+    if (jsonMode) {
+      console.log(JSON.stringify(info, null, 2))
+    } else {
+      const expr = info.conditions
+        ?.map((c: any) => `${c.field} ${c.op} ${c.value}`)
+        .join(info.match === 'all' ? ' AND ' : ' OR ') || '?'
+      console.log(`Watcher ${info.id}:`)
+      console.log(`  Connection: ${info.connectionId}`)
+      console.log(`  Expression: ${expr}`)
+      console.log(`  Status: ${info.status}  Matches: ${info.matchCount ?? 0}  Cooldown: ${info.cooldown}s`)
+      if (info.lastMatch) console.log(`  Last match: ${info.lastMatch}`)
+      console.log(`  Created: ${info.createdAt}`)
+    }
+    return
+  }
+
+  const connId = arg
+
+  const params = connId ? `?connectionId=${connId}` : ''
+  const data = await daemonJson(`/watchers${params}`)
+
+  // Handle error response (e.g. old daemon that requires connectionId)
+  if (data.error) {
+    console.error(`Error: ${data.error}`)
+    return
+  }
+
+  const list = Array.isArray(data) ? data : []
+
+  if (jsonMode) {
+    console.log(JSON.stringify(list, null, 2))
+    return
+  }
+
+  if (list.length === 0) {
+    console.log(connId ? `No watchers for ${connId}.` : 'No watchers.')
+    return
+  }
+
+  // Group by connectionId for display
+  const grouped = new Map<string, any[]>()
+  for (const w of list) {
+    const key = w.connectionId
+    if (!grouped.has(key)) grouped.set(key, [])
+    grouped.get(key)!.push(w)
+  }
+
+  for (const [cid, ws] of grouped) {
+    console.log(`Watchers for ${cid}:\n`)
+    printWatchers(ws)
+  }
+}
+
+function printWatchers(watchers: any[]) {
+  for (const w of watchers) {
+    const expr = w.conditions
+      ?.map((c: any) => `${c.field} ${c.op} ${c.value}`)
+      .join(w.match === 'all' ? ' AND ' : ' OR ') || '?'
+    const last = w.lastMatch ? timeSince(w.lastMatch) : 'never'
+    console.log(`  ${w.id}  ${expr}`)
+    console.log(`         ${w.status}  ${w.matchCount ?? 0} matches  cooldown ${w.cooldown}s  last: ${last}\n`)
+  }
+}
+
+function timeSince(iso: string): string {
+  const ms = Date.now() - new Date(iso).getTime()
+  if (ms < 60_000) return `${Math.round(ms / 1000)}s ago`
+  if (ms < 3600_000) return `${Math.round(ms / 60_000)}m ago`
+  return `${Math.round(ms / 3600_000)}h ago`
+}

package/src/mcp/channel.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env bun
+/**
+ * livetap MCP Channel Proxy
+ *
+ * Thin MCP server spawned by Claude Code as a subprocess (stdio transport).
+ * - Declares claude/channel capability for push notifications
+ * - Proxies all tool calls to the livetap daemon on :8788
+ * - Holds SSE connection to daemon /events for alert delivery
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { registerTools } from './tools.js'
+import { generateInstructions } from '../shared/catalog-generators.js'
+
+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> {
+  const deadline = Date.now() + maxWaitMs
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${DAEMON_URL}/status`)
+      if (res.ok) return true
+    } catch { /* not ready */ }
+    await new Promise((r) => setTimeout(r, 500))
+  }
+  return false
+}
+
+async function autoStartDaemon(): Promise<boolean> {
+  // Check if already running
+  try {
+    const res = await fetch(`${DAEMON_URL}/status`)
+    if (res.ok) return true
+  } catch { /* not running */ }
+
+  // Auto-start the daemon
+  console.error('[livetap-mcp] Daemon not running, auto-starting...')
+  Bun.spawn(['bun', 'src/server/index.ts'], {
+    env: { ...process.env, LIVETAP_PORT: String(DAEMON_PORT) },
+    stdout: 'ignore',
+    stderr: 'ignore',
+  })
+
+  return waitForDaemon()
+}
+
+async function connectToSSE(mcp: Server) {
+  try {
+    const res = await fetch(`${DAEMON_URL}/events`)
+    if (!res.ok || !res.body) return
+
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6)
+          try {
+            const event = JSON.parse(data)
+            await mcp.notification({
+              method: 'notifications/claude/channel',
+              params: {
+                content: JSON.stringify(event.payload ?? event),
+                meta: {
+                  type: event.type ?? 'alert',
+                  ...(event.connectionId && { connection: event.connectionId }),
+                  ...(event.watcherId && { watcher: event.watcherId }),
+                },
+              },
+            })
+          } catch { /* malformed event */ }
+        }
+      }
+    }
+  } catch {
+    // SSE connection failed — daemon may not support /events yet (Phase 3)
+    // Silently retry after delay
+    setTimeout(() => connectToSSE(mcp), 5000)
+  }
+}
+
+async function main() {
+  const daemonReady = await autoStartDaemon()
+  if (!daemonReady) {
+    console.error('[livetap-mcp] WARNING: Could not connect to daemon. Tools may fail.')
+  }
+
+  const mcp = new Server(
+    { name: 'livetap', version: '0.1.0' },
+    {
+      capabilities: {
+        experimental: { 'claude/channel': {} },
+        tools: {},
+      },
+      instructions: INSTRUCTIONS,
+    },
+  )
+
+  registerTools(mcp, DAEMON_URL)
+
+  await mcp.connect(new StdioServerTransport())
+  console.error('[livetap-mcp] MCP channel proxy connected')
+
+  // Start SSE listener for alert delivery (non-blocking)
+  connectToSSE(mcp)
+}
+
+main()