archer-wizard 0.1.1 → 0.2.1

package/src/daemon/store.ts

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ARCHER_DIR, STATE_FILE } from './types.js';
+import type { WatchConfig } from './types.js';
+
+// ─── Ensure Directory ───────────────────────────────────────
+
+function ensureDir(): void {
+  if (!fs.existsSync(ARCHER_DIR)) {
+    fs.mkdirSync(ARCHER_DIR, { recursive: true });
+  }
+}
+
+// ─── Load Watches ───────────────────────────────────────────
+
+export function loadWatches(): WatchConfig[] {
+  try {
+    if (!fs.existsSync(STATE_FILE)) return [];
+    const raw = fs.readFileSync(STATE_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed as WatchConfig[];
+  } catch {
+    return [];
+  }
+}
+
+// ─── Save Watches (atomic write) ────────────────────────────
+
+export function saveWatches(watches: WatchConfig[]): void {
+  ensureDir();
+  const tmp = STATE_FILE + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(watches, null, 2) + '\n', 'utf-8');
+  fs.renameSync(tmp, STATE_FILE);
+}
+
+// ─── Add Watch ──────────────────────────────────────────────
+
+export function addWatch(watch: WatchConfig): WatchConfig[] {
+  const watches = loadWatches();
+  // Replace if same ID exists
+  const idx = watches.findIndex((w) => w.id === watch.id);
+  if (idx >= 0) {
+    watches[idx] = watch;
+  } else {
+    watches.push(watch);
+  }
+  saveWatches(watches);
+  return watches;
+}
+
+// ─── Remove Watch ───────────────────────────────────────────
+
+export function removeWatch(watchId: string): { watches: WatchConfig[]; removed: boolean } {
+  const watches = loadWatches();
+  const before = watches.length;
+  const filtered = watches.filter((w) => w.id !== watchId);
+  saveWatches(filtered);
+  return { watches: filtered, removed: filtered.length < before };
+}

package/src/daemon/types.ts

@@ -0,0 +1,41 @@
+// ─── Daemon Configuration ───────────────────────────────────
+
+import path from 'node:path';
+import os from 'node:os';
+
+export const DAEMON_PORT = 7481;
+export const DAEMON_HOST = '127.0.0.1';
+export const ARCHER_DIR = path.join(os.homedir(), '.archer');
+export const STATE_FILE = path.join(ARCHER_DIR, 'state.json');
+export const PID_FILE = path.join(ARCHER_DIR, 'daemon.pid');
+export const LOG_FILE = path.join(ARCHER_DIR, 'daemon.log');
+
+// ─── Watch State ────────────────────────────────────────────
+
+export interface WatchConfig {
+  id: string;
+  table: string;
+  event: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+  filter?: string;
+  webhookUrl?: string;
+  createdAt: string;           // ISO timestamp
+  supabaseUrl: string;         // needed to re-subscribe
+  supabaseKey: string;         // service role key
+}
+
+// ─── IPC Protocol ───────────────────────────────────────────
+// JSON lines over TCP. Each message is JSON + '\n'.
+// Client sends a Request, daemon responds with a Response.
+
+export type IpcRequest =
+  | { type: 'add_watch'; watch: WatchConfig }
+  | { type: 'remove_watch'; watchId: string }
+  | { type: 'list_watches' }
+  | { type: 'ping' };
+
+export type IpcResponse =
+  | { ok: true; type: 'watch_added'; watchId: string }
+  | { ok: true; type: 'watch_removed'; watchId: string }
+  | { ok: true; type: 'watch_list'; watches: WatchConfig[] }
+  | { ok: true; type: 'pong' }
+  | { ok: false; error: string };

package/src/index.ts

@@ -5,8 +5,13 @@ import 'dotenv/config';
 // ─── Mode Detection ─────────────────────────────────────────
 
 const isMcpMode = process.argv.includes('--mcp');
+const isDaemonMode = process.argv.includes('--daemon');
 
-if (isMcpMode) {
+if (isDaemonMode) {
+  // ─── Daemon Mode ──────────────────────────────────────────
+  const { startDaemonProcess } = await import('./daemon/process.js');
+  startDaemonProcess();
+} else if (isMcpMode) {
   // ─── MCP Server Mode ─────────────────────────────────────
   const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
   const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
@@ -14,13 +19,78 @@ if (isMcpMode) {
     CallToolRequestSchema,
     ListToolsRequestSchema,
   } = await import('@modelcontextprotocol/sdk/types.js');
-  const { executeWatch, WATCH_TOOL_SCHEMA } = await import('./tools/watch.js');
+  const { executeWatch, WatchInputSchema } = await import('./tools/watch.js');
+  const { executeUnwatch, UnwatchInputSchema } = await import('./tools/unwatch.js');
+  const { executeListWatches } = await import('./tools/watches.js');
+  const { ensureDaemon } = await import('./daemon/lifecycle.js');
   const { stderrReady, stderrError } = await import('./lib/ascii.js');
 
+  // Auto-start daemon if not running
+  try {
+    const { pid } = await ensureDaemon();
+    stderrReady(`daemon running (pid ${pid})`);
+  } catch {
+    stderrError('warning: could not start daemon — watches will fail');
+  }
+
+  // Read credentials from environment
+  const supabaseUrl = process.env.SUPABASE_URL ?? '';
+  const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY ?? '';
+
+  // ─── Tool Definitions ──────────────────────────────────────
+
+  const WATCH_TOOL = {
+    name: 'archer_watch',
+    description:
+      'Create a persistent real-time watch on a Supabase table. The watch survives agent session restarts. Delivers changes to a webhook URL.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        table: { type: 'string', description: 'Supabase table name to watch' },
+        event: {
+          type: 'string',
+          enum: ['INSERT', 'UPDATE', 'DELETE', '*'],
+          description: 'Database event to listen for (default: *)',
+          default: '*',
+        },
+        filter: {
+          type: 'string',
+          description: 'Optional Postgres filter e.g. "status=eq.active"',
+        },
+        webhookUrl: {
+          type: 'string',
+          description: 'URL to receive webhook POST when event fires',
+        },
+      },
+      required: ['table'],
+    },
+  };
+
+  const UNWATCH_TOOL = {
+    name: 'archer_unwatch',
+    description: 'Remove an active watch by its ID. The watch will stop listening and be deleted from persistent storage.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        watchId: { type: 'string', description: 'The watch ID returned by archer_watch' },
+      },
+      required: ['watchId'],
+    },
+  };
+
+  const WATCHES_TOOL = {
+    name: 'archer_watches',
+    description: 'List all active watches managed by the archer daemon, including their IDs, tables, events, and webhook URLs.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  };
+
   const server = new Server(
     {
       name: 'archer',
-      version: '0.1.0',
+      version: '0.2.0',
     },
     {
       capabilities: {
@@ -32,7 +102,7 @@ if (isMcpMode) {
   // Register tool listing
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
-      tools: [WATCH_TOOL_SCHEMA],
+      tools: [WATCH_TOOL, UNWATCH_TOOL, WATCHES_TOOL],
     };
   });
 
@@ -40,27 +110,46 @@ if (isMcpMode) {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
 
-    if (name === 'archer_watch') {
-      const result = executeWatch(args);
+    try {
+      let resultText: string;
+
+      switch (name) {
+        case 'archer_watch': {
+          const input = WatchInputSchema.parse(args);
+          resultText = await executeWatch(input, supabaseUrl, serviceRoleKey);
+          break;
+        }
+        case 'archer_unwatch': {
+          const input = UnwatchInputSchema.parse(args);
+          resultText = await executeUnwatch(input);
+          break;
+        }
+        case 'archer_watches': {
+          resultText = await executeListWatches();
+          break;
+        }
+        default:
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: JSON.stringify({ error: `unknown tool: ${name}` }),
+              },
+            ],
+            isError: true,
+          };
+      }
+
       return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
+        content: [{ type: 'text' as const, text: resultText }],
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: 'text' as const, text: `❌ Error: ${message}` }],
+        isError: true,
       };
     }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ error: `unknown tool: ${name}` }),
-        },
-      ],
-      isError: true,
-    };
   });
 
   // Start server

package/src/lib/ascii.ts

@@ -11,54 +11,19 @@ const emeraldDim = colors.dim;
 
 export function showAsciiArt(): void {
   const lines = [
-    '█████╗ ██████╗  ██████╗██╗  ██╗███████╗██████╗ ',
-    '██╔══██╗██╔══██╗██╔════╝██║  ██║██╔════╝██╔══██╗',
-    '███████║██████╔╝██║     ███████║█████╗  ██████╔╝',
-    '██╔══██║██╔══██╗██║     ██╔══██║██╔══╝  ██╔══██╗',
-    '██║  ██║██║  ██║╚██████╗██║  ██║███████╗██║  ██║',
-    '╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝',
+    '',
+    '   █████╗ ██████╗  ██████╗██╗  ██╗███████╗██████╗ ',
+    '  ██╔══██╗██╔══██╗██╔════╝██║  ██║██╔════╝██╔══██╗',
+    '  ███████║██████╔╝██║     ███████║█████╗  ██████╔╝',
+    '  ██╔══██║██╔══██╗██║     ██╔══██║██╔══╝  ██╔══██╗',
+    '  ██║  ██║██║  ██║╚██████╗██║  ██║███████╗██║  ██║',
+    '  ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝',
+    '',
   ];
 
-  // Column boundaries for coloring:
-  // A: cols 0-5, R: 6-13, C: 14-21, H: 22-29, E: 30-37, R: 38-45
-  // ARCH = white, ER = emerald green
-  const archEnd = 30; // columns 0-29 are A R C H
-  const erEnd = 46;   // columns 30-45 are E R
-
   for (const line of lines) {
-    const archPart = line.slice(0, archEnd);
-    const erPart = line.slice(archEnd, erEnd);
-    const rest = line.slice(erEnd);
-    process.stdout.write(colors.white(archPart) + emerald(erPart) + rest + '\n');
+    console.log(emerald(line));
   }
-
-  // Pixel art bow and arrow (emerald green)
-  const bowArrow = [
-    `        ${emerald('╭───╮')}`,
-    `       ${emerald('╱')}   ${emerald('╲')}`,
-    `      ${emerald('╱')}     ${emerald('╲')}`,
-    `     ${emerald('╱')}       ${emerald('╲')}`,
-    `    ${emerald('╱')}         ${emerald('╲')}`,
-    `   ${emerald('╱')}           ${emerald('╲')}`,
-    `  ${emerald('╱')}             ${emerald('╲')}`,
-    ` ${emerald('╱')}               ${emerald('╲')}`,
-    `${emerald('╱')}                 ${emerald('╲')}`,
-    ` ${emerald('╲')}               ${emerald('╱')}`,
-    `  ${emerald('╲')}             ${emerald('╱')}`,
-    `   ${emerald('╲')}           ${emerald('╱')}`,
-    `    ${emerald('╲')}         ${emerald('╱')}`,
-    `     ${emerald('╲')}       ${emerald('╱')}`,
-    `      ${emerald('╲')}     ${emerald('╱')}`,
-    `       ${emerald('╲')}   ${emerald('╱')}`,
-    `        ${emerald('╰───╯')}`,
-    `          ${emerald('───►')}`,
-  ];
-  
-  console.log();
-  bowArrow.forEach(line => console.log(line));
-  console.log();
-  console.log(emeraldDim('  v0.1.0  ·  event intelligence for AI agents'));
-  console.log();
 }
 
 // ─── Status Logger ──────────────────────────────────────────

package/src/tools/unwatch.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { sendCommand } from '../daemon/client.js';
+
+// ─── Input Schema ───────────────────────────────────────────
+
+export const UnwatchInputSchema = z.object({
+  watchId: z.string().min(1, 'watchId is required'),
+});
+
+export type UnwatchInput = z.infer<typeof UnwatchInputSchema>;
+
+// ─── Execute Unwatch (via daemon IPC) ───────────────────────
+
+export async function executeUnwatch(input: UnwatchInput): Promise<string> {
+  try {
+    const res = await sendCommand({ type: 'remove_watch', watchId: input.watchId });
+
+    if (!res.ok) {
+      return `❌ Failed to remove watch: ${res.error}`;
+    }
+
+    return `✅ Watch removed: ${input.watchId}`;
+  } catch (err) {
+    return `❌ Daemon error: ${err instanceof Error ? err.message : String(err)}\n\nIs the archer daemon running?`;
+  }
+}

package/src/tools/watch.ts

@@ -1,223 +1,57 @@
-import crypto from 'node:crypto';
-import type { RealtimeChannel } from '@supabase/supabase-js';
-import { WatchInputSchema, type WatchInput, type WatchResult, type PostgresEvent } from '../types/index.js';
-import { createAuthChannel, createTableChannel } from '../lib/supabase.js';
-import { fireWebhook, buildWebhookPayload } from '../lib/webhook.js';
-import { stderrAction, stderrSuccess, stderrError } from '../lib/ascii.js';
-
-// ─── Active Subscriptions ───────────────────────────────────
-
-interface ActiveWatch {
-  watchId: string;
-  channel: RealtimeChannel;
-  event: string;
-  table?: string;
-  condition?: string;
-  webhookUrl: string;
-}
-
-const activeWatches = new Map<string, ActiveWatch>();
-
-// ─── Condition Evaluator ────────────────────────────────────
-
-function evaluateCondition(
-  data: Record<string, unknown>,
-  condition: string,
-): boolean {
-  // Parse: "field operator value"
-  // Supported: "ends with", "starts with", "contains", "equals"
-  const operators = ['ends with', 'starts with', 'contains', 'equals'] as const;
-
-  const conditionLower = condition.toLowerCase();
-  let matchedOperator: (typeof operators)[number] | null = null;
-  let splitIndex = -1;
-
-  for (const op of operators) {
-    const idx = conditionLower.indexOf(op);
-    if (idx !== -1) {
-      matchedOperator = op;
-      splitIndex = idx;
-      break;
-    }
-  }
-
-  if (!matchedOperator || splitIndex === -1) {
-    stderrError(`unknown condition format: "${condition}"`);
-    return true; // Pass through if condition can't be parsed
-  }
-
-  const field = condition.slice(0, splitIndex).trim();
-  const value = condition.slice(splitIndex + matchedOperator.length).trim();
-  const fieldValue = String(data[field] ?? '');
-
-  switch (matchedOperator) {
-    case 'ends with':
-      return fieldValue.endsWith(value);
-    case 'starts with':
-      return fieldValue.startsWith(value);
-    case 'contains':
-      return fieldValue.includes(value);
-    case 'equals':
-      return fieldValue === value;
-    default:
-      return true;
-  }
-}
-
-// ─── Map Event To Postgres Event ────────────────────────────
-
-function toPostgresEvent(event: string): PostgresEvent {
-  switch (event) {
-    case 'table.insert': return 'INSERT';
-    case 'table.update': return 'UPDATE';
-    case 'table.delete': return 'DELETE';
-    default: return 'INSERT';
-  }
-}
-
-// ─── Event Handler ──────────────────────────────────────────
-
-function createEventHandler(watch: ActiveWatch) {
-  return async (data: Record<string, unknown>) => {
-    stderrAction(`event received → ${watch.event}${watch.table ? ` on ${watch.table}` : ''}`);
-
-    // Apply condition filter
-    if (watch.condition && !evaluateCondition(data, watch.condition)) {
-      stderrAction(`condition not met → "${watch.condition}", skipping`);
-      return;
-    }
-
-    // Build and fire webhook
-    const payload = buildWebhookPayload(watch.watchId, watch.event, data);
-    await fireWebhook({
-      url: watch.webhookUrl,
-      payload,
-      event: watch.event,
-    });
+import { z } from 'zod';
+import { sendCommand } from '../daemon/client.js';
+import type { WatchConfig } from '../daemon/types.js';
+
+// ─── Input Schema ───────────────────────────────────────────
+
+export const WatchInputSchema = z.object({
+  table: z.string().min(1, 'table name is required'),
+  event: z.enum(['INSERT', 'UPDATE', 'DELETE', '*']).default('*'),
+  filter: z.string().optional(),
+  webhookUrl: z.string().url().optional(),
+});
+
+export type WatchInput = z.infer<typeof WatchInputSchema>;
+
+// ─── Execute Watch (via daemon IPC) ─────────────────────────
+
+export async function executeWatch(
+  input: WatchInput,
+  supabaseUrl: string,
+  serviceRoleKey: string,
+): Promise<string> {
+  const watchId = `watch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  const watch: WatchConfig = {
+    id: watchId,
+    table: input.table,
+    event: input.event,
+    filter: input.filter,
+    webhookUrl: input.webhookUrl,
+    createdAt: new Date().toISOString(),
+    supabaseUrl,
+    supabaseKey: serviceRoleKey,
   };
-}
-
-// ─── Main Watch Implementation ──────────────────────────────
-
-export function executeWatch(rawInput: unknown): WatchResult {
-  // Validate input
-  const parseResult = WatchInputSchema.safeParse(rawInput);
-  if (!parseResult.success) {
-    const errors = parseResult.error.issues.map((e) => e.message).join(', ');
-    return {
-      success: false,
-      watchId: '',
-      message: `validation failed: ${errors}`,
-      condition: null,
-    };
-  }
-
-  const input: WatchInput = parseResult.data;
-  const watchId = `watch_${crypto.randomUUID().slice(0, 8)}`;
-
-  stderrAction(`creating watch ${watchId} for ${input.event}`);
 
   try {
-    let channel: RealtimeChannel;
-
-    if (input.event === 'auth.signup') {
-      // Auth signup → watch auth.users table
-      const handler = createEventHandler({
-        watchId,
-        channel: null as unknown as RealtimeChannel,
-        event: input.event,
-        condition: input.condition,
-        webhookUrl: input.webhookUrl,
-      });
-
-      channel = createAuthChannel(watchId, handler);
-    } else {
-      // Table events → watch specific table
-      const table = input.table!;
-      const pgEvent = toPostgresEvent(input.event);
+    const res = await sendCommand({ type: 'add_watch', watch });
 
-      const handler = createEventHandler({
-        watchId,
-        channel: null as unknown as RealtimeChannel,
-        event: input.event,
-        table,
-        condition: input.condition,
-        webhookUrl: input.webhookUrl,
-      });
-
-      channel = createTableChannel(watchId, table, pgEvent, handler);
+    if (!res.ok) {
+      return `❌ Failed to add watch: ${res.error}`;
     }
 
-    // Store active watch
-    const watch: ActiveWatch = {
-      watchId,
-      channel,
-      event: input.event,
-      table: input.table,
-      condition: input.condition,
-      webhookUrl: input.webhookUrl,
-    };
-
-    activeWatches.set(watchId, watch);
+    const parts = [
+      `✅ Watch created: ${watchId}`,
+      `   table: ${input.table}`,
+      `   event: ${input.event}`,
+    ];
 
-    const tableInfo = input.table ? ` on table "${input.table}"` : '';
-    const conditionInfo = input.condition ? ` where ${input.condition}` : '';
-    const message = `watching ${input.event}${tableInfo}${conditionInfo} → ${input.webhookUrl}`;
+    if (input.filter) parts.push(`   filter: ${input.filter}`);
+    if (input.webhookUrl) parts.push(`   webhook: ${input.webhookUrl}`);
+    parts.push(`   status: subscribed via daemon (persistent)`);
 
-    stderrSuccess(message);
-
-    return {
-      success: true,
-      watchId,
-      message,
-      condition: input.condition ?? null,
-    };
+    return parts.join('\n');
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    stderrError(`watch failed: ${message}`);
-
-    return {
-      success: false,
-      watchId,
-      message: `watch failed: ${message}`,
-      condition: input.condition ?? null,
-    };
+    return `❌ Daemon error: ${err instanceof Error ? err.message : String(err)}\n\nIs the archer daemon running? Try restarting with: npx archer-wizard@latest --daemon`;
   }
 }
-
-// ─── Tool Schema (for MCP registration) ─────────────────────
-
-export const WATCH_TOOL_SCHEMA = {
-  name: 'archer_watch',
-  description:
-    'Archer is the event intelligence layer for AI agents. Watch real-time events from data sources. Monitors auth signups, table inserts, updates, and deletes. Fires a webhook when conditions are met. Agents stop waiting for you to talk to them and start acting on their own when the world moves.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      source: {
-        type: 'string' as const,
-        enum: ['supabase'],
-        description: 'Event source (currently only "supabase")',
-      },
-      event: {
-        type: 'string' as const,
-        enum: ['auth.signup', 'table.insert', 'table.update', 'table.delete'],
-        description: 'Event type to watch for',
-      },
-      table: {
-        type: 'string' as const,
-        description: 'Table name (required for table.* events)',
-      },
-      condition: {
-        type: 'string' as const,
-        description:
-          'Optional filter like "email ends with @gmail.com". Supports: ends with, starts with, contains, equals',
-      },
-      webhookUrl: {
-        type: 'string' as const,
-        description: 'URL to receive POST notifications when events match',
-      },
-    },
-    required: ['source', 'event', 'webhookUrl'],
-  },
-};

package/src/tools/watches.ts

@@ -0,0 +1,37 @@
+import { sendCommand } from '../daemon/client.js';
+
+// ─── Execute List Watches (via daemon IPC) ──────────────────
+
+export async function executeListWatches(): Promise<string> {
+  try {
+    const res = await sendCommand({ type: 'list_watches' });
+
+    if (!res.ok) {
+      return `❌ Failed to list watches: ${res.error}`;
+    }
+
+    if (res.type !== 'watch_list') {
+      return `❌ Unexpected response type: ${res.type}`;
+    }
+
+    if (res.watches.length === 0) {
+      return '📭 No active watches.';
+    }
+
+    const lines = [`📋 Active watches (${res.watches.length}):\n`];
+
+    for (const w of res.watches) {
+      lines.push(`  🔹 ${w.id}`);
+      lines.push(`     table: ${w.table}`);
+      lines.push(`     event: ${w.event}`);
+      if (w.filter) lines.push(`     filter: ${w.filter}`);
+      if (w.webhookUrl) lines.push(`     webhook: ${w.webhookUrl}`);
+      lines.push(`     created: ${w.createdAt}`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  } catch (err) {
+    return `❌ Daemon error: ${err instanceof Error ? err.message : String(err)}\n\nIs the archer daemon running?`;
+  }
+}