@ebowwa/osascript 1.1.0

package/dist/mcp/index.js

@@ -0,0 +1,866 @@
+#!/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/index.ts
+var MCP_PORT = parseInt(process.env.MCP_PORT || "8914");
+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}`;
+}
+function parseModifiers(modifiersStr) {
+  if (!modifiersStr)
+    return [];
+  return modifiersStr.split(",").map((m) => m.trim().toLowerCase()).filter((m) => ["command", "shift", "option", "control"].includes(m));
+}
+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}`;
+}
+var TOOLS = [
+  { name: "osascript_execute", description: "Execute raw AppleScript or JXA code", args: ["script", "language?"] },
+  { name: "osascript_display_notification", description: "Display a macOS notification", args: ["message", "title?", "subtitle?", "sound_name?"] },
+  { name: "osascript_display_dialog", description: "Display a dialog with buttons", args: ["message", "title?", "buttons?", "default_button?", "icon?"] },
+  { name: "osascript_get_volume", description: "Get system volume level", args: [] },
+  { name: "osascript_set_volume", description: "Set system volume level (0-100)", args: ["volume", "muted?"] },
+  { name: "osascript_get_clipboard", description: "Get clipboard contents", args: [] },
+  { name: "osascript_set_clipboard", description: "Set clipboard contents", args: ["text"] },
+  { name: "osascript_clear_clipboard", description: "Clear clipboard contents", args: [] },
+  { name: "osascript_list_apps", description: "List all running applications", args: [] },
+  { name: "osascript_get_app_info", description: "Get detailed information about an application", args: ["app_name"] },
+  { name: "osascript_activate_app", description: "Activate (bring to front) an application", args: ["app_name"] },
+  { name: "osascript_quit_app", description: "Quit an application", args: ["app_name", "force?"] },
+  { name: "osascript_launch_app", description: "Launch an application", args: ["app_name"] },
+  { name: "osascript_get_frontmost_app", description: "Get the name of the frontmost application", args: [] },
+  { name: "osascript_get_windows", description: "Get window list for an application", args: ["app_name"] },
+  { name: "osascript_set_window_bounds", description: "Set window position and size", args: ["app_name", "window_index", "x", "y", "width", "height"] },
+  { name: "osascript_keystroke", description: "Send keystroke with optional modifiers", args: ["key", "modifiers?"] },
+  { name: "osascript_key_code", description: "Send key code (for special keys)", args: ["key_code", "modifiers?"] },
+  { name: "osascript_type_text", description: "Type text (simulate keyboard input)", args: ["text"] },
+  { name: "osascript_safari_get_url", description: "Get current Safari URL", args: [] },
+  { name: "osascript_safari_set_url", description: "Navigate Safari to URL", args: ["url"] },
+  { name: "osascript_safari_get_tabs", description: "Get Safari tab titles", args: [] },
+  { name: "osascript_safari_exec_js", description: "Execute JavaScript in Safari", args: ["js_code"] },
+  { name: "osascript_finder_get_selection", description: "Get currently selected files in Finder", args: [] },
+  { name: "osascript_finder_open", description: "Open Finder window at path", args: ["path"] },
+  { name: "osascript_finder_create_folder", description: "Create new folder in Finder", args: ["parent_path", "folder_name"] },
+  { name: "osascript_finder_trash", description: "Move file/folder to trash", args: ["path"] },
+  { name: "osascript_get_displays", description: "Get display information", args: [] },
+  { name: "osascript_get_resolution", description: "Get main screen resolution", args: [] },
+  { name: "osascript_say", description: "Say text using system voice", args: ["text", "voice?", "rate?"] },
+  { name: "osascript_beep", description: "Play system beep", args: ["count?"] },
+  { name: "osascript_get_datetime", description: "Get current system date/time", args: [] }
+];
+Bun.serve({
+  port: MCP_PORT,
+  fetch: async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/health") {
+      return Response.json({
+        status: "ok",
+        port: MCP_PORT,
+        service: "osascript-mcp",
+        platform: process.platform,
+        macos: isMacOS()
+      });
+    }
+    if (url.pathname === "/mcp") {
+      if (req.method === "GET") {
+        return Response.json({
+          name: "osascript-mcp",
+          version: "1.0.0",
+          description: "macOS automation via osascript (AppleScript/JXA)",
+          platform: process.platform,
+          macos: isMacOS(),
+          tools: TOOLS
+        });
+      }
+      if (req.method === "POST") {
+        if (!isMacOS()) {
+          return Response.json({ error: "osascript MCP only works on macOS" }, { status: 500 });
+        }
+        const body = await req.json();
+        const { tool, args = {} } = body;
+        try {
+          let result;
+          switch (tool) {
+            case "osascript_execute":
+              result = await osascriptExecute(args?.script, args?.language || "applescript");
+              break;
+            case "osascript_display_notification":
+              result = await osascriptNotification(args?.message, args?.title, args?.subtitle, args?.sound_name);
+              break;
+            case "osascript_display_dialog":
+              result = await osascriptDialog(args?.message, args?.title, args?.buttons?.split(","), args?.default_button, args?.icon);
+              break;
+            case "osascript_get_volume":
+              result = await osascriptGetVolume();
+              break;
+            case "osascript_set_volume":
+              result = await osascriptSetVolume(args?.volume, args?.muted);
+              break;
+            case "osascript_get_clipboard":
+              result = await osascriptGetClipboard();
+              break;
+            case "osascript_set_clipboard":
+              result = await osascriptSetClipboard(args?.text);
+              break;
+            case "osascript_clear_clipboard":
+              result = await osascriptClearClipboard();
+              break;
+            case "osascript_list_apps":
+              result = await osascriptListApps();
+              break;
+            case "osascript_get_app_info":
+              result = await osascriptGetAppInfo(args?.app_name);
+              break;
+            case "osascript_activate_app":
+              result = await osascriptActivateApp(args?.app_name);
+              break;
+            case "osascript_quit_app":
+              result = await osascriptQuitApp(args?.app_name, args?.force);
+              break;
+            case "osascript_launch_app":
+              result = await osascriptLaunchApp(args?.app_name);
+              break;
+            case "osascript_get_frontmost_app":
+              result = await osascriptGetFrontmostApp();
+              break;
+            case "osascript_get_windows":
+              result = await osascriptGetWindows(args?.app_name);
+              break;
+            case "osascript_set_window_bounds":
+              result = await osascriptSetWindowBounds(args?.app_name, args?.window_index, args?.x, args?.y, args?.width, args?.height);
+              break;
+            case "osascript_keystroke":
+              result = await osascriptKeystroke(args?.key, parseModifiers(args?.modifiers));
+              break;
+            case "osascript_key_code":
+              result = await osascriptKeyCode(args?.key_code, parseModifiers(args?.modifiers));
+              break;
+            case "osascript_type_text":
+              result = await osascriptTypeText(args?.text);
+              break;
+            case "osascript_safari_get_url":
+              result = await osascriptSafariGetURL();
+              break;
+            case "osascript_safari_set_url":
+              result = await osascriptSafariSetURL(args?.url);
+              break;
+            case "osascript_safari_get_tabs":
+              result = await osascriptSafariGetTabs();
+              break;
+            case "osascript_safari_exec_js":
+              result = await osascriptSafariExecJS(args?.js_code);
+              break;
+            case "osascript_finder_get_selection":
+              result = await osascriptFinderGetSelection();
+              break;
+            case "osascript_finder_open":
+              result = await osascriptFinderOpen(args?.path);
+              break;
+            case "osascript_finder_create_folder":
+              result = await osascriptFinderCreateFolder(args?.parent_path, args?.folder_name);
+              break;
+            case "osascript_finder_trash":
+              result = await osascriptFinderTrash(args?.path);
+              break;
+            case "osascript_get_displays":
+              result = await osascriptGetDisplays();
+              break;
+            case "osascript_get_resolution":
+              result = await osascriptGetResolution();
+              break;
+            case "osascript_say":
+              result = await osascriptSay(args?.text, args?.voice, args?.rate);
+              break;
+            case "osascript_beep":
+              result = await osascriptBeep(args?.count || 1);
+              break;
+            case "osascript_get_datetime":
+              result = await osascriptGetDateTime();
+              break;
+            default:
+              return Response.json({ error: `Unknown tool: ${tool}` }, { status: 400 });
+          }
+          return Response.json({ result });
+        } catch (error) {
+          return Response.json({ error: String(error) }, { status: 500 });
+        }
+      }
+    }
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+});
+console.log(`osascript MCP Server running on port ${MCP_PORT}`);
+console.log(`   Health: http://localhost:${MCP_PORT}/health`);
+console.log(`   MCP:    http://localhost:${MCP_PORT}/mcp`);