archer-wizard 0.1.0 → 0.2.0

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

@@ -1,33 +1,29 @@
 import pc from 'picocolors';
 
+// Force colors for better visibility
+const colors = pc.createColors(true);
+
+// Use picocolors green (more compatible than true color)
+const emerald = colors.green;
+const emeraldDim = colors.dim;
+
 // ─── ASCII Art ──────────────────────────────────────────────
 
 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 = 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(pc.white(archPart) + pc.green(erPart) + rest + '\n');
+    console.log(emerald(line));
   }
-
-  console.log();
-  console.log(pc.dim('  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:
-    'Watch real-time events from Supabase. Monitors auth signups, table inserts, updates, and deletes. Fires a webhook when conditions are met.',
-  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?`;
+  }
+}

package/src/wizard/detector.ts

@@ -106,9 +106,10 @@ export function detectAgents(): AgentInfo[] {
     const configExists = fileExists(configPath);
     const dirExists = parentDirExists(configPath);
 
-    // Agent is "installed" if its parent directory exists
-    // (the config file might not exist yet)
-    if (dirExists) {
+    // Agent is "installed" if:
+    // 1. The config file exists, OR
+    // 2. The parent directory exists (for first-time setup)
+    if (configExists || dirExists) {
       detected.push({
         name: agent.name,
         installed: true,
@@ -133,19 +134,23 @@ export function getConfigKey(agentName: string): 'mcpServers' | 'mcp' {
 
 // ─── Get Rules Path For Agent ───────────────────────────────
 
-export function getRulesPath(agentName: string, cwd: string): string {
+export function getRulesPath(agentName: string): string {
+  const homeDir = os.homedir();
+  
   switch (agentName) {
     case 'cursor':
-      return path.join(cwd, '.cursor', 'rules', 'archer.mdc');
+      return path.join(homeDir, '.cursor', 'rules', 'archer.mdc');
     case 'claude-code':
-      return path.join(cwd, 'CLAUDE.md');
+      // For Claude Code, we'll use the project's CLAUDE.md
+      // but we need to get the current working directory
+      return path.join(process.cwd(), 'CLAUDE.md');
     case 'opencode':
-      return path.join(cwd, '.opencode', 'rules.md');
+      return path.join(homeDir, '.config', 'opencode', 'rules.md');
     case 'antigravity':
-      return path.join(cwd, '.antigravity', 'rules.md');
+      return path.join(homeDir, '.config', 'antigravity', 'rules.md');
     case 'windsurf':
-      return path.join(cwd, '.windsurf', 'rules.md');
+      return path.join(homeDir, '.codeium', 'windsurf', 'rules.md');
     default:
-      return path.join(cwd, '.archer', 'rules.md');
+      return path.join(homeDir, '.archer', 'rules.md');
   }
 }

package/src/wizard/index.ts

@@ -58,7 +58,7 @@ export async function runWizard(): Promise<void> {
   // ─ Step 13: Inject rules ─
   if (successfulAgents.length > 0) {
     logAction('writing agent rules...');
-    injectRules(successfulAgents, cwd);
+    injectRules(successfulAgents);
     console.log();
   }
 

package/src/wizard/injector.ts

@@ -11,7 +11,7 @@ import type { AgentInfo, InjectionResult, McpServerEntry } from '../types/index.
 function buildArcherEntry(supabaseUrl: string, serviceRoleKey: string): McpServerEntry {
   return {
     command: 'npx',
-    args: ['-y', 'archer', '--mcp'],
+    args: ['-y', 'archer-wizard@latest', '--mcp'],
     env: {
       SUPABASE_URL: supabaseUrl,
       SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,