vellum 0.2.1 → 0.2.2

package/src/tools/watcher/create.ts

@@ -1,110 +1,64 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { createWatcher } from '../../watcher/watcher-store.js';
 import { getWatcherProvider, listWatcherProviders } from '../../watcher/provider-registry.js';
 
-class WatcherCreateTool implements Tool {
-  name = 'watcher_create';
-  description = 'Create a new watcher that polls an external service for events and processes them with an action prompt';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Medium;
+export async function executeWatcherCreate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const name = input.name as string;
+  const providerId = input.provider as string;
+  const actionPrompt = input.action_prompt as string;
+  const pollIntervalMs = (input.poll_interval_ms as number) ?? undefined;
+  const config = input.config as Record<string, unknown> | undefined;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'A human-readable name for this watcher (e.g. "My Gmail")',
-          },
-          provider: {
-            type: 'string',
-            description: 'The provider to poll (e.g. "gmail")',
-          },
-          action_prompt: {
-            type: 'string',
-            description: 'Instructions for the LLM on how to handle detected events. This prompt is sent along with event data to a background conversation.',
-          },
-          poll_interval_ms: {
-            type: 'number',
-            description: 'How often to poll in milliseconds. Defaults to 60000 (1 minute). Minimum 15000.',
-          },
-          credential_service: {
-            type: 'string',
-            description: 'Override the credential service to use. Defaults to the provider\'s required service.',
-          },
-          config: {
-            type: 'object',
-            description: 'Provider-specific configuration (e.g. filter criteria)',
-          },
-        },
-        required: ['name', 'provider', 'action_prompt'],
-      },
-    };
+  if (!name || typeof name !== 'string') {
+    return { content: 'Error: name is required and must be a string', isError: true };
+  }
+  if (!providerId || typeof providerId !== 'string') {
+    return { content: 'Error: provider is required and must be a string', isError: true };
+  }
+  if (!actionPrompt || typeof actionPrompt !== 'string') {
+    return { content: 'Error: action_prompt is required and must be a string', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const name = input.name as string;
-    const providerId = input.provider as string;
-    const actionPrompt = input.action_prompt as string;
-    const pollIntervalMs = (input.poll_interval_ms as number) ?? undefined;
-    const config = input.config as Record<string, unknown> | undefined;
-
-    if (!name || typeof name !== 'string') {
-      return { content: 'Error: name is required and must be a string', isError: true };
-    }
-    if (!providerId || typeof providerId !== 'string') {
-      return { content: 'Error: provider is required and must be a string', isError: true };
-    }
-    if (!actionPrompt || typeof actionPrompt !== 'string') {
-      return { content: 'Error: action_prompt is required and must be a string', isError: true };
-    }
-
-    const provider = getWatcherProvider(providerId);
-    if (!provider) {
-      const available = listWatcherProviders().map((p) => p.id).join(', ') || 'none';
-      return { content: `Error: Unknown provider "${providerId}". Available: ${available}`, isError: true };
-    }
+  const provider = getWatcherProvider(providerId);
+  if (!provider) {
+    const available = listWatcherProviders().map((p) => p.id).join(', ') || 'none';
+    return { content: `Error: Unknown provider "${providerId}". Available: ${available}`, isError: true };
+  }
 
-    if (pollIntervalMs !== undefined && pollIntervalMs < 15000) {
-      return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
-    }
+  if (pollIntervalMs !== undefined && pollIntervalMs < 15000) {
+    return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
+  }
 
-    const credentialService = (input.credential_service as string) ?? provider.requiredCredentialService;
+  const credentialService = (input.credential_service as string) ?? provider.requiredCredentialService;
 
-    try {
-      const watcher = createWatcher({
-        name,
-        providerId,
-        actionPrompt,
-        credentialService,
-        pollIntervalMs,
-        configJson: config ? JSON.stringify(config) : null,
-      });
+  try {
+    const watcher = createWatcher({
+      name,
+      providerId,
+      actionPrompt,
+      credentialService,
+      pollIntervalMs,
+      configJson: config ? JSON.stringify(config) : null,
+    });
 
-      const intervalSec = Math.round(watcher.pollIntervalMs / 1000);
-      return {
-        content: [
-          'Watcher created successfully.',
-          `  Name: ${watcher.name}`,
-          `  Provider: ${provider.displayName}`,
-          `  Poll interval: ${intervalSec}s`,
-          `  Credential: ${watcher.credentialService}`,
-          `  Status: ${watcher.status}`,
-          `  ID: ${watcher.id}`,
-        ].join('\n'),
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error creating watcher: ${msg}`, isError: true };
-    }
+    const intervalSec = Math.round(watcher.pollIntervalMs / 1000);
+    return {
+      content: [
+        'Watcher created successfully.',
+        `  Name: ${watcher.name}`,
+        `  Provider: ${provider.displayName}`,
+        `  Poll interval: ${intervalSec}s`,
+        `  Credential: ${watcher.credentialService}`,
+        `  Status: ${watcher.status}`,
+        `  ID: ${watcher.id}`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error creating watcher: ${msg}`, isError: true };
   }
 }
-
-registerTool(new WatcherCreateTool());

package/src/tools/watcher/delete.ts

@@ -1,53 +1,27 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { getWatcher, deleteWatcher } from '../../watcher/watcher-store.js';
 
-class WatcherDeleteTool implements Tool {
-  name = 'watcher_delete';
-  description = 'Delete a watcher and all its event history';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'The ID of the watcher to delete',
-          },
-        },
-        required: ['watcher_id'],
-      },
-    };
+export async function executeWatcherDelete(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string;
+  if (!watcherId || typeof watcherId !== 'string') {
+    return { content: 'Error: watcher_id is required', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string;
-    if (!watcherId || typeof watcherId !== 'string') {
-      return { content: 'Error: watcher_id is required', isError: true };
-    }
-
-    const watcher = getWatcher(watcherId);
-    if (!watcher) {
-      return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
-    }
-
-    const deleted = deleteWatcher(watcherId);
-    if (!deleted) {
-      return { content: `Error: Failed to delete watcher: ${watcherId}`, isError: true };
-    }
+  const watcher = getWatcher(watcherId);
+  if (!watcher) {
+    return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
+  }
 
-    return {
-      content: `Watcher deleted: "${watcher.name}"`,
-      isError: false,
-    };
+  const deleted = deleteWatcher(watcherId);
+  if (!deleted) {
+    return { content: `Error: Failed to delete watcher: ${watcherId}`, isError: true };
   }
-}
 
-registerTool(new WatcherDeleteTool());
+  return {
+    content: `Watcher deleted: "${watcher.name}"`,
+    isError: false,
+  };
+}

package/src/tools/watcher/digest.ts

@@ -1,84 +1,50 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { listWatchers, listWatcherEvents } from '../../watcher/watcher-store.js';
 
-class WatcherDigestTool implements Tool {
-  name = 'watcher_digest';
-  description = 'Get a summary of recent watcher activity. Use this when the user asks about what happened with their email, notifications, etc.';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Low;
+export async function executeWatcherDigest(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string | undefined;
+  const hours = (input.hours as number) ?? 24;
+  const limit = (input.limit as number) ?? 50;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'Filter to events from a specific watcher. If omitted, shows events from all watchers.',
-          },
-          hours: {
-            type: 'number',
-            description: 'How many hours back to look. Defaults to 24.',
-          },
-          limit: {
-            type: 'number',
-            description: 'Maximum number of events to return. Defaults to 50.',
-          },
-        },
-        required: [],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string | undefined;
-    const hours = (input.hours as number) ?? 24;
-    const limit = (input.limit as number) ?? 50;
-
-    const since = Date.now() - hours * 60 * 60 * 1000;
+  const since = Date.now() - hours * 60 * 60 * 1000;
 
-    const events = listWatcherEvents({ watcherId, limit, since });
+  const events = listWatcherEvents({ watcherId, limit, since });
 
-    if (events.length === 0) {
-      const period = hours === 24 ? 'today' : `the last ${hours} hours`;
-      return { content: `No watcher events detected ${period}.`, isError: false };
-    }
+  if (events.length === 0) {
+    const period = hours === 24 ? 'today' : `the last ${hours} hours`;
+    return { content: `No watcher events detected ${period}.`, isError: false };
+  }
 
-    // Group events by watcher
-    const watcherMap = new Map<string, typeof events>();
-    for (const event of events) {
-      const existing = watcherMap.get(event.watcherId) ?? [];
-      existing.push(event);
-      watcherMap.set(event.watcherId, existing);
-    }
+  // Group events by watcher
+  const watcherMap = new Map<string, typeof events>();
+  for (const event of events) {
+    const existing = watcherMap.get(event.watcherId) ?? [];
+    existing.push(event);
+    watcherMap.set(event.watcherId, existing);
+  }
 
-    // Get watcher names
-    const allWatchers = listWatchers();
-    const nameMap = new Map(allWatchers.map((w) => [w.id, w.name]));
+  // Get watcher names
+  const allWatchers = listWatchers();
+  const nameMap = new Map(allWatchers.map((w) => [w.id, w.name]));
 
-    const lines = [`Watcher activity (last ${hours}h, ${events.length} events):`];
+  const lines = [`Watcher activity (last ${hours}h, ${events.length} events):`];
 
-    for (const [wId, wEvents] of watcherMap) {
-      const name = nameMap.get(wId) ?? wId;
-      lines.push('', `${name} (${wEvents.length} events):`);
+  for (const [wId, wEvents] of watcherMap) {
+    const name = nameMap.get(wId) ?? wId;
+    lines.push('', `${name} (${wEvents.length} events):`);
 
-      for (const event of wEvents) {
-        const time = new Date(event.createdAt).toLocaleString();
-        const disposition = event.disposition !== 'pending' ? ` [${event.disposition}]` : '';
-        lines.push(`  - ${event.summary}${disposition} (${time})`);
-        if (event.llmAction) {
-          lines.push(`    Action: ${event.llmAction}`);
-        }
+    for (const event of wEvents) {
+      const time = new Date(event.createdAt).toLocaleString();
+      const disposition = event.disposition !== 'pending' ? ` [${event.disposition}]` : '';
+      lines.push(`  - ${event.summary}${disposition} (${time})`);
+      if (event.llmAction) {
+        lines.push(`    Action: ${event.llmAction}`);
       }
     }
-
-    return { content: lines.join('\n'), isError: false };
   }
-}
 
-registerTool(new WatcherDigestTool());
+  return { content: lines.join('\n'), isError: false };
+}

package/src/tools/watcher/list.ts

@@ -1,90 +1,60 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { listWatchers, getWatcher, listWatcherEvents } from '../../watcher/watcher-store.js';
 
-class WatcherListTool implements Tool {
-  name = 'watcher_list';
-  description = 'List all watchers with their status, or show details for a specific watcher';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'If provided, show detailed info for this specific watcher including recent events.',
-          },
-          enabled_only: {
-            type: 'boolean',
-            description: 'When true, only show enabled watchers. Defaults to false.',
-          },
-        },
-        required: [],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string | undefined;
-    const enabledOnly = (input.enabled_only as boolean) ?? false;
-
-    if (watcherId) {
-      const watcher = getWatcher(watcherId);
-      if (!watcher) {
-        return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
-      }
-
-      const events = listWatcherEvents({ watcherId, limit: 10 });
-      const lines = [
-        `Watcher: ${watcher.name}`,
-        `  ID: ${watcher.id}`,
-        `  Provider: ${watcher.providerId}`,
-        `  Status: ${watcher.status}`,
-        `  Enabled: ${watcher.enabled}`,
-        `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
-        `  Credential: ${watcher.credentialService}`,
-        `  Last poll: ${watcher.lastPollAt ? new Date(watcher.lastPollAt).toLocaleString() : 'never'}`,
-        `  Next poll: ${watcher.nextPollAt ? new Date(watcher.nextPollAt).toLocaleString() : 'n/a'}`,
-        `  Errors: ${watcher.consecutiveErrors}`,
-      ];
-
-      if (watcher.lastError) {
-        lines.push(`  Last error: ${watcher.lastError}`);
-      }
-
-      if (events.length > 0) {
-        lines.push('', `Recent events (${events.length}):`);
-        for (const event of events) {
-          lines.push(`  - [${event.disposition}] ${event.summary} (${new Date(event.createdAt).toLocaleString()})`);
-        }
-      } else {
-        lines.push('', 'No events detected yet.');
-      }
-
-      return { content: lines.join('\n'), isError: false };
+export async function executeWatcherList(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string | undefined;
+  const enabledOnly = (input.enabled_only as boolean) ?? false;
+
+  if (watcherId) {
+    const watcher = getWatcher(watcherId);
+    if (!watcher) {
+      return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
     }
 
-    const allWatchers = listWatchers({ enabledOnly });
-    if (allWatchers.length === 0) {
-      return { content: 'No watchers found.', isError: false };
+    const events = listWatcherEvents({ watcherId, limit: 10 });
+    const lines = [
+      `Watcher: ${watcher.name}`,
+      `  ID: ${watcher.id}`,
+      `  Provider: ${watcher.providerId}`,
+      `  Status: ${watcher.status}`,
+      `  Enabled: ${watcher.enabled}`,
+      `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
+      `  Credential: ${watcher.credentialService}`,
+      `  Last poll: ${watcher.lastPollAt ? new Date(watcher.lastPollAt).toLocaleString() : 'never'}`,
+      `  Next poll: ${watcher.nextPollAt ? new Date(watcher.nextPollAt).toLocaleString() : 'n/a'}`,
+      `  Errors: ${watcher.consecutiveErrors}`,
+    ];
+
+    if (watcher.lastError) {
+      lines.push(`  Last error: ${watcher.lastError}`);
     }
 
-    const lines = [`Watchers (${allWatchers.length}):`];
-    for (const w of allWatchers) {
-      const status = w.enabled ? w.status : 'disabled';
-      const lastPoll = w.lastPollAt ? new Date(w.lastPollAt).toLocaleString() : 'never';
-      lines.push(`  - [${status}] ${w.name} (${w.providerId}) — last: ${lastPoll}`);
+    if (events.length > 0) {
+      lines.push('', `Recent events (${events.length}):`);
+      for (const event of events) {
+        lines.push(`  - [${event.disposition}] ${event.summary} (${new Date(event.createdAt).toLocaleString()})`);
+      }
+    } else {
+      lines.push('', 'No events detected yet.');
     }
 
     return { content: lines.join('\n'), isError: false };
   }
-}
 
-registerTool(new WatcherListTool());
+  const allWatchers = listWatchers({ enabledOnly });
+  if (allWatchers.length === 0) {
+    return { content: 'No watchers found.', isError: false };
+  }
+
+  const lines = [`Watchers (${allWatchers.length}):`];
+  for (const w of allWatchers) {
+    const status = w.enabled ? w.status : 'disabled';
+    const lastPoll = w.lastPollAt ? new Date(w.lastPollAt).toLocaleString() : 'never';
+    lines.push(`  - [${status}] ${w.name} (${w.providerId}) — last: ${lastPoll}`);
+  }
+
+  return { content: lines.join('\n'), isError: false };
+}

package/src/tools/watcher/update.ts

@@ -1,102 +1,56 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { updateWatcher } from '../../watcher/watcher-store.js';
 
-class WatcherUpdateTool implements Tool {
-  name = 'watcher_update';
-  description = 'Update a watcher\'s configuration (name, action prompt, interval, enabled state)';
-  category = 'watcher';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          watcher_id: {
-            type: 'string',
-            description: 'The ID of the watcher to update',
-          },
-          name: {
-            type: 'string',
-            description: 'New name for the watcher',
-          },
-          action_prompt: {
-            type: 'string',
-            description: 'New action prompt for event processing',
-          },
-          poll_interval_ms: {
-            type: 'number',
-            description: 'New poll interval in milliseconds (minimum 15000)',
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Enable or disable the watcher',
-          },
-          config: {
-            type: 'object',
-            description: 'New provider-specific configuration',
-          },
-        },
-        required: ['watcher_id'],
-      },
-    };
+export async function executeWatcherUpdate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const watcherId = input.watcher_id as string;
+  if (!watcherId || typeof watcherId !== 'string') {
+    return { content: 'Error: watcher_id is required', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const watcherId = input.watcher_id as string;
-    if (!watcherId || typeof watcherId !== 'string') {
-      return { content: 'Error: watcher_id is required', isError: true };
+  const updates: Record<string, unknown> = {};
+  if (input.name !== undefined) updates.name = input.name;
+  if (input.action_prompt !== undefined) updates.actionPrompt = input.action_prompt;
+  if (input.poll_interval_ms !== undefined) {
+    if ((input.poll_interval_ms as number) < 15000) {
+      return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
     }
+    updates.pollIntervalMs = input.poll_interval_ms;
+  }
+  if (input.enabled !== undefined) updates.enabled = input.enabled;
+  if (input.config !== undefined) updates.configJson = JSON.stringify(input.config);
 
-    const updates: Record<string, unknown> = {};
-    if (input.name !== undefined) updates.name = input.name;
-    if (input.action_prompt !== undefined) updates.actionPrompt = input.action_prompt;
-    if (input.poll_interval_ms !== undefined) {
-      if ((input.poll_interval_ms as number) < 15000) {
-        return { content: 'Error: poll_interval_ms must be at least 15000 (15 seconds)', isError: true };
-      }
-      updates.pollIntervalMs = input.poll_interval_ms;
-    }
-    if (input.enabled !== undefined) updates.enabled = input.enabled;
-    if (input.config !== undefined) updates.configJson = JSON.stringify(input.config);
+  if (Object.keys(updates).length === 0) {
+    return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  }
 
-    if (Object.keys(updates).length === 0) {
-      return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  try {
+    const watcher = updateWatcher(watcherId, updates as {
+      name?: string;
+      actionPrompt?: string;
+      pollIntervalMs?: number;
+      enabled?: boolean;
+      configJson?: string | null;
+    });
+
+    if (!watcher) {
+      return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
     }
 
-    try {
-      const watcher = updateWatcher(watcherId, updates as {
-        name?: string;
-        actionPrompt?: string;
-        pollIntervalMs?: number;
-        enabled?: boolean;
-        configJson?: string | null;
-      });
-
-      if (!watcher) {
-        return { content: `Error: Watcher not found: ${watcherId}`, isError: true };
-      }
-
-      return {
-        content: [
-          'Watcher updated successfully.',
-          `  Name: ${watcher.name}`,
-          `  Enabled: ${watcher.enabled}`,
-          `  Status: ${watcher.status}`,
-          `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
-        ].join('\n'),
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error updating watcher: ${msg}`, isError: true };
-    }
+    return {
+      content: [
+        'Watcher updated successfully.',
+        `  Name: ${watcher.name}`,
+        `  Enabled: ${watcher.enabled}`,
+        `  Status: ${watcher.status}`,
+        `  Poll interval: ${Math.round(watcher.pollIntervalMs / 1000)}s`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error updating watcher: ${msg}`, isError: true };
   }
 }
-
-registerTool(new WatcherUpdateTool());