@ebowwa/osascript 1.1.0

package/dist/mcp/stdio.js

@@ -0,0 +1,1704 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { spawn } from "child_process";
+async function executeOsascript(script, options = {}) {
+  const { language = "applescript", timeout = 30000 } = options;
+  const args = [];
+  if (language === "javascript") {
+    args.push("-l", "JavaScript");
+  }
+  args.push("-e", script);
+  return new Promise((resolve) => {
+    const proc = spawn("osascript", args, { timeout });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timer = setTimeout(() => {
+      proc.kill();
+      resolve({
+        success: false,
+        stdout: stdout.trim(),
+        stderr: "Timeout exceeded",
+        exitCode: 1
+      });
+    }, timeout);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        success: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1
+      });
+    });
+    proc.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        stdout: "",
+        stderr: error.message,
+        exitCode: 1
+      });
+    });
+  });
+}
+async function executeAppleScript(script, timeout = 30000) {
+  return executeOsascript(script, { language: "applescript", timeout });
+}
+async function executeJXA(script, timeout = 30000) {
+  return executeOsascript(script, { language: "javascript", timeout });
+}
+async function displayNotification(options) {
+  const { title = "Notification", subtitle, message, soundName } = options;
+  let script = `display notification "${escapeString(message)}"`;
+  if (title)
+    script += ` with title "${escapeString(title)}"`;
+  if (subtitle)
+    script += ` subtitle "${escapeString(subtitle)}"`;
+  if (soundName)
+    script += ` sound name "${escapeString(soundName)}"`;
+  return executeAppleScript(script);
+}
+async function displayDialog(options) {
+  const { title, message, buttons = ["OK"], defaultButton = 1, icon, givingUpAfter } = options;
+  let script = `display dialog "${escapeString(message)}"`;
+  script += ` buttons ${JSON.stringify(buttons)}`;
+  script += ` default button ${defaultButton}`;
+  if (icon)
+    script += ` with icon ${icon}`;
+  if (givingUpAfter)
+    script += ` giving up after ${givingUpAfter}`;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Dialog failed: ${result.stderr}`);
+  }
+  const buttonMatch = result.stdout.match(/button returned:(\w+)/);
+  const gaveUpMatch = result.stdout.match(/gave up:(\w+)/);
+  return {
+    buttonReturned: buttonMatch ? buttonMatch[1] : buttons[0],
+    gaveUp: gaveUpMatch ? gaveUpMatch[1] === "true" : false
+  };
+}
+async function getVolume() {
+  const script = `
+    output volume of (get volume settings) as integer
+  `;
+  const volumeResult = await executeAppleScript(script);
+  const mutedScript = `
+    output muted of (get volume settings) as boolean
+  `;
+  const mutedResult = await executeAppleScript(mutedScript);
+  return {
+    volume: parseInt(volumeResult.stdout) || 0,
+    muted: mutedResult.stdout.toLowerCase() === "true"
+  };
+}
+async function setVolume(volume, muted) {
+  const safeVolume = Math.max(0, Math.min(100, Math.round(volume)));
+  let script = `set volume output volume ${safeVolume}`;
+  if (muted !== undefined) {
+    script += muted ? " with output muted" : " without output muted";
+  }
+  return executeAppleScript(script);
+}
+async function getClipboard() {
+  const result = await executeAppleScript("the clipboard");
+  if (!result.success) {
+    throw new Error(`Failed to get clipboard: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+async function setClipboard(text) {
+  const script = `set the clipboard to "${escapeString(text)}"`;
+  return executeAppleScript(script);
+}
+async function clearClipboard() {
+  return executeAppleScript('set the clipboard to ""');
+}
+async function listRunningApplications() {
+  const script = `
+    tell application "System Events"
+      set appList to name of every process whose background only is false
+      set output to ""
+      repeat with appName in appList
+        set output to output & appName & linefeed
+      end repeat
+      return output
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Failed to list applications: ${result.stderr}`);
+  }
+  const apps = result.stdout.split(`
+`).filter((name) => name.trim()).map((name) => ({
+    name: name.trim(),
+    running: true
+  }));
+  return apps;
+}
+async function getApplicationInfo(appName) {
+  const script = `
+    tell application "System Events"
+      if exists process "${escapeString(appName)}" then
+        set theProcess to process "${escapeString(appName)}"
+        set theName to name of theProcess
+        set thePath to POSIX path of (application file of theProcess as alias)
+        set thePID to unix id of theProcess
+        set windowCount to count of windows of theProcess
+        return theName & "|" & thePath & "|" & thePID & "|" & windowCount
+      else
+        return "NOT_RUNNING"
+      end if
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success || result.stdout === "NOT_RUNNING") {
+    return {
+      name: appName,
+      running: false
+    };
+  }
+  const [name, path, pid, windowCount] = result.stdout.split("|");
+  return {
+    name,
+    path,
+    processId: parseInt(pid),
+    running: true,
+    windowCount: parseInt(windowCount)
+  };
+}
+async function activateApplication(appName) {
+  const script = `
+    tell application "${escapeString(appName)}"
+      activate
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function quitApplication(appName, force = false) {
+  let script;
+  if (force) {
+    script = `
+      tell application "System Events"
+        set theProcess to process "${escapeString(appName)}"
+        set thePID to unix id of theProcess
+        do shell script "kill -9 " & thePID
+      end tell
+    `;
+  } else {
+    script = `
+      tell application "${escapeString(appName)}"
+        quit
+      end tell
+    `;
+  }
+  return executeAppleScript(script);
+}
+async function launchApplication(appName) {
+  const script = `
+    tell application "${escapeString(appName)}"
+      launch
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function getFrontmostApplication() {
+  const script = `
+    tell application "System Events"
+      name of first process whose frontmost is true
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Failed to get frontmost app: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+async function getApplicationWindows(appName) {
+  const script = `
+    tell application "System Events"
+      tell process "${escapeString(appName)}"
+        set windowList to {}
+        repeat with theWindow in windows
+          set windowName to name of theWindow
+          set windowId to id of theWindow
+          set windowIndex to index of theWindow
+          set end of windowList to windowName & "|" & windowId & "|" & windowIndex
+        end repeat
+        return windowList as text
+      end tell
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    return [];
+  }
+  if (!result.stdout.trim()) {
+    return [];
+  }
+  const windows = result.stdout.split(", ").filter((w) => w.trim()).map((w) => {
+    const [name, id, index] = w.split("|");
+    return {
+      name: name || null,
+      id: parseInt(id) || 0,
+      index: parseInt(index) || 0
+    };
+  });
+  return windows;
+}
+async function setWindowBounds(appName, windowIndex, bounds) {
+  const script = `
+    tell application "System Events"
+      tell process "${escapeString(appName)}"
+        set position of window ${windowIndex} to {${bounds.x}, ${bounds.y}}
+        set size of window ${windowIndex} to {${bounds.width}, ${bounds.height}}
+      end tell
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function sendKeystroke(options) {
+  const { key, modifiers = [], delay = 0 } = options;
+  const modifierStr = modifiers.map((m) => m + " down").join(", ");
+  const usingStr = modifierStr ? ` using {${modifierStr}}` : "";
+  const script = `
+    tell application "System Events"
+      keystroke "${escapeString(key)}"${usingStr}
+      ${delay > 0 ? `delay ${delay}` : ""}
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function sendKeyCode(options) {
+  const { keyCode, modifiers = [] } = options;
+  const modifierStr = modifiers.map((m) => m + " down").join(", ");
+  const usingStr = modifierStr ? ` using {${modifierStr}}` : "";
+  const script = `
+    tell application "System Events"
+      key code ${keyCode}${usingStr}
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function typeText(text, delayBetweenChars = 0.01) {
+  const script = `
+    tell application "System Events"
+      keystroke "${escapeString(text)}"
+      ${delayBetweenChars > 0 ? `delay ${delayBetweenChars}` : ""}
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function getSafariURL() {
+  const script = `
+    tell application "Safari"
+      return URL of current tab of front window
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Failed to get Safari URL: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+async function setSafariURL(url) {
+  const script = `
+    tell application "Safari"
+      set URL of current tab of front window to "${escapeString(url)}"
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function getSafariTabTitles() {
+  const script = `
+    tell application "Safari"
+      set tabTitles to name of every tab of front window
+      return tabTitles as text
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    return [];
+  }
+  return result.stdout.split(", ").filter((t) => t.trim());
+}
+async function executeSafariJS(jsCode) {
+  const script = `
+    tell application "Safari"
+      do JavaScript "${escapeString(jsCode)}" in current tab of front window
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Failed to execute Safari JS: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+async function getFinderSelection() {
+  const script = `
+    tell application "Finder"
+      set selectedItems to selection
+      set output to ""
+      repeat with theItem in selectedItems
+        set itemName to name of theItem
+        set itemPath to POSIX path of (theItem as alias)
+        set itemKind to kind of theItem
+        set output to output & itemName & "|" & itemPath & "|" & itemKind & linefeed
+      end repeat
+      return output
+    end tell
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success || !result.stdout.trim()) {
+    return [];
+  }
+  return result.stdout.split(`
+`).filter((line) => line.trim()).map((line) => {
+    const [name, path, kind] = line.split("|");
+    const type = kind?.toLowerCase().includes("folder") ? "folder" : kind?.toLowerCase().includes("application") ? "application" : "file";
+    return {
+      name,
+      path,
+      type,
+      exists: true
+    };
+  });
+}
+async function openFinderWindow(path) {
+  const script = `
+    tell application "Finder"
+      activate
+      open POSIX file "${escapeString(path)}"
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function createFolder(parentPath, folderName) {
+  const script = `
+    tell application "Finder"
+      make new folder at POSIX file "${escapeString(parentPath)}" with properties {name:"${escapeString(folderName)}"}
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function moveToTrash(path) {
+  const script = `
+    tell application "Finder"
+      delete POSIX file "${escapeString(path)}"
+    end tell
+  `;
+  return executeAppleScript(script);
+}
+async function getDisplayInfo() {
+  const script = `
+    ObjC.import('Cocoa');
+    var screens = $.NSScreen.screens;
+    var count = screens.count;
+    var result = [];
+    for (var i = 0; i < count; i++) {
+      var screen = screens.objectAtIndex(i);
+      var frame = screen.frame;
+      result.push({
+        id: i,
+        width: frame.size.width,
+        height: frame.size.height,
+        main: i === 0
+      });
+    }
+    JSON.stringify(result);
+  `;
+  const result = await executeJXA(script);
+  if (!result.success) {
+    const fallbackScript = `
+      tell application "System Events"
+        set screenWidth to word 3 of (do shell script "system_profiler SPDisplaysDataType | grep Resolution")
+        set screenHeight to word 5 of (do shell script "system_profiler SPDisplaysDataType | grep Resolution")
+        return screenWidth & "x" & screenHeight
+      end tell
+    `;
+    const fallback = await executeAppleScript(fallbackScript);
+    const [width, height] = fallback.stdout.split("x").map((n) => parseInt(n));
+    return [
+      {
+        id: 0,
+        width: width || 1920,
+        height: height || 1080,
+        main: true
+      }
+    ];
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return [
+      {
+        id: 0,
+        width: 1920,
+        height: 1080,
+        main: true
+      }
+    ];
+  }
+}
+async function getScreenResolution() {
+  const displays = await getDisplayInfo();
+  const mainDisplay = displays.find((d) => d.main) || displays[0];
+  return {
+    width: mainDisplay?.width || 1920,
+    height: mainDisplay?.height || 1080
+  };
+}
+function isMacOS() {
+  return process.platform === "darwin";
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+async function sayText(text, voice, rate) {
+  let script = `say "${escapeString(text)}"`;
+  if (voice)
+    script += ` using "${voice}"`;
+  if (rate)
+    script += ` speaking rate ${rate}`;
+  return executeAppleScript(script);
+}
+async function beep(count = 1) {
+  return executeAppleScript(`beep ${count}`);
+}
+async function getSystemDateTime() {
+  const script = `
+    get current date
+  `;
+  const result = await executeAppleScript(script);
+  if (!result.success) {
+    throw new Error(`Failed to get system date: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+
+// src/mcp/events.ts
+import { spawn as spawn2 } from "child_process";
+import { EventEmitter } from "events";
+
+class ActionEventBus extends EventEmitter {
+  listeners = new Map;
+  eventHistory = [];
+  maxHistorySize = 1000;
+  monitors = new Map;
+  emit(event) {
+    this.eventHistory.push(event);
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift();
+    }
+    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;
+      if (listener.callback) {
+        Promise.resolve(listener.callback(event)).catch(console.error);
+      }
+      if (listener.webhookUrl) {
+        this.sendWebhook(listener.webhookUrl, event).catch(console.error);
+      }
+    }
+    return super.emit(event.type, event);
+  }
+  addListener(listener) {
+    this.listeners.set(listener.id, listener);
+  }
+  removeListener(id) {
+    return this.listeners.delete(id);
+  }
+  getListeners() {
+    return Array.from(this.listeners.values());
+  }
+  getHistory(since, type) {
+    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() {
+    this.eventHistory = [];
+  }
+  async sendWebhook(url, event, config) {
+    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, process2) {
+    this.monitors.set(id, process2);
+  }
+  removeMonitor(id) {
+    const proc = this.monitors.get(id);
+    if (proc) {
+      proc.kill();
+      this.monitors.delete(id);
+    }
+  }
+  stopAllMonitors() {
+    for (const [id, proc] of this.monitors) {
+      proc.kill();
+    }
+    this.monitors.clear();
+  }
+}
+var eventBus = new ActionEventBus;
+var eventCounter = 0;
+function generateEventId() {
+  return `evt_${Date.now()}_${++eventCounter}`;
+}
+function createEvent(type, source, data, success = true, error) {
+  return {
+    id: generateEventId(),
+    type,
+    timestamp: Date.now(),
+    source,
+    data,
+    success,
+    error
+  };
+}
+async function startAppMonitor() {
+  const monitorId = `app_${Date.now()}`;
+  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 = spawn2("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;
+}
+async function startClipboardMonitor() {
+  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 = spawn2("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;
+}
+function stopMonitor(monitorId) {
+  eventBus.removeMonitor(monitorId);
+  return true;
+}
+function stopAllMonitors() {
+  eventBus.stopAllMonitors();
+}
+function registerEventListener(eventType, options = {}) {
+  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;
+}
+function unregisterEventListener(listenerId) {
+  return eventBus.removeListener(listenerId);
+}
+function listEventListeners() {
+  return eventBus.getListeners();
+}
+function getEventHistory(since, type) {
+  return eventBus.getHistory(since, type);
+}
+function clearEventHistory() {
+  eventBus.clearHistory();
+}
+async function sendEventWebhook(url, event, config) {
+  const success = await eventBus.sendWebhook(url, event, config);
+  return { success, error: success ? undefined : "Webhook delivery failed" };
+}
+function getActiveMonitorCount() {
+  return eventBus["monitors"].size;
+}
+function getActiveListenerCount() {
+  return eventBus.getListeners().filter((l) => l.active).length;
+}
+
+// src/mcp/stdio.ts
+async function osascriptExecute(script, language = "applescript") {
+  const result = language === "javascript" ? await executeJXA(script) : await executeAppleScript(script);
+  return JSON.stringify(result, null, 2);
+}
+async function osascriptNotification(message, title = "Notification", subtitle, soundName) {
+  const options = { message, title, subtitle, soundName };
+  const result = await displayNotification(options);
+  return result.success ? `Notification sent: ${title}` : `Error: ${result.stderr}`;
+}
+async function osascriptDialog(message, title, buttons, defaultButton, icon) {
+  const options = { message, title, buttons, defaultButton, icon };
+  try {
+    const result = await displayDialog(options);
+    return `Button returned: ${result.buttonReturned}${result.gaveUp ? " (timed out)" : ""}`;
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}
+async function osascriptGetVolume() {
+  const info = await getVolume();
+  return `Volume: ${info.volume}%${info.muted ? " (muted)" : ""}`;
+}
+async function osascriptSetVolume(volume, muted) {
+  const result = await setVolume(volume, muted);
+  return result.success ? `Volume set to ${volume}%` : `Error: ${result.stderr}`;
+}
+async function osascriptGetClipboard() {
+  try {
+    const content = await getClipboard();
+    return content || "(clipboard is empty)";
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}
+async function osascriptSetClipboard(text) {
+  const result = await setClipboard(text);
+  return result.success ? "Clipboard updated" : `Error: ${result.stderr}`;
+}
+async function osascriptClearClipboard() {
+  const result = await clearClipboard();
+  return result.success ? "Clipboard cleared" : `Error: ${result.stderr}`;
+}
+async function osascriptListApps() {
+  const apps = await listRunningApplications();
+  const lines = ["Running Applications:", "=".repeat(40), ""];
+  for (const app of apps) {
+    lines.push(`- ${app.name}`);
+  }
+  return lines.join(`
+`);
+}
+async function osascriptGetAppInfo(appName) {
+  const info = await getApplicationInfo(appName);
+  if (!info.running) {
+    return `Application "${appName}" is not running`;
+  }
+  const lines = [
+    `Application: ${info.name}`,
+    "=".repeat(40),
+    `Running: ${info.running}`,
+    info.path ? `Path: ${info.path}` : "",
+    info.processId ? `PID: ${info.processId}` : "",
+    info.windowCount !== undefined ? `Windows: ${info.windowCount}` : ""
+  ].filter(Boolean);
+  return lines.join(`
+`);
+}
+async function osascriptActivateApp(appName) {
+  const result = await activateApplication(appName);
+  return result.success ? `Activated ${appName}` : `Error: ${result.stderr}`;
+}
+async function osascriptQuitApp(appName, force = false) {
+  const result = await quitApplication(appName, force);
+  return result.success ? `Quit ${appName}` : `Error: ${result.stderr}`;
+}
+async function osascriptLaunchApp(appName) {
+  const result = await launchApplication(appName);
+  return result.success ? `Launched ${appName}` : `Error: ${result.stderr}`;
+}
+async function osascriptGetFrontmostApp() {
+  const appName = await getFrontmostApplication();
+  return `Frontmost application: ${appName}`;
+}
+async function osascriptGetWindows(appName) {
+  const windows = await getApplicationWindows(appName);
+  if (windows.length === 0) {
+    return `No windows for ${appName}`;
+  }
+  const lines = [`Windows for ${appName}:`, "=".repeat(40), ""];
+  for (const win of windows) {
+    lines.push(`${win.index}. ${win.name || "(unnamed)"} (ID: ${win.id})`);
+  }
+  return lines.join(`
+`);
+}
+async function osascriptSetWindowBounds(appName, windowIndex, x, y, width, height) {
+  const result = await setWindowBounds(appName, windowIndex, { x, y, width, height });
+  return result.success ? `Window ${windowIndex} bounds set to ${width}x${height} at (${x}, ${y})` : `Error: ${result.stderr}`;
+}
+async function osascriptKeystroke(key, modifiers = []) {
+  const options = { key, modifiers };
+  const result = await sendKeystroke(options);
+  const modStr = modifiers.length > 0 ? ` with ${modifiers.join("+")}` : "";
+  return result.success ? `Sent keystroke: ${key}${modStr}` : `Error: ${result.stderr}`;
+}
+async function osascriptKeyCode(keyCode, modifiers = []) {
+  const options = { keyCode, modifiers };
+  const result = await sendKeyCode(options);
+  const modStr = modifiers.length > 0 ? ` with ${modifiers.join("+")}` : "";
+  return result.success ? `Sent key code: ${keyCode}${modStr}` : `Error: ${result.stderr}`;
+}
+async function osascriptTypeText(text) {
+  const result = await typeText(text);
+  return result.success ? `Typed: ${text}` : `Error: ${result.stderr}`;
+}
+async function osascriptSafariGetURL() {
+  try {
+    const url = await getSafariURL();
+    return `Current Safari URL: ${url}`;
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}
+async function osascriptSafariSetURL(url) {
+  const result = await setSafariURL(url);
+  return result.success ? `Navigated to: ${url}` : `Error: ${result.stderr}`;
+}
+async function osascriptSafariGetTabs() {
+  const titles = await getSafariTabTitles();
+  if (titles.length === 0) {
+    return "No Safari tabs";
+  }
+  const lines = ["Safari Tabs:", "=".repeat(40), ""];
+  titles.forEach((title, i) => lines.push(`${i + 1}. ${title}`));
+  return lines.join(`
+`);
+}
+async function osascriptSafariExecJS(jsCode) {
+  try {
+    const result = await executeSafariJS(jsCode);
+    return result || "(no output)";
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}
+async function osascriptFinderGetSelection() {
+  const items = await getFinderSelection();
+  if (items.length === 0) {
+    return "No Finder selection";
+  }
+  const lines = ["Finder Selection:", "=".repeat(40), ""];
+  for (const item of items) {
+    lines.push(`- ${item.name} (${item.type})`);
+    lines.push(`  ${item.path}`);
+  }
+  return lines.join(`
+`);
+}
+async function osascriptFinderOpen(path) {
+  const result = await openFinderWindow(path);
+  return result.success ? `Opened Finder at: ${path}` : `Error: ${result.stderr}`;
+}
+async function osascriptFinderCreateFolder(parentPath, folderName) {
+  const result = await createFolder(parentPath, folderName);
+  return result.success ? `Created folder: ${folderName}` : `Error: ${result.stderr}`;
+}
+async function osascriptFinderTrash(path) {
+  const result = await moveToTrash(path);
+  return result.success ? `Moved to trash: ${path}` : `Error: ${result.stderr}`;
+}
+async function osascriptGetDisplays() {
+  const displays = await getDisplayInfo();
+  const lines = ["Display Information:", "=".repeat(40), ""];
+  for (const display of displays) {
+    lines.push(`Display ${display.id}: ${display.width}x${display.height}${display.main ? " (main)" : ""}`);
+  }
+  return lines.join(`
+`);
+}
+async function osascriptGetResolution() {
+  const { width, height } = await getScreenResolution();
+  return `Screen resolution: ${width}x${height}`;
+}
+async function osascriptSay(text, voice, rate) {
+  const result = await sayText(text, voice, rate);
+  return result.success ? `Said: "${text}"` : `Error: ${result.stderr}`;
+}
+async function osascriptBeep(count = 1) {
+  const result = await beep(count);
+  return result.success ? `Beeped ${count} time(s)` : `Error: ${result.stderr}`;
+}
+async function osascriptGetDateTime() {
+  const dateTime = await getSystemDateTime();
+  return `System date/time: ${dateTime}`;
+}
+async function osascriptSpawnClaudeSession(sessionId, workingDir, dopplerProject = "seed", dopplerConfig = "prd") {
+  const cdCmd = workingDir ? `cd ${workingDir} && ` : "";
+  const script = `tell application "Terminal" to do script "${cdCmd}unset CLAUDECODE && NO_COLOR=1 TERM=dumb doppler run --project ${dopplerProject} --config ${dopplerConfig} --command \\"claude -r ${sessionId}\\""`;
+  const result = await executeAppleScript(script);
+  if (result.success) {
+    return `Spawned Claude Code session ${sessionId} in ${result.stdout}`;
+  }
+  return `Error: ${result.stderr}`;
+}
+async function osascriptSpawnClaudeSessionsBatch(sessionIdsStr, workingDir, dopplerProject = "seed", dopplerConfig = "prd") {
+  const sessionIds = sessionIdsStr.split(",").map((s) => s.trim()).filter(Boolean);
+  const cdCmd = workingDir ? `cd ${workingDir} && ` : "";
+  const results = [];
+  for (const sessionId of sessionIds) {
+    const script = `tell application "Terminal" to do script "${cdCmd}unset CLAUDECODE && NO_COLOR=1 TERM=dumb doppler run --project ${dopplerProject} --config ${dopplerConfig} --command \\"claude -r ${sessionId}\\""`;
+    const result = await executeAppleScript(script);
+    results.push(`${sessionId.slice(0, 8)}: ${result.success ? result.stdout : result.stderr}`);
+  }
+  return `Spawned ${sessionIds.length} sessions:
+${results.join(`
+`)}`;
+}
+var TOOLS = [
+  {
+    name: "osascript_execute",
+    description: "Execute raw AppleScript code",
+    inputSchema: {
+      type: "object",
+      properties: {
+        script: { type: "string", description: "AppleScript code to execute" },
+        language: {
+          type: "string",
+          description: "Script language",
+          enum: ["applescript", "javascript"],
+          default: "applescript"
+        }
+      },
+      required: ["script"]
+    }
+  },
+  {
+    name: "osascript_display_notification",
+    description: "Display a macOS notification",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Notification body text" },
+        title: { type: "string", description: "Notification title", default: "Notification" },
+        subtitle: { type: "string", description: "Notification subtitle" },
+        sound_name: { type: "string", description: "Sound name (e.g., 'Ping', 'Glass')" }
+      },
+      required: ["message"]
+    }
+  },
+  {
+    name: "osascript_display_dialog",
+    description: "Display a dialog with buttons",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Dialog message" },
+        title: { type: "string", description: "Dialog title" },
+        buttons: {
+          type: "string",
+          description: "Comma-separated button labels (e.g., 'OK,Cancel')"
+        },
+        default_button: { type: "number", description: "Default button index (1-based)" },
+        icon: {
+          type: "string",
+          description: "Dialog icon",
+          enum: ["note", "caution", "stop"]
+        }
+      },
+      required: ["message"]
+    }
+  },
+  {
+    name: "osascript_get_volume",
+    description: "Get system volume level",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_set_volume",
+    description: "Set system volume level (0-100)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        volume: { type: "number", description: "Volume level 0-100" },
+        muted: { type: "boolean", description: "Whether to mute" }
+      },
+      required: ["volume"]
+    }
+  },
+  {
+    name: "osascript_get_clipboard",
+    description: "Get clipboard contents",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_set_clipboard",
+    description: "Set clipboard contents",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to copy to clipboard" }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "osascript_clear_clipboard",
+    description: "Clear clipboard contents",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_list_apps",
+    description: "List all running applications",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_get_app_info",
+    description: "Get detailed information about an application",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name" }
+      },
+      required: ["app_name"]
+    }
+  },
+  {
+    name: "osascript_activate_app",
+    description: "Activate (bring to front) an application",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name to activate" }
+      },
+      required: ["app_name"]
+    }
+  },
+  {
+    name: "osascript_quit_app",
+    description: "Quit an application",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name to quit" },
+        force: { type: "boolean", description: "Force quit (kill -9)" }
+      },
+      required: ["app_name"]
+    }
+  },
+  {
+    name: "osascript_launch_app",
+    description: "Launch an application",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name to launch" }
+      },
+      required: ["app_name"]
+    }
+  },
+  {
+    name: "osascript_get_frontmost_app",
+    description: "Get the name of the frontmost (active) application",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_get_windows",
+    description: "Get window list for an application",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name" }
+      },
+      required: ["app_name"]
+    }
+  },
+  {
+    name: "osascript_set_window_bounds",
+    description: "Set window position and size",
+    inputSchema: {
+      type: "object",
+      properties: {
+        app_name: { type: "string", description: "Application name" },
+        window_index: { type: "number", description: "Window index (1-based)" },
+        x: { type: "number", description: "X position" },
+        y: { type: "number", description: "Y position" },
+        width: { type: "number", description: "Window width" },
+        height: { type: "number", description: "Window height" }
+      },
+      required: ["app_name", "window_index", "x", "y", "width", "height"]
+    }
+  },
+  {
+    name: "osascript_keystroke",
+    description: "Send keystroke with optional modifiers",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Key to press" },
+        modifiers: {
+          type: "string",
+          description: "Comma-separated modifiers: command, shift, option, control"
+        }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "osascript_key_code",
+    description: "Send key code (for special keys)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key_code: { type: "number", description: "Key code number (e.g., 36=Return, 48=Tab)" },
+        modifiers: {
+          type: "string",
+          description: "Comma-separated modifiers: command, shift, option, control"
+        }
+      },
+      required: ["key_code"]
+    }
+  },
+  {
+    name: "osascript_type_text",
+    description: "Type text (simulate keyboard input)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to type" }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "osascript_safari_get_url",
+    description: "Get current Safari URL",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_safari_set_url",
+    description: "Navigate Safari to URL",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to navigate to" }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "osascript_safari_get_tabs",
+    description: "Get Safari tab titles",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_safari_exec_js",
+    description: "Execute JavaScript in Safari",
+    inputSchema: {
+      type: "object",
+      properties: {
+        js_code: { type: "string", description: "JavaScript code to execute" }
+      },
+      required: ["js_code"]
+    }
+  },
+  {
+    name: "osascript_finder_get_selection",
+    description: "Get currently selected files in Finder",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_finder_open",
+    description: "Open Finder window at path",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to open" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "osascript_finder_create_folder",
+    description: "Create new folder in Finder",
+    inputSchema: {
+      type: "object",
+      properties: {
+        parent_path: { type: "string", description: "Parent directory path" },
+        folder_name: { type: "string", description: "New folder name" }
+      },
+      required: ["parent_path", "folder_name"]
+    }
+  },
+  {
+    name: "osascript_finder_trash",
+    description: "Move file/folder to trash",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to move to trash" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "osascript_get_displays",
+    description: "Get display information",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_get_resolution",
+    description: "Get main screen resolution",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_say",
+    description: "Say text using system voice",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to speak" },
+        voice: { type: "string", description: "Voice name (e.g., 'Alex', 'Samantha')" },
+        rate: { type: "number", description: "Speaking rate" }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "osascript_beep",
+    description: "Play system beep",
+    inputSchema: {
+      type: "object",
+      properties: {
+        count: { type: "number", description: "Number of beeps" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "osascript_get_datetime",
+    description: "Get current system date/time",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_spawn_claude_session",
+    description: "Open new Terminal tab with Claude Code resume session (auto-unsets CLAUDECODE to bypass nested session check)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Claude Code session ID to resume" },
+        working_dir: { type: "string", description: "Working directory (default: current directory)" },
+        doppler_project: { type: "string", description: "Doppler project name (default: seed)" },
+        doppler_config: { type: "string", description: "Doppler config (default: prd)" }
+      },
+      required: ["session_id"]
+    }
+  },
+  {
+    name: "osascript_spawn_claude_sessions_batch",
+    description: "Open multiple Terminal tabs with Claude Code resume sessions in parallel",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_ids: { type: "string", description: "Comma-separated list of Claude Code session IDs" },
+        working_dir: { type: "string", description: "Working directory (default: current directory)" },
+        doppler_project: { type: "string", description: "Doppler project name (default: seed)" },
+        doppler_config: { type: "string", description: "Doppler config (default: prd)" }
+      },
+      required: ["session_ids"]
+    }
+  },
+  {
+    name: "osascript_event_start_app_monitor",
+    description: "Start monitoring application switches (fires event when frontmost app changes)",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_start_clipboard_monitor",
+    description: "Start monitoring clipboard changes (fires event when clipboard content changes)",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_stop_monitor",
+    description: "Stop a specific monitor by ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        monitor_id: { type: "string", description: "Monitor ID to stop" }
+      },
+      required: ["monitor_id"]
+    }
+  },
+  {
+    name: "osascript_event_stop_all_monitors",
+    description: "Stop all active monitors",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_register_listener",
+    description: "Register an event listener with optional webhook callback",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_type: {
+          type: "string",
+          description: "Event type to listen for (e.g., 'keystroke', 'app_activate', '*' for all)"
+        },
+        webhook_url: { type: "string", description: "Webhook URL to POST events to" }
+      },
+      required: ["event_type"]
+    }
+  },
+  {
+    name: "osascript_event_unregister_listener",
+    description: "Unregister an event listener",
+    inputSchema: {
+      type: "object",
+      properties: {
+        listener_id: { type: "string", description: "Listener ID to remove" }
+      },
+      required: ["listener_id"]
+    }
+  },
+  {
+    name: "osascript_event_list_listeners",
+    description: "List all registered event listeners",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_get_history",
+    description: "Get event history, optionally filtered by type or time",
+    inputSchema: {
+      type: "object",
+      properties: {
+        since: { type: "number", description: "Unix timestamp to get events since" },
+        event_type: { type: "string", description: "Filter by event type" }
+      },
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_clear_history",
+    description: "Clear all event history",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "osascript_event_send_webhook",
+    description: "Manually send an event to a webhook URL",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Webhook URL" },
+        event_type: { type: "string", description: "Event type" },
+        data: { type: "string", description: "JSON string of event data" }
+      },
+      required: ["url", "event_type"]
+    }
+  },
+  {
+    name: "osascript_event_emit",
+    description: "Emit a custom event to the event bus",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_type: { type: "string", description: "Event type to emit" },
+        source: { type: "string", description: "Source identifier" },
+        data: { type: "string", description: "JSON string of event data" }
+      },
+      required: ["event_type", "source"]
+    }
+  },
+  {
+    name: "osascript_event_status",
+    description: "Get status of event system (active monitors, listeners, event count)",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  }
+];
+function parseModifiers(modifiersStr) {
+  if (!modifiersStr)
+    return [];
+  return modifiersStr.split(",").map((m) => m.trim().toLowerCase()).filter((m) => ["command", "shift", "option", "control"].includes(m));
+}
+async function handleToolCall(name, args) {
+  if (!isMacOS()) {
+    throw new Error("osascript MCP only works on macOS");
+  }
+  switch (name) {
+    case "osascript_execute":
+      return await osascriptExecute(args.script, args.language || "applescript");
+    case "osascript_display_notification":
+      return await osascriptNotification(args.message, args.title, args.subtitle, args.sound_name);
+    case "osascript_display_dialog":
+      return await osascriptDialog(args.message, args.title, args.buttons?.split(","), args.default_button, args.icon);
+    case "osascript_get_volume":
+      return await osascriptGetVolume();
+    case "osascript_set_volume":
+      return await osascriptSetVolume(args.volume, args.muted);
+    case "osascript_get_clipboard":
+      return await osascriptGetClipboard();
+    case "osascript_set_clipboard":
+      return await osascriptSetClipboard(args.text);
+    case "osascript_clear_clipboard":
+      return await osascriptClearClipboard();
+    case "osascript_list_apps":
+      return await osascriptListApps();
+    case "osascript_get_app_info":
+      return await osascriptGetAppInfo(args.app_name);
+    case "osascript_activate_app":
+      return await osascriptActivateApp(args.app_name);
+    case "osascript_quit_app":
+      return await osascriptQuitApp(args.app_name, args.force);
+    case "osascript_launch_app":
+      return await osascriptLaunchApp(args.app_name);
+    case "osascript_get_frontmost_app":
+      return await osascriptGetFrontmostApp();
+    case "osascript_get_windows":
+      return await osascriptGetWindows(args.app_name);
+    case "osascript_set_window_bounds":
+      return await osascriptSetWindowBounds(args.app_name, args.window_index, args.x, args.y, args.width, args.height);
+    case "osascript_keystroke":
+      return await osascriptKeystroke(args.key, parseModifiers(args.modifiers));
+    case "osascript_key_code":
+      return await osascriptKeyCode(args.key_code, parseModifiers(args.modifiers));
+    case "osascript_type_text":
+      return await osascriptTypeText(args.text);
+    case "osascript_safari_get_url":
+      return await osascriptSafariGetURL();
+    case "osascript_safari_set_url":
+      return await osascriptSafariSetURL(args.url);
+    case "osascript_safari_get_tabs":
+      return await osascriptSafariGetTabs();
+    case "osascript_safari_exec_js":
+      return await osascriptSafariExecJS(args.js_code);
+    case "osascript_finder_get_selection":
+      return await osascriptFinderGetSelection();
+    case "osascript_finder_open":
+      return await osascriptFinderOpen(args.path);
+    case "osascript_finder_create_folder":
+      return await osascriptFinderCreateFolder(args.parent_path, args.folder_name);
+    case "osascript_finder_trash":
+      return await osascriptFinderTrash(args.path);
+    case "osascript_get_displays":
+      return await osascriptGetDisplays();
+    case "osascript_get_resolution":
+      return await osascriptGetResolution();
+    case "osascript_say":
+      return await osascriptSay(args.text, args.voice, args.rate);
+    case "osascript_beep":
+      return await osascriptBeep(args.count || 1);
+    case "osascript_get_datetime":
+      return await osascriptGetDateTime();
+    case "osascript_spawn_claude_session":
+      return await osascriptSpawnClaudeSession(args.session_id, args.working_dir, args.doppler_project, args.doppler_config);
+    case "osascript_spawn_claude_sessions_batch":
+      return await osascriptSpawnClaudeSessionsBatch(args.session_ids, args.working_dir, args.doppler_project, args.doppler_config);
+    case "osascript_event_start_app_monitor": {
+      const monitorId = await startAppMonitor();
+      return `Started app monitor: ${monitorId}`;
+    }
+    case "osascript_event_start_clipboard_monitor": {
+      const monitorId = await startClipboardMonitor();
+      return `Started clipboard monitor: ${monitorId}`;
+    }
+    case "osascript_event_stop_monitor": {
+      const stopped = stopMonitor(args.monitor_id);
+      return stopped ? `Stopped monitor: ${args.monitor_id}` : `Monitor not found: ${args.monitor_id}`;
+    }
+    case "osascript_event_stop_all_monitors": {
+      stopAllMonitors();
+      return "Stopped all monitors";
+    }
+    case "osascript_event_register_listener": {
+      const listenerId = registerEventListener(args.event_type, {
+        webhookUrl: args.webhook_url
+      });
+      return `Registered listener: ${listenerId}`;
+    }
+    case "osascript_event_unregister_listener": {
+      const removed = unregisterEventListener(args.listener_id);
+      return removed ? `Unregistered listener: ${args.listener_id}` : `Listener not found: ${args.listener_id}`;
+    }
+    case "osascript_event_list_listeners": {
+      const listeners = listEventListeners();
+      if (listeners.length === 0)
+        return "No listeners registered";
+      const lines = ["Event Listeners:", "=".repeat(40), ""];
+      for (const l of listeners) {
+        lines.push(`${l.id}: ${l.eventType} (${l.active ? "active" : "inactive"})${l.webhookUrl ? ` -> ${l.webhookUrl}` : ""}`);
+      }
+      return lines.join(`
+`);
+    }
+    case "osascript_event_get_history": {
+      const events = getEventHistory(args.since, args.event_type);
+      if (events.length === 0)
+        return "No events in history";
+      return JSON.stringify(events, null, 2);
+    }
+    case "osascript_event_clear_history": {
+      clearEventHistory();
+      return "Event history cleared";
+    }
+    case "osascript_event_send_webhook": {
+      const data = args.data ? JSON.parse(args.data) : {};
+      const event = createEvent(args.event_type, "manual", data);
+      const result = await sendEventWebhook(args.url, event);
+      return result.success ? `Webhook sent: ${event.id}` : `Webhook failed: ${result.error}`;
+    }
+    case "osascript_event_emit": {
+      const data = args.data ? JSON.parse(args.data) : {};
+      const event = createEvent(args.event_type, args.source, data);
+      eventBus.emit(event);
+      return `Emitted event: ${event.id}`;
+    }
+    case "osascript_event_status": {
+      const status = {
+        activeMonitors: getActiveMonitorCount(),
+        activeListeners: getActiveListenerCount(),
+        historySize: getEventHistory().length
+      };
+      return `Event System Status:
+${JSON.stringify(status, null, 2)}`;
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+function sendMessage(message) {
+  console.log(JSON.stringify(message));
+}
+async function processMessage(message) {
+  const { id, method, params } = message;
+  try {
+    switch (method) {
+      case "initialize":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {}
+            },
+            serverInfo: {
+              name: "osascript-mcp",
+              version: "1.0.0",
+              description: "macOS automation via osascript (AppleScript/JXA)"
+            }
+          }
+        });
+        break;
+      case "tools/list":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: TOOLS
+          }
+        });
+        break;
+      case "tools/call":
+        const { name, arguments: args } = params;
+        const result = await handleToolCall(name, args || {});
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: result
+              }
+            ]
+          }
+        });
+        break;
+      case "shutdown":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {}
+        });
+        process.exit(0);
+        break;
+      default:
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        });
+    }
+  } catch (error) {
+    sendMessage({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32603,
+        message: `Internal error: ${error}`
+      }
+    });
+  }
+}
+async function main() {
+  if (!isMacOS()) {
+    console.error("ERROR: osascript MCP only works on macOS");
+    process.exit(1);
+  }
+  const decoder = new TextDecoder;
+  let buffer = "";
+  for await (const chunk of process.stdin) {
+    buffer += decoder.decode(chunk);
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const message = JSON.parse(line);
+        await processMessage(message);
+      } catch (error) {
+        sendMessage({
+          jsonrpc: "2.0",
+          error: {
+            code: -32700,
+            message: `Parse error: ${error}`
+          }
+        });
+      }
+    }
+  }
+}
+main().catch(console.error);