@ebowwa/osascript 1.1.0

package/src/mcp/events.ts

@@ -0,0 +1,468 @@
+/**
+ * Action Events System for osascript MCP
+ *
+ * Provides:
+ * - Completion callbacks for AppleScript commands
+ * - System event monitoring (keystrokes, apps, windows)
+ * - Webhook integration for external automation
+ * - MCP lifecycle hooks integration
+ */
+
+import { spawn, ChildProcess } from "child_process";
+import { EventEmitter } from "events";
+
+// ==============
+// Types
+// ==============
+
+export interface ActionEvent {
+  id: string;
+  type: EventType;
+  timestamp: number;
+  source: string;
+  data: Record<string, any>;
+  success: boolean;
+  error?: string;
+}
+
+export type EventType =
+  | "keystroke"
+  | "keycode"
+  | "app_launch"
+  | "app_quit"
+  | "app_activate"
+  | "window_change"
+  | "clipboard_change"
+  | "volume_change"
+  | "display_change"
+  | "script_complete"
+  | "script_error"
+  | "webhook_sent"
+  | "lifecycle_start"
+  | "lifecycle_end"
+  | "lifecycle_tool_use";
+
+export interface EventListener {
+  id: string;
+  eventType: EventType | "*";
+  active: boolean;
+  webhookUrl?: string;
+  filter?: (event: ActionEvent) => boolean;
+  callback?: (event: ActionEvent) => void | Promise<void>;
+}
+
+export interface WebhookConfig {
+  url: string;
+  method?: "POST" | "PUT";
+  headers?: Record<string, string>;
+  timeout?: number;
+  retries?: number;
+}
+
+export interface KeystrokeMonitorConfig {
+  captureKeys: boolean;
+  captureModifiers: boolean;
+  targetApp?: string;
+  excludeApps?: string[];
+}
+
+// ==============
+// Event Bus
+// ==============
+
+class ActionEventBus extends EventEmitter {
+  private listeners: Map<string, EventListener> = new Map();
+  private eventHistory: ActionEvent[] = [];
+  private maxHistorySize: number = 1000;
+  private monitors: Map<string, ChildProcess> = new Map();
+
+  emit(event: ActionEvent): boolean {
+    // Store in history
+    this.eventHistory.push(event);
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift();
+    }
+
+    // Notify all matching listeners
+    for (const [id, listener] of this.listeners) {
+      if (!listener.active) continue;
+      if (listener.eventType !== "*" && listener.eventType !== event.type) continue;
+      if (listener.filter && !listener.filter(event)) continue;
+
+      // Call local callback
+      if (listener.callback) {
+        Promise.resolve(listener.callback(event)).catch(console.error);
+      }
+
+      // Send webhook
+      if (listener.webhookUrl) {
+        this.sendWebhook(listener.webhookUrl, event).catch(console.error);
+      }
+    }
+
+    return super.emit(event.type, event);
+  }
+
+  addListener(listener: EventListener): void {
+    this.listeners.set(listener.id, listener);
+  }
+
+  removeListener(id: string): boolean {
+    return this.listeners.delete(id);
+  }
+
+  getListeners(): EventListener[] {
+    return Array.from(this.listeners.values());
+  }
+
+  getHistory(since?: number, type?: EventType): ActionEvent[] {
+    let events = this.eventHistory;
+    if (since) {
+      events = events.filter((e) => e.timestamp >= since);
+    }
+    if (type) {
+      events = events.filter((e) => e.type === type);
+    }
+    return events;
+  }
+
+  clearHistory(): void {
+    this.eventHistory = [];
+  }
+
+  async sendWebhook(url: string, event: ActionEvent, config?: WebhookConfig): Promise<boolean> {
+    const retries = config?.retries || 3;
+    const timeout = config?.timeout || 5000;
+
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        const response = await fetch(url, {
+          method: config?.method || "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config?.headers,
+          },
+          body: JSON.stringify(event),
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (response.ok) {
+          return true;
+        }
+      } catch (error) {
+        if (attempt === retries - 1) {
+          console.error(`Webhook failed after ${retries} attempts:`, error);
+        }
+      }
+    }
+    return false;
+  }
+
+  addMonitor(id: string, process: ChildProcess): void {
+    this.monitors.set(id, process);
+  }
+
+  removeMonitor(id: string): void {
+    const proc = this.monitors.get(id);
+    if (proc) {
+      proc.kill();
+      this.monitors.delete(id);
+    }
+  }
+
+  stopAllMonitors(): void {
+    for (const [id, proc] of this.monitors) {
+      proc.kill();
+    }
+    this.monitors.clear();
+  }
+}
+
+// Global event bus instance
+export const eventBus = new ActionEventBus();
+
+// ==============
+// Event Generators
+// ==============
+
+let eventCounter = 0;
+
+function generateEventId(): string {
+  return `evt_${Date.now()}_${++eventCounter}`;
+}
+
+export function createEvent(
+  type: EventType,
+  source: string,
+  data: Record<string, any>,
+  success: boolean = true,
+  error?: string
+): ActionEvent {
+  return {
+    id: generateEventId(),
+    type,
+    timestamp: Date.now(),
+    source,
+    data,
+    success,
+    error,
+  };
+}
+
+// ==============
+// Monitoring Functions
+// ==============
+
+/**
+ * Start monitoring keystrokes (requires accessibility permissions)
+ */
+export async function startKeystrokeMonitor(config: KeystrokeMonitorConfig = {
+  captureKeys: true,
+  captureModifiers: true,
+}): Promise<string> {
+  const monitorId = `keystroke_${Date.now()}`;
+
+  // AppleScript to monitor keystrokes via System Events
+  const script = `
+    tell application "System Events"
+      set lastKey to ""
+      repeat
+        try
+          -- This is a polling approach; real keylogging requires more permissions
+          -- For MCP purposes, we track when we send keystrokes, not passive monitoring
+          delay 0.1
+        end try
+      end repeat
+    end tell
+  `;
+
+  // Note: Passive keystroke monitoring requires accessibility permissions
+  // and is restricted by macOS. We'll emit events for our own keystroke actions.
+
+  return monitorId;
+}
+
+/**
+ * Start monitoring application changes
+ */
+export async function startAppMonitor(): Promise<string> {
+  const monitorId = `app_${Date.now()}`;
+
+  // Create a background process to monitor app changes
+  const script = `
+    set lastApp to ""
+    repeat
+      tell application "System Events"
+        set currentApp to name of first process whose frontmost is true
+      end tell
+      if currentApp is not lastApp then
+        do shell script "echo " & quoted form of currentApp
+        set lastApp to currentApp
+      end if
+      delay 0.5
+    end repeat
+  `;
+
+  const proc = spawn("osascript", ["-e", script]);
+  eventBus.addMonitor(monitorId, proc);
+
+  proc.stdout?.on("data", (data) => {
+    const appName = data.toString().trim();
+    eventBus.emit(createEvent("app_activate", "app_monitor", { appName }));
+  });
+
+  proc.stderr?.on("data", (data) => {
+    console.error(`App monitor error: ${data}`);
+  });
+
+  proc.on("close", () => {
+    eventBus.removeMonitor(monitorId);
+  });
+
+  return monitorId;
+}
+
+/**
+ * Start monitoring clipboard changes
+ */
+export async function startClipboardMonitor(): Promise<string> {
+  const monitorId = `clipboard_${Date.now()}`;
+
+  const script = `
+    set lastClipboard to the clipboard as text
+    repeat
+      delay 0.5
+      try
+        set currentClipboard to the clipboard as text
+        if currentClipboard is not lastClipboard then
+          do shell script "echo CLIPBOARD_CHANGED"
+          set lastClipboard to currentClipboard
+        end if
+      end try
+    end repeat
+  `;
+
+  const proc = spawn("osascript", ["-e", script]);
+  eventBus.addMonitor(monitorId, proc);
+
+  proc.stdout?.on("data", (data) => {
+    if (data.toString().includes("CLIPBOARD_CHANGED")) {
+      eventBus.emit(createEvent("clipboard_change", "clipboard_monitor", {}));
+    }
+  });
+
+  proc.stderr?.on("data", (data) => {
+    console.error(`Clipboard monitor error: ${data}`);
+  });
+
+  proc.on("close", () => {
+    eventBus.removeMonitor(monitorId);
+  });
+
+  return monitorId;
+}
+
+/**
+ * Stop a specific monitor
+ */
+export function stopMonitor(monitorId: string): boolean {
+  eventBus.removeMonitor(monitorId);
+  return true;
+}
+
+/**
+ * Stop all active monitors
+ */
+export function stopAllMonitors(): void {
+  eventBus.stopAllMonitors();
+}
+
+// ==============
+// Event Listener Management
+// ==============
+
+export function registerEventListener(
+  eventType: EventType | "*",
+  options: {
+    webhookUrl?: string;
+    callback?: (event: ActionEvent) => void | Promise<void>;
+    filter?: (event: ActionEvent) => boolean;
+  } = {}
+): string {
+  const listenerId = `listener_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+  eventBus.addListener({
+    id: listenerId,
+    eventType,
+    active: true,
+    webhookUrl: options.webhookUrl,
+    callback: options.callback,
+    filter: options.filter,
+  });
+
+  return listenerId;
+}
+
+export function unregisterEventListener(listenerId: string): boolean {
+  return eventBus.removeListener(listenerId);
+}
+
+export function listEventListeners(): EventListener[] {
+  return eventBus.getListeners();
+}
+
+export function toggleListener(listenerId: string, active: boolean): boolean {
+  const listeners = eventBus.getListeners();
+  const listener = listeners.find((l) => l.id === listenerId);
+  if (listener) {
+    listener.active = active;
+    return true;
+  }
+  return false;
+}
+
+// ==============
+// Event History
+// ==============
+
+export function getEventHistory(since?: number, type?: EventType): ActionEvent[] {
+  return eventBus.getHistory(since, type);
+}
+
+export function clearEventHistory(): void {
+  eventBus.clearHistory();
+}
+
+// ==============
+// Webhook Integration
+// ==============
+
+export async function sendEventWebhook(
+  url: string,
+  event: ActionEvent,
+  config?: WebhookConfig
+): Promise<{ success: boolean; error?: string }> {
+  const success = await eventBus.sendWebhook(url, event, config);
+  return { success, error: success ? undefined : "Webhook delivery failed" };
+}
+
+// ==============
+// MCP Lifecycle Integration
+// ==============
+
+export interface MCPLifecycleEvent {
+  sessionId?: string;
+  toolName?: string;
+  action: "start" | "end" | "tool_use" | "tool_result";
+  metadata?: Record<string, any>;
+}
+
+export function emitLifecycleEvent(lifecycleEvent: MCPLifecycleEvent): ActionEvent {
+  const eventType: EventType = `lifecycle_${lifecycleEvent.action}` as EventType;
+  const event = createEvent(eventType, "mcp_lifecycle", {
+    sessionId: lifecycleEvent.sessionId,
+    toolName: lifecycleEvent.toolName,
+    metadata: lifecycleEvent.metadata,
+  });
+  eventBus.emit(event);
+  return event;
+}
+
+// ==============
+// Convenience: Emit event after action
+// ==============
+
+export function withEvent<T>(
+  type: EventType,
+  source: string,
+  action: () => T | Promise<T>
+): Promise<{ result: T; event: ActionEvent }> {
+  return Promise.resolve(action())
+    .then((result) => {
+      const event = createEvent(type, source, { result }, true);
+      eventBus.emit(event);
+      return { result, event };
+    })
+    .catch((error) => {
+      const event = createEvent(type, source, {}, false, error.message);
+      eventBus.emit(event);
+      throw error;
+    });
+}
+
+// ==============
+// Export active monitor count
+// ==============
+
+export function getActiveMonitorCount(): number {
+  return eventBus["monitors"].size;
+}
+
+export function getActiveListenerCount(): number {
+  return eventBus.getListeners().filter((l) => l.active).length;
+}