livetap 0.2.0 → 0.2.1

package/src/shared/canonical/cli.ts

@@ -0,0 +1,144 @@
+/**
+ * Canonical CLI command definitions.
+ * This is the single source of truth for all CLI commands.
+ *
+ * Consumed by:
+ *   - catalog-generators.ts   → --help, --llm-help
+ *   - drift detection tests   → cross-reference validation
+ */
+
+export interface CatalogCommand {
+  name: string
+  usage: string
+  description: string
+  args?: { position: number; name: string; required: boolean; description?: string }[]
+  flags?: { name: string; type: string; default?: unknown; description: string }[]
+  examples?: string[]
+}
+
+export const CLI_COMMANDS: CatalogCommand[] = [
+  // --- Setup ---
+  {
+    name: 'setup',
+    usage: 'livetap setup',
+    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 (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)' },
+    ],
+  },
+  {
+    name: 'stop',
+    usage: 'livetap stop',
+    description: 'Stop the daemon',
+  },
+  {
+    name: 'status',
+    usage: 'livetap status',
+    description: 'Show daemon, taps, and watchers',
+    flags: [
+      { name: '--json', type: 'boolean', description: 'Output as JSON' },
+    ],
+  },
+  // --- Connections ---
+  {
+    name: 'tap',
+    usage: 'livetap tap <uri|file.json>',
+    description: 'Tap into a data source (MQTT, WebSocket, file, or webhook)',
+    args: [
+      { position: 0, name: 'source', required: true, description: 'URI (mqtt://..., wss://..., file:///path), "webhook", or a .json config file' },
+    ],
+    flags: [
+      { name: '--name', type: 'string', description: 'Display name for the connection' },
+    ],
+    examples: [
+      'livetap tap mqtt://broker.emqx.io:1883/sensors/#',
+      'livetap tap wss://stream.example.com/prices',
+      'livetap tap file:///var/log/nginx/error.log',
+      'livetap tap webhook',
+      'livetap tap connection.json',
+    ],
+  },
+  {
+    name: 'untap',
+    usage: 'livetap untap <connectionId>',
+    description: 'Remove a tap',
+    args: [
+      { position: 0, name: 'connectionId', required: true },
+    ],
+  },
+  {
+    name: 'taps',
+    usage: 'livetap taps',
+    description: 'List active taps',
+    flags: [
+      { name: '--json', type: 'boolean', description: 'Output as JSON' },
+    ],
+  },
+  // --- Sampling ---
+  {
+    name: 'sip',
+    usage: 'livetap sip <connectionId>',
+    description: 'Sip from a stream (sample recent entries as pretty JSON)',
+    args: [
+      { position: 0, name: 'connectionId', required: true },
+    ],
+    flags: [
+      { name: '--max', type: 'number', default: 10, description: 'Max entries to return' },
+      { name: '--back', type: 'number', default: 60, description: 'Backfill seconds' },
+      { name: '--raw', type: 'boolean', description: 'Output raw JSON' },
+    ],
+  },
+  // --- Watchers ---
+  {
+    name: 'watch',
+    usage: 'livetap watch <connectionId> "expression"',
+    description: 'Create an expression-based watcher',
+    args: [
+      { position: 0, name: 'connectionId', required: true },
+      { position: 1, name: 'expression', required: true, description: '"field > value", supports AND/OR' },
+    ],
+    flags: [
+      { name: '--cooldown', type: 'number', default: 60, description: 'Seconds between repeated alerts (0 = every match)' },
+      { name: '--action', type: 'string', description: '"channel_alert" (default), "webhook:URL", or "shell:command"' },
+    ],
+    examples: [
+      'livetap watch conn_abc "temperature > 50"',
+      'livetap watch conn_abc "temp > 50 AND humidity > 90"',
+      'livetap watch conn_abc "temp > 50 OR smoke > 0.05"',
+      'livetap watch conn_abc "price > 70000" --cooldown 300',
+    ],
+  },
+  {
+    name: 'unwatch',
+    usage: 'livetap unwatch <watcherId>',
+    description: 'Remove a watcher',
+    args: [
+      { position: 0, name: 'watcherId', required: true },
+    ],
+  },
+  {
+    name: 'watchers',
+    usage: 'livetap watchers [connectionId|watcherId]',
+    description: 'List watchers, show watcher details, or view watcher logs',
+    args: [
+      { position: 0, name: 'connectionId or watcherId', required: false, description: 'Filter by connection (conn_xxx) or show details for a watcher (w_xxx)' },
+    ],
+    flags: [
+      { name: '--json', type: 'boolean', description: 'Output as JSON' },
+      { name: '--logs', type: 'string', description: 'Show evaluation logs for a watcher ID' },
+    ],
+    examples: [
+      'livetap watchers',
+      'livetap watchers conn_abc',
+      'livetap watchers w_abc',
+      'livetap watchers --logs w_abc',
+    ],
+  },
+]

package/src/shared/canonical/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical data barrel — THE single import point for all canonical data.
+ *
+ * Usage:
+ *   import { TOOLS, CLI_COMMANDS, META } from '../canonical/index.js'
+ */
+
+export { TOOLS } from './tools.js'
+export { CLI_COMMANDS, type CatalogCommand } from './cli.js'
+export { META } from './meta.js'

package/src/shared/canonical/meta.ts

@@ -0,0 +1,222 @@
+/**
+ * Canonical metadata — everything that isn't tool schemas or CLI commands.
+ * This is the single source of truth for descriptions, operators, source types,
+ * examples, do-not rules, tips, data shapes, and generation specs.
+ *
+ * Consumed by:
+ *   - catalog-generators.ts   → --help, --llm-help, MCP instructions
+ *   - /lt-push skill          → README + CONTRIBUTING generation
+ *   - drift detection tests   → cross-reference validation
+ *   - package.json            → description field (synced by /lt-push)
+ */
+
+export const META = {
+  name: 'LiveTap',
+  npmName: 'livetap',
+  description: 'Push live data streams into your AI coding agent',
+  npmDescription: 'Push live data streams into your AI coding agent. LLM/AI agent? Run: npx livetap --llm-help',
+  repo: 'https://github.com/livetap/livetap',
+  license: 'MIT',
+
+  channelsExplainer: 'Claude Code Channels let MCP servers push real-time events (like watcher alerts) into your conversation. The --dangerously-load-development-channels flag enables this for locally-installed servers. It only loads servers listed in your project\'s .mcp.json — nothing is sent externally.',
+
+  demoImages: [
+    {
+      path: 'docs/images/demo-setup.png',
+      alt: 'Claude Code connects to a live MQTT stream of solar inverter data, samples payloads with OBIS codes, and creates a watcher for high power consumption (16.7.0 > 3000W). When the alert fires, it autonomously formats the data and analyzes the reading.',
+      caption: 'Real solar inverter data — from natural language request to live alert in under 30 seconds',
+    },
+    {
+      path: 'docs/images/demo-alert.png',
+      alt: 'A second alert fires and Claude Code autonomously compares previous and current values, noting consumption increased by 174W and is still climbing. It formats a comparison table and recommends investigation.',
+      caption: 'Escalating alerts — the agent compares values across alerts and analyzes trends autonomously',
+    },
+  ],
+
+  sourceTypes: [
+    {
+      type: 'mqtt',
+      params: '{ type: "mqtt", broker, port, tls, topics, username?, password? }',
+      cli: 'mqtt://host:port/topic/#',
+      useCase: 'IoT sensors, home automation',
+    },
+    {
+      type: 'websocket',
+      params: '{ type: "websocket", url, headers?, handshake? }',
+      cli: 'wss://...',
+      useCase: 'Finance, real-time APIs',
+    },
+    {
+      type: 'file',
+      params: '{ type: "file", path }',
+      cli: 'file:///path/to/log',
+      useCase: 'Log monitoring, DevOps',
+    },
+    {
+      type: 'webhook',
+      params: '{ type: "webhook" }',
+      cli: 'webhook',
+      useCase: 'CI/CD, external services',
+      status: 'built-deferred' as const,
+    },
+  ],
+
+  operators: ['>', '<', '>=', '<=', '==', '!=', 'contains', 'matches'] as const,
+
+  doNotRules: [
+    '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 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',
+  ],
+
+  dataShapes: [
+    {
+      source: 'MQTT/WebSocket',
+      format: 'JSON',
+      description: 'entries have { payload: "{...json...}", topic: "..." }. The payload is parsed as JSON.',
+      usage: 'Use dot-paths into the parsed JSON: "sensors.temperature.value", "metadata.device_name"',
+    },
+    {
+      source: 'File',
+      format: 'plain text',
+      description: 'entries have { payload: "the raw line", format: "text" }.',
+      usage: 'Use field "payload" with contains/matches: { field: "payload", op: "contains", value: "ERROR" }',
+    },
+    {
+      source: 'File',
+      format: 'JSON lines',
+      description: 'entries have { payload: "{...json...}", format: "json" }. Parsed as JSON.',
+      usage: 'Use dot-paths like MQTT: "level", "msg", "status"',
+    },
+  ],
+
+  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.',
+  ],
+
+  setupSteps: [
+    'Step 1: npm install livetap (skip if already installed)',
+    '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',
+  ],
+
+  examples: [
+    {
+      title: 'IoT sensor monitoring',
+      sourceType: 'mqtt' as const,
+      url: 'mqtt://broker.emqx.io:1883/justinx/demo/#',
+      publicBroker: true,
+      fieldPaths: ['sensors.environmental.temperature.value'],
+      condition: 'temperature > 25',
+      narrative: 'Agent connects to the free public broker, samples payload structure, sets watcher on sensors.environmental.temperature.value > 25. Fires: "sensor-zone-c hit 25.4C at 10:05:08Z"',
+    },
+    {
+      title: 'WebSocket trade stream',
+      sourceType: 'websocket' as const,
+      url: 'wss://stream.binance.com:9443/ws/btcusdt@trade',
+      fieldPaths: ['p', 'q', 'T'],
+      condition: 'payload contains "btcusdt"',
+      narrative: 'Agent connects, samples to discover trade fields (p=price, q=quantity, T=timestamp), sets up a watcher to log each trade. Can filter by quantity or use regex on the symbol field.',
+    },
+    {
+      title: 'Log file monitoring',
+      sourceType: 'file' as const,
+      url: 'file:///var/log/nginx/error.log',
+      fieldPaths: ['payload'],
+      condition: 'payload matches "5[0-9]{2}"',
+      narrative: 'Agent tails error log, creates regex watcher for 5xx errors, summarizes each match: "503 Service Unavailable on /api/data — upstream auth-service not responding"',
+    },
+    {
+      title: 'WiFi disconnect detection',
+      sourceType: 'file' as const,
+      url: 'file:///var/log/wifi.log',
+      fieldPaths: ['payload'],
+      condition: 'payload matches "power state changed"',
+      narrative: 'Agent monitors WiFi log for power state changes, reports outage duration: "Wi-Fi powered OFF at 17:51:45, back ON at 17:51:47 (2s outage)"',
+    },
+  ],
+
+  alertGuidance: [
+    'When a watcher alert fires, you receive the FULL stream entry — all fields, not just the matched condition.',
+    'Analyze the data: format it clearly (tables work well), explain what the values mean, identify what triggered the alert.',
+    'Compare across alerts: if you have seen previous alerts from the same watcher, compare values and note trends (e.g. "consumption increased by 174W since last alert").',
+    'Be proactive: if values are escalating, say so. If something looks anomalous compared to earlier samples, flag it.',
+    'Include context: device IDs, timestamps, related fields — not just the field that matched the condition.',
+  ],
+
+  troubleshooting: [
+    {
+      problem: 'Daemon won\'t start / "Unable to connect"',
+      solution: 'Run `livetap start --foreground` to see error output. Check if port 8788 is in use: `lsof -i :8788`. Use `--port` or `LIVETAP_PORT` to change.',
+    },
+    {
+      problem: 'MQTT connection refused',
+      solution: 'Verify the broker is reachable: `nc -zv broker.emqx.io 1883`. Check that `tls: false` and `port: 1883` are set for unencrypted brokers. Brokers on port 8883 typically require `tls: true`.',
+    },
+    {
+      problem: 'Watcher not firing',
+      solution: 'Run `read_stream` (or `livetap sip`) to verify data is flowing. Check field paths match the actual payload structure. View watcher logs: `livetap watchers --logs <watcherId>` — look for FIELD_NOT_FOUND or SUPPRESSED events.',
+    },
+    {
+      problem: 'MCP tools not showing after restart',
+      solution: 'Verify `.mcp.json` exists in the project root (not `~/.claude/mcp.json`). Restart Claude Code with the `--dangerously-load-development-channels server:livetap` flag.',
+    },
+  ],
+
+  limitations: [
+    'In-memory stream buffer — data does not persist across daemon restarts.',
+    'No authentication on the daemon HTTP API (localhost only, port 8788).',
+    'Tested with streams up to ~50 msg/s. High-throughput streams (1000+ msg/s) may need higher cooldowns on watchers.',
+    'MQTT credentials are passed as tool parameters, not stored on disk.',
+    'Single daemon instance per port. Multiple projects can share a daemon or use different ports.',
+  ],
+
+  architectureDiagram: `Source (MQTT/WS/File) ──> Subscriber ──> StreamStore ──> Watcher Engine
+                                              |                 |
+                                              v                 v (on match)
+                                         read_stream        Channel Alert
+                                         (agent samples)    ──> Claude Code
+                                                            ──> agent acts`,
+
+  readmeSpec: {
+    audience: 'Developers and AI coding agents (Claude Code, Codex, etc.)',
+    tone: 'Direct, practical, no fluff. Show don\'t tell.',
+    sections: [
+      { id: 'tagline', notes: 'One-liner + 1 sentence expansion. No badges yet.' },
+      { id: 'hero-demo', notes: 'Both demo screenshots immediately after tagline. Use demoImages from canonical. Each with alt text and caption. This is the wow moment — show before explaining.' },
+      { id: 'quick-start', notes: 'Use npm (not bun) for quickstart — universal. npx livetap setup, then restart Claude. Explain what --dangerously-load-development-channels does using channelsExplainer. Show one example prompt AND expected outcome.' },
+      { id: 'agent-setup', notes: 'For AI agents reading this. npx livetap --llm-help pointer. Quick steps. do-not rules. After-restart workflow. Mention MCP tools auto-register on restart — no discovery step needed.' },
+      { id: 'what-it-does', notes: 'Architecture paragraph + ASCII flow diagram. Mention daemon, in-memory StreamStore, Channels API.' },
+      { id: 'source-types-and-data', notes: 'MERGED section: source types table with data shape info inline. Each row shows type, params, CLI, and how the payload looks. End with IMPORTANT: always read_stream first.' },
+      { id: 'examples', notes: 'One subsection per example from canonical data. Show user prompt + agent behavior. Include one CLI-only example (livetap tap, sip, watch sequence) for people who want to verify manually before handing to the agent.' },
+      { id: 'expression-watchers', notes: 'JSON example, ALL operators listed here (single location, not repeated), cooldown guidance, how alerts arrive as channel tags.' },
+      { id: 'cli', notes: 'Full CLI reference from canonical CLI commands. Group by function. Include all flags.' },
+      { id: 'mcp-tools', notes: 'Table of all MCP tools from canonical data.' },
+      { id: 'troubleshooting', notes: 'Top problems and solutions from canonical troubleshooting array.' },
+      { id: 'limitations', notes: 'Upfront about what this tool does NOT do. From canonical limitations array.' },
+      { id: 'config', notes: 'Daemon port, state directory, MCP config (.mcp.json), --llm-help.' },
+      { id: 'development', notes: 'Clone, install, test.' },
+      { id: 'contributing', notes: 'Brief or link to CONTRIBUTING.md.' },
+      { id: 'license', notes: 'MIT.' },
+    ],
+  },
+
+  contributingSpec: {
+    audience: 'Contributors',
+    tone: 'Concise, welcoming.',
+    sections: [
+      { id: 'setup', notes: 'Clone, bun install, bun test.' },
+      { id: 'architecture', notes: 'Brief overview, link to docs/PLAN.md for details.' },
+      { id: 'testing', notes: 'How to run tests, port ranges (28xxx), SKIP_LIVE_MQTT.' },
+      { id: 'pr-process', notes: 'Fork, branch, test, PR to v0.' },
+    ],
+  },
+}

package/src/shared/canonical/tools.ts

@@ -0,0 +1,178 @@
+/**
+ * Canonical MCP tool definitions.
+ * This is the single source of truth for all tool schemas.
+ *
+ * Consumed by:
+ *   - src/mcp/tools.ts        → tool registration + handler dispatch
+ *   - catalog-generators.ts   → --llm-help, MCP instructions
+ *   - drift detection tests   → cross-reference validation
+ */
+
+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 stream buffer.',
+    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'],
+    },
+  },
+  {
+    name: 'status',
+    description: 'Get daemon status: uptime, port, active connections and watchers count.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+]