@aurora-foundation/obsidian-next 0.4.7 → 0.4.9

package/dist/chunk-B77K6OQZ.js

@@ -0,0 +1,687 @@
+import {
+  ScreenshotError,
+  shell
+} from "./chunk-YPMJD4YE.js";
+
+// src/computer/screenshot.ts
+import * as fs from "fs";
+var MAX_LONG_EDGE = 1568;
+var MAX_PIXELS = 115e4;
+async function getDisplayDimensions() {
+  try {
+    try {
+      const { stdout } = await shell.execute(
+        "system_profiler SPDisplaysDataType | grep Resolution | head -1 | awk '{print $2, $4}'"
+      );
+      const parts = stdout.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const width = parseInt(parts[0], 10);
+        const height = parseInt(parts[1], 10);
+        if (width > 0 && height > 0) {
+          return { width, height };
+        }
+      }
+    } catch {
+    }
+    try {
+      const { stdout } = await shell.execute(
+        `osascript -e 'tell application "Finder" to get bounds of window of desktop'`
+      );
+      const parts = stdout.trim().split(",").map((p) => parseInt(p.trim(), 10));
+      if (parts.length === 4 && parts[2] > 0 && parts[3] > 0) {
+        return { width: parts[2], height: parts[3] };
+      }
+    } catch {
+    }
+    try {
+      const { stdout } = await shell.execute(
+        "screenresolution get 2>/dev/null || echo ''"
+      );
+      const match = stdout.match(/(\d+)\s*x\s*(\d+)/);
+      if (match) {
+        return {
+          width: parseInt(match[1], 10),
+          height: parseInt(match[2], 10)
+        };
+      }
+    } catch {
+    }
+  } catch (error) {
+  }
+  return { width: 1920, height: 1080 };
+}
+function calculateScaleForAPI(width, height) {
+  const longEdge = Math.max(width, height);
+  const totalPixels = width * height;
+  const longEdgeScale = MAX_LONG_EDGE / longEdge;
+  const totalPixelsScale = Math.sqrt(MAX_PIXELS / totalPixels);
+  return Math.min(1, longEdgeScale, totalPixelsScale);
+}
+async function takeScreenshot(captureCursor = false) {
+  const screenshotPath = `/tmp/screenshot-${Date.now()}.png`;
+  const flags = captureCursor ? "-x -C" : "-x";
+  try {
+    await shell.execute(`screencapture ${flags} ${screenshotPath}`);
+    const imageBuffer = fs.readFileSync(screenshotPath);
+    return imageBuffer.toString("base64");
+  } catch (error) {
+    throw new ScreenshotError("Failed to capture screenshot", error);
+  } finally {
+    if (fs.existsSync(screenshotPath)) {
+      fs.unlinkSync(screenshotPath);
+    }
+  }
+}
+async function takeScreenshotForAPI(captureCursor = false, targetWidth, targetHeight) {
+  const screenshotPath = `/tmp/screenshot-${Date.now()}.png`;
+  const resizedPath = `/tmp/screenshot-resized-${Date.now()}.png`;
+  const flags = captureCursor ? "-x -C" : "-x";
+  try {
+    await shell.execute(`screencapture ${flags} ${screenshotPath}`);
+    const { stdout: sizeOutput } = await shell.execute(
+      `sips -g pixelWidth -g pixelHeight ${screenshotPath} | tail -2`
+    );
+    const widthMatch = sizeOutput.match(/pixelWidth:\s*(\d+)/);
+    const heightMatch = sizeOutput.match(/pixelHeight:\s*(\d+)/);
+    const originalWidth = widthMatch ? parseInt(widthMatch[1], 10) : 1920;
+    const originalHeight = heightMatch ? parseInt(heightMatch[1], 10) : 1080;
+    const scale = calculateScaleForAPI(originalWidth, originalHeight);
+    const finalWidth = targetWidth || Math.floor(originalWidth * scale);
+    const finalHeight = targetHeight || Math.floor(originalHeight * scale);
+    if (scale < 1) {
+      await shell.execute(
+        `sips -z ${finalHeight} ${finalWidth} ${screenshotPath} --out ${resizedPath}`
+      );
+      const imageBuffer = fs.readFileSync(resizedPath);
+      return {
+        base64: imageBuffer.toString("base64"),
+        width: finalWidth,
+        height: finalHeight,
+        scale
+      };
+    } else {
+      const imageBuffer = fs.readFileSync(screenshotPath);
+      return {
+        base64: imageBuffer.toString("base64"),
+        width: originalWidth,
+        height: originalHeight,
+        scale: 1
+      };
+    }
+  } catch (error) {
+    throw new ScreenshotError("Failed to capture/resize screenshot", error);
+  } finally {
+    for (const p of [screenshotPath, resizedPath]) {
+      if (fs.existsSync(p)) {
+        try {
+          fs.unlinkSync(p);
+        } catch {
+        }
+      }
+    }
+  }
+}
+async function zoom(x1, y1, x2, y2) {
+  const regionScreenshotPath = `/tmp/screenshot_region-${Date.now()}.png`;
+  const left = Math.min(x1, x2);
+  const top = Math.min(y1, y2);
+  const width = Math.abs(x2 - x1);
+  const height = Math.abs(y2 - y1);
+  if (width <= 0 || height <= 0) {
+    throw new ScreenshotError(
+      "Invalid region dimensions",
+      new Error(`Width: ${width}, Height: ${height}`)
+    );
+  }
+  try {
+    await shell.execute(
+      `screencapture -x -R ${left},${top},${width},${height} ${regionScreenshotPath}`
+    );
+    const imageBuffer = fs.readFileSync(regionScreenshotPath);
+    return imageBuffer.toString("base64");
+  } catch (error) {
+    throw new ScreenshotError(
+      `Failed to capture region (${left},${top},${width}x${height})`,
+      error
+    );
+  } finally {
+    if (fs.existsSync(regionScreenshotPath)) {
+      try {
+        fs.unlinkSync(regionScreenshotPath);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/computer/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/computer/keyboard.ts
+var KEY_MAP = {
+  enter: "return",
+  return: "return",
+  "\n": "return",
+  "\r": "return",
+  "num-enter": "num-enter",
+  escape: "esc",
+  esc: "esc",
+  tab: "tab",
+  backspace: "delete",
+  // macOS backspace
+  delete: "fwd-delete",
+  // macOS forward delete
+  space: "space",
+  up: "arrow-up",
+  down: "arrow-down",
+  left: "arrow-left",
+  right: "arrow-right",
+  home: "home",
+  end: "end",
+  pageup: "page-up",
+  pagedown: "page-down",
+  f1: "f1",
+  f2: "f2",
+  f3: "f3",
+  f4: "f4",
+  f5: "f5",
+  f6: "f6",
+  f7: "f7",
+  f8: "f8",
+  f9: "f9",
+  f10: "f10",
+  f11: "f11",
+  f12: "f12"
+};
+var MODIFIER_MAP = {
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  shift: "shift",
+  cmd: "cmd",
+  command: "cmd",
+  super: "cmd",
+  meta: "cmd",
+  win: "cmd"
+};
+async function typeText(text) {
+  if (!text) return;
+  const segments = text.split(/\r?\n/);
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment) {
+      const escapedText = segment.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'");
+      await shell.execute(`cliclick t:"${escapedText}"`);
+    }
+    if (i < segments.length - 1) {
+      await shell.execute("cliclick kp:return");
+    }
+  }
+}
+async function pressKey(key) {
+  if (!key) {
+    throw new Error("Key is required for pressKey action");
+  }
+  const keyLower = key.toLowerCase();
+  if (keyLower.includes("+")) {
+    await pressKeyCombination(keyLower);
+    return;
+  }
+  const mappedKey = KEY_MAP[keyLower];
+  if (mappedKey) {
+    await shell.execute(`cliclick kp:${mappedKey}`);
+    return;
+  }
+  if (MODIFIER_MAP[keyLower]) {
+    const mod = MODIFIER_MAP[keyLower];
+    await shell.execute(`cliclick kd:${mod} ku:${mod}`);
+    return;
+  }
+  const escapedKey = key.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'");
+  await shell.execute(`cliclick t:"${escapedKey}"`);
+}
+async function pressKeyCombination(combo) {
+  const parts = combo.split("+").map((p) => p.trim());
+  const mainKey = parts.pop();
+  const mainKeyLower = mainKey.toLowerCase();
+  const modifiers = parts.map((m) => MODIFIER_MAP[m.toLowerCase()] || m.toLowerCase()).filter((m) => m);
+  const mappedKey = KEY_MAP[mainKeyLower];
+  const holdCmds = modifiers.map((m) => `kd:${m}`).join(" ");
+  const releaseCmds = modifiers.reverse().map((m) => `ku:${m}`).join(" ");
+  if (mappedKey) {
+    await shell.execute(`cliclick ${holdCmds} kp:${mappedKey} ${releaseCmds}`);
+  } else {
+    const escapedKey = mainKey.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'");
+    await shell.execute(
+      `cliclick ${holdCmds} t:"${escapedKey}" ${releaseCmds}`
+    );
+  }
+}
+async function holdKey(key, duration) {
+  if (!key) {
+    throw new Error("Key is required for holdKey action");
+  }
+  const keyLower = key.toLowerCase();
+  const cliclickKey = MODIFIER_MAP[keyLower] || KEY_MAP[keyLower] || keyLower;
+  const durationSec = Math.max(0.1, duration);
+  await shell.execute(
+    `cliclick kd:${cliclickKey} w:${Math.round(durationSec * 1e3)} ku:${cliclickKey}`
+  );
+}
+
+// src/computer/mouse.ts
+function getModifier(modifier) {
+  if (!modifier) return "";
+  switch (modifier.toLowerCase()) {
+    case "shift":
+      return "shift-";
+    case "ctrl":
+      return "ctrl-";
+    case "alt":
+      return "alt-";
+    case "super":
+      return "cmd-";
+    // 'super' usually maps to 'cmd' on macOS
+    default:
+      return "";
+  }
+}
+async function leftClick(x, y, modifier) {
+  const mod = getModifier(modifier);
+  await shell.execute(`cliclick ${mod}c:${x},${y}`);
+}
+async function mouseMove(x, y) {
+  await shell.execute(`cliclick m:${x},${y}`);
+}
+async function leftClickDrag(startX, startY, endX, endY) {
+  await shell.execute(`cliclick dd:${startX},${startY} du:${endX},${endY}`);
+}
+async function rightClick(x, y, modifier) {
+  const mod = getModifier(modifier);
+  await shell.execute(`cliclick ${mod}rc:${x},${y}`);
+}
+async function middleClick(x, y, modifier) {
+  console.warn(
+    "Middle click not directly supported by cliclick. Consider alternative implementation if needed."
+  );
+  await shell.execute(
+    `echo "Middle click at ${x},${y} with modifier ${modifier} requested but not fully supported by cliclick."`
+  );
+}
+async function doubleClick(x, y, modifier) {
+  const mod = getModifier(modifier);
+  await shell.execute(`cliclick ${mod}dc:${x},${y}`);
+}
+async function tripleClick(x, y, modifier) {
+  const mod = getModifier(modifier);
+  await shell.execute(`cliclick ${mod}tc:${x},${y}`);
+}
+async function leftMouseDown(x, y) {
+  await shell.execute(`cliclick dd:${x},${y}`);
+}
+async function leftMouseUp(x, y) {
+  await shell.execute(`cliclick du:${x},${y}`);
+}
+async function scroll(x, y, direction, amount, modifier) {
+  let scrollCommand = "";
+  const mod = getModifier(modifier);
+  await shell.execute(`cliclick m:${x},${y}`);
+  switch (direction) {
+    case "up":
+      scrollCommand = `${mod}sc:u${amount}`;
+      break;
+    case "down":
+      scrollCommand = `${mod}sc:d${amount}`;
+      break;
+    case "left":
+      scrollCommand = `${mod}sc:l${amount}`;
+      break;
+    case "right":
+      scrollCommand = `${mod}sc:r${amount}`;
+      break;
+    default:
+      console.warn(`Unsupported scroll direction: ${direction}`);
+      return;
+  }
+  await shell.execute(`cliclick ${scrollCommand}`);
+}
+async function executeBatch(commands) {
+  const batchString = commands.join(" ");
+  await shell.execute(`cliclick ${batchString}`);
+}
+
+// src/computer/utils.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function wait(duration) {
+  await new Promise((resolve) => setTimeout(resolve, duration));
+}
+
+// src/computer/accessibility.ts
+async function getFocusedApp() {
+  try {
+    const script = `
+            tell application "System Events"
+                set frontApp to first application process whose frontmost is true
+                return name of frontApp
+            end tell
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim();
+  } catch (error) {
+    return "Unknown";
+  }
+}
+async function getFocusedWindowTitle() {
+  try {
+    const script = `
+            tell application "System Events"
+                set frontApp to first application process whose frontmost is true
+                tell frontApp
+                    if (count of windows) > 0 then
+                        return name of window 1
+                    else
+                        return ""
+                    end if
+                end tell
+            end tell
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim();
+  } catch (error) {
+    return "";
+  }
+}
+async function findElementByLabel(label, appName) {
+  try {
+    const targetApp = appName || await getFocusedApp();
+    const script = `
+            tell application "System Events"
+                tell process "${targetApp}"
+                    set targetElements to every UI element of window 1 whose name contains "${label}"
+                    if (count of targetElements) > 0 then
+                        set el to item 1 of targetElements
+                        set elPos to position of el
+                        set elSize to size of el
+                        return (item 1 of elPos) & "," & (item 2 of elPos) & "," & (item 1 of elSize) & "," & (item 2 of elSize)
+                    end if
+
+                    -- Try deeper search in groups/scroll areas
+                    set allGroups to every group of window 1
+                    repeat with grp in allGroups
+                        try
+                            set targetElements to every UI element of grp whose name contains "${label}"
+                            if (count of targetElements) > 0 then
+                                set el to item 1 of targetElements
+                                set elPos to position of el
+                                set elSize to size of el
+                                return (item 1 of elPos) & "," & (item 2 of elPos) & "," & (item 1 of elSize) & "," & (item 2 of elSize)
+                            end if
+                        end try
+                    end repeat
+
+                    return ""
+                end tell
+            end tell
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    const result = stdout.trim();
+    if (!result) return null;
+    const [x, y, width, height] = result.split(",").map(Number);
+    return { x, y, width, height };
+  } catch (error) {
+    return null;
+  }
+}
+async function findClickableByLabel(label) {
+  const element = await findElementByLabel(label);
+  if (!element) return null;
+  const centerX = Math.round(element.x + element.width / 2);
+  const centerY = Math.round(element.y + element.height / 2);
+  return [centerX, centerY];
+}
+async function clickElementByLabel(label, appName) {
+  try {
+    const targetApp = appName || await getFocusedApp();
+    const script = `
+            tell application "System Events"
+                tell process "${targetApp}"
+                    set targetElements to every button of window 1 whose name contains "${label}"
+                    if (count of targetElements) > 0 then
+                        click item 1 of targetElements
+                        return "clicked"
+                    end if
+
+                    -- Try menu items
+                    set targetMenus to every menu item of every menu of menu bar 1 whose name contains "${label}"
+                    if (count of targetMenus) > 0 then
+                        click item 1 of targetMenus
+                        return "clicked"
+                    end if
+
+                    return "not_found"
+                end tell
+            end tell
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim() === "clicked";
+  } catch (error) {
+    return false;
+  }
+}
+async function getButtons(appName) {
+  try {
+    const targetApp = appName || await getFocusedApp();
+    const script = `
+            set buttonNames to {}
+            tell application "System Events"
+                tell process "${targetApp}"
+                    if (count of windows) > 0 then
+                        set allButtons to every button of window 1
+                        repeat with btn in allButtons
+                            try
+                                set end of buttonNames to name of btn
+                            end try
+                        end repeat
+                    end if
+                end tell
+            end tell
+            return buttonNames as text
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim().split(", ").filter((b) => b);
+  } catch (error) {
+    return [];
+  }
+}
+async function getTextFields(appName) {
+  try {
+    const targetApp = appName || await getFocusedApp();
+    const script = `
+            set fieldNames to {}
+            tell application "System Events"
+                tell process "${targetApp}"
+                    if (count of windows) > 0 then
+                        set allFields to every text field of window 1
+                        repeat with fld in allFields
+                            try
+                                set end of fieldNames to description of fld
+                            end try
+                        end repeat
+                    end if
+                end tell
+            end tell
+            return fieldNames as text
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim().split(", ").filter((f) => f);
+  } catch (error) {
+    return [];
+  }
+}
+async function activateApp(appName) {
+  try {
+    const script = `
+            tell application "${appName}"
+                activate
+            end tell
+            return "ok"
+        `;
+    const { stdout } = await shell.execute(`osascript -e '${script}'`);
+    return stdout.trim() === "ok";
+  } catch (error) {
+    return false;
+  }
+}
+async function getUIContext() {
+  const [app, windowTitle, buttons, textFields] = await Promise.all([
+    getFocusedApp(),
+    getFocusedWindowTitle(),
+    getButtons(),
+    getTextFields()
+  ]);
+  const lines = [`Focused App: ${app}`, `Window: ${windowTitle || "(none)"}`];
+  if (buttons.length > 0) {
+    lines.push(
+      `Buttons: ${buttons.slice(0, 10).join(", ")}${buttons.length > 10 ? "..." : ""}`
+    );
+  }
+  if (textFields.length > 0) {
+    lines.push(
+      `Text Fields: ${textFields.slice(0, 5).join(", ")}${textFields.length > 5 ? "..." : ""}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/computer/index.ts
+var macComputer = {
+  takeScreenshot,
+  leftClick,
+  typeText,
+  pressKey,
+  mouseMove,
+  scroll,
+  leftClickDrag,
+  rightClick,
+  middleClick,
+  doubleClick,
+  tripleClick,
+  leftMouseDown,
+  leftMouseUp,
+  holdKey,
+  wait,
+  zoom,
+  getDisplayDimensions,
+  executeBatch
+};
+var unimplementedComputer = {
+  takeScreenshot: async () => {
+    throw new Error(
+      "Computer use not implemented for this platform. Currently macOS only."
+    );
+  },
+  leftClick: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  typeText: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  pressKey: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  mouseMove: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  scroll: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  leftClickDrag: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  rightClick: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  middleClick: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  doubleClick: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  tripleClick: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  leftMouseDown: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  leftMouseUp: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  holdKey: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  wait: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  zoom: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  getDisplayDimensions: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  },
+  executeBatch: async () => {
+    throw new Error("Computer use not implemented for this platform.");
+  }
+};
+var computer = process.platform === "darwin" ? macComputer : unimplementedComputer;
+function isComputerUseAvailable() {
+  return process.platform === "darwin";
+}
+async function checkDependencies() {
+  if (process.platform !== "darwin") {
+    return { available: false, missing: ["macOS required"] };
+  }
+  const { shell: shell2 } = await import("./shell-FM34624T.js");
+  const missing = [];
+  try {
+    await shell2.execute("which cliclick");
+  } catch {
+    missing.push("cliclick (install with: brew install cliclick)");
+  }
+  return {
+    available: missing.length === 0,
+    missing
+  };
+}
+
+// src/computer/client.ts
+function getToolConfig(model) {
+  if (model.includes("opus-4-5") || model.includes("opus-4.5")) {
+    return {
+      toolVersion: "computer_20251124",
+      betaFlag: "computer-use-2025-11-24"
+    };
+  }
+  return {
+    toolVersion: "computer_20250124",
+    betaFlag: "computer-use-2025-01-24"
+  };
+}
+
+export {
+  getDisplayDimensions,
+  calculateScaleForAPI,
+  takeScreenshotForAPI,
+  getToolConfig,
+  getFocusedApp,
+  findClickableByLabel,
+  clickElementByLabel,
+  getButtons,
+  activateApp,
+  getUIContext,
+  computer,
+  isComputerUseAvailable,
+  checkDependencies
+};