ucu-mcp 0.1.0

package/dist/src/utils/input.js

@@ -0,0 +1,425 @@
+/**
+ * Cross-platform input synthesis for UCU-MCP.
+ *
+ * macOS: Uses CGEvent API exclusively for BACKGROUND input injection.
+ * This does NOT activate windows or steal focus — the AI agent can
+ * control the desktop while the user continues working in another
+ * terminal/window without interruption.
+ *
+ * Windows: Uses SendInput (stub).
+ * Linux: Uses xdotool (stub).
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "../util/logger.js";
+const execFileAsync = promisify(execFile);
+// ── Dry-run mode ──────────────────────────────────────────────────────────
+const isDryRun = () => process.env.UCU_DRY_RUN === "true";
+function logDryRun(action, details) {
+    logger.info(`[DRY RUN] Would ${action}`, details);
+}
+// ── macOS key code map ────────────────────────────────────────────────────
+const MAC_KEY_CODES = {
+    enter: 36, return: 36,
+    tab: 48,
+    escape: 53, esc: 53,
+    backspace: 51, delete: 51,
+    forwarddelete: 117, fn_delete: 117,
+    space: 49,
+    up: 126, down: 125, left: 123, right: 124,
+    home: 115, end: 119,
+    pageup: 116, pagedown: 121,
+    f1: 122, f2: 120, f3: 99, f4: 118, f5: 96, f6: 97,
+    f7: 98, f8: 100, f9: 101, f10: 109, f11: 103, f12: 111,
+    capslock: 57,
+};
+const MAC_MODIFIER_FLAGS = {
+    cmd: 0x00100000, command: 0x00100000,
+    shift: 0x00020000,
+    option: 0x00080000, alt: 0x00080000,
+    control: 0x00040000, ctrl: 0x00040000,
+};
+// ── AppleScript string escaping ───────────────────────────────────────────
+function escapeAppleScriptString(str) {
+    return str
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t")
+        .replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+}
+// ── JXA runner helper ─────────────────────────────────────────────────────
+async function runJXA(script, timeout = 5000) {
+    const { stdout } = await execFileAsync("/usr/bin/osascript", [
+        "-l", "JavaScript", "-e", script,
+    ], { timeout });
+    return stdout.trim();
+}
+// ── Mouse operations (CGEvent — background, no focus steal) ───────────────
+export async function click(x, y, button = "left", _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("click", { x, y, button });
+        return;
+    }
+    if (_platform === "darwin") {
+        const btnType = { left: 0, right: 1, middle: 2 }[button];
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      var loc = $.CGPointMake(${x}, ${y});
+      var down = $.CGEventCreateMouseEvent(null, ${1 + btnType * 2}, loc, ${btnType});
+      var up = $.CGEventCreateMouseEvent(null, ${2 + btnType * 2}, loc, ${btnType});
+      $.CGEventPost(0, down);
+      $.CGEventPost(0, up);
+      $.CFRelease(down);
+      $.CFRelease(up);
+    `);
+        return;
+    }
+    if (_platform === "linux") {
+        const btnFlag = { left: "1", right: "3", middle: "2" }[button];
+        await execFileAsync("xdotool", ["mousemove", String(x), String(y)]);
+        await execFileAsync("xdotool", ["click", btnFlag]);
+        return;
+    }
+    // Windows
+    throw new Error("click not implemented for Windows");
+}
+export async function doubleClick(x, y, button = "left", _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("doubleClick", { x, y, button });
+        return;
+    }
+    if (_platform === "darwin") {
+        const btnType = { left: 0, right: 1, middle: 2 }[button];
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      var loc = $.CGPointMake(${x}, ${y});
+      var down1 = $.CGEventCreateMouseEvent(null, ${1 + btnType * 2}, loc, ${btnType});
+      $.CGEventSetIntegerValueField(down1, 1, 1);
+      var up1 = $.CGEventCreateMouseEvent(null, ${2 + btnType * 2}, loc, ${btnType});
+      $.CGEventSetIntegerValueField(up1, 1, 1);
+      var down2 = $.CGEventCreateMouseEvent(null, ${1 + btnType * 2}, loc, ${btnType});
+      $.CGEventSetIntegerValueField(down2, 1, 2);
+      var up2 = $.CGEventCreateMouseEvent(null, ${2 + btnType * 2}, loc, ${btnType});
+      $.CGEventSetIntegerValueField(up2, 1, 2);
+      $.CGEventPost(0, down1);
+      $.CGEventPost(0, up1);
+      $.CGEventPost(0, down2);
+      $.CGEventPost(0, up2);
+      $.CFRelease(down1);
+      $.CFRelease(up1);
+      $.CFRelease(down2);
+      $.CFRelease(up2);
+    `);
+        return;
+    }
+    // Fallback: two clicks
+    await click(x, y, button, _platform);
+    await new Promise(r => setTimeout(r, 50));
+    await click(x, y, button, _platform);
+}
+export async function move(x, y, _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("move", { x, y });
+        return;
+    }
+    if (_platform === "darwin") {
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      var loc = $.CGPointMake(${x}, ${y});
+      var ev = $.CGEventCreateMouseEvent(null, 5, loc, 0);
+      $.CGEventPost(0, ev);
+      $.CFRelease(ev);
+    `);
+        return;
+    }
+    if (_platform === "linux") {
+        await execFileAsync("xdotool", ["mousemove", String(x), String(y)]);
+        return;
+    }
+    throw new Error("move not implemented for Windows");
+}
+export async function drag(fromX, fromY, toX, toY, button = "left", duration = 300, _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("drag", { fromX, fromY, toX, toY, button, duration });
+        return;
+    }
+    if (_platform === "darwin") {
+        const btnType = { left: 0, right: 1, middle: 2 }[button];
+        const steps = Math.max(2, Math.min(60, Math.ceil(duration / 16)));
+        const delayMicros = Math.max(0, Math.floor((duration * 1000) / steps));
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      ObjC.import('stdlib');
+      var from = $.CGPointMake(${fromX}, ${fromY});
+      var to = $.CGPointMake(${toX}, ${toY});
+      var down = $.CGEventCreateMouseEvent(null, ${1 + btnType * 2}, from, ${btnType});
+      $.CGEventPost(0, down);
+      $.CFRelease(down);
+      for (var i = 1; i <= ${steps}; i++) {
+        var t = i / ${steps};
+        var x = ${fromX} + (${toX} - ${fromX}) * t;
+        var y = ${fromY} + (${toY} - ${fromY}) * t;
+        var pt = $.CGPointMake(x, y);
+        var moveEv = $.CGEventCreateMouseEvent(null, 6, pt, ${btnType});
+        $.CGEventPost(0, moveEv);
+        $.CFRelease(moveEv);
+        if (${delayMicros} > 0 && i < ${steps}) $.usleep(${delayMicros});
+      }
+      var up = $.CGEventCreateMouseEvent(null, ${2 + btnType * 2}, to, ${btnType});
+      $.CGEventPost(0, up);
+      $.CFRelease(up);
+    `);
+        return;
+    }
+    if (_platform === "linux") {
+        await execFileAsync("xdotool", [
+            "mousemove", String(fromX), String(fromY),
+            "mousedown", String({ left: 1, right: 3, middle: 2 }[button]),
+        ]);
+        await execFileAsync("xdotool", ["mousemove", String(toX), String(toY)]);
+        await execFileAsync("xdotool", [
+            "mouseup", String({ left: 1, right: 3, middle: 2 }[button]),
+        ]);
+        return;
+    }
+    throw new Error("drag not implemented for Windows");
+}
+export async function scroll(x, y, deltaX, deltaY, _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("scroll", { x, y, deltaX, deltaY });
+        return;
+    }
+    if (_platform === "darwin") {
+        const verticalDelta = -deltaY;
+        const horizontalDelta = deltaX;
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      var loc = $.CGPointMake(${x}, ${y});
+      var ev = $.CGEventCreateScrollWheelEvent(null, 1, 2, ${verticalDelta}, ${horizontalDelta});
+      $.CGEventPost(0, ev);
+      $.CFRelease(ev);
+    `);
+        return;
+    }
+    if (_platform === "linux") {
+        const verticalButton = deltaY < 0 ? "4" : "5";
+        for (let i = 0; i < Math.abs(deltaY); i++) {
+            await execFileAsync("xdotool", ["click", verticalButton]);
+        }
+        const horizontalButton = deltaX < 0 ? "6" : "7";
+        for (let i = 0; i < Math.abs(deltaX); i++) {
+            await execFileAsync("xdotool", ["click", horizontalButton]);
+        }
+        return;
+    }
+    throw new Error("scroll not implemented for Windows");
+}
+// ── Keyboard operations (CGEvent — background) ────────────────────────────
+export async function typeText(text, delay = 20, _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("typeText", { text: text.slice(0, 50), delay });
+        return;
+    }
+    if (!text)
+        return;
+    if (_platform === "darwin") {
+        // Character -> { keyCode, shift? } map for CGEvent injection
+        const CHAR_TO_KEY = {};
+        // Lowercase letters
+        const letterMap = {
+            a: 0, s: 1, d: 2, f: 3, h: 4, g: 5, z: 6, x: 7, c: 8, v: 9,
+            b: 11, q: 12, w: 13, e: 14, r: 15, y: 16, t: 17,
+            o: 31, u: 32, i: 33, p: 34, l: 37, j: 38, k: 40,
+            n: 45, m: 46,
+        };
+        for (const [ch, code] of Object.entries(letterMap)) {
+            CHAR_TO_KEY[ch] = { code };
+            CHAR_TO_KEY[ch.toUpperCase()] = { code, shift: true };
+        }
+        // Digits
+        const digitMap = {
+            "1": 18, "2": 19, "3": 20, "4": 21, "5": 23,
+            "6": 22, "7": 26, "8": 28, "9": 25, "0": 29,
+        };
+        for (const [ch, code] of Object.entries(digitMap)) {
+            CHAR_TO_KEY[ch] = { code };
+        }
+        // Unshifted symbols
+        CHAR_TO_KEY["="] = { code: 24 };
+        CHAR_TO_KEY["-"] = { code: 27 };
+        CHAR_TO_KEY["["] = { code: 33 };
+        CHAR_TO_KEY["]"] = { code: 30 };
+        CHAR_TO_KEY["\\"] = { code: 42 };
+        CHAR_TO_KEY[";"] = { code: 41 };
+        CHAR_TO_KEY["'"] = { code: 39 };
+        CHAR_TO_KEY[","] = { code: 43 };
+        CHAR_TO_KEY["/"] = { code: 44 };
+        CHAR_TO_KEY["."] = { code: 47 };
+        CHAR_TO_KEY["`"] = { code: 50 };
+        CHAR_TO_KEY[" "] = { code: 49 };
+        // Shifted symbols
+        CHAR_TO_KEY["!"] = { code: 18, shift: true };
+        CHAR_TO_KEY["@"] = { code: 19, shift: true };
+        CHAR_TO_KEY["#"] = { code: 20, shift: true };
+        CHAR_TO_KEY["$"] = { code: 21, shift: true };
+        CHAR_TO_KEY["%"] = { code: 23, shift: true };
+        CHAR_TO_KEY["^"] = { code: 22, shift: true };
+        CHAR_TO_KEY["&"] = { code: 26, shift: true };
+        CHAR_TO_KEY["*"] = { code: 28, shift: true };
+        CHAR_TO_KEY["("] = { code: 25, shift: true };
+        CHAR_TO_KEY[")"] = { code: 29, shift: true };
+        CHAR_TO_KEY["_"] = { code: 27, shift: true };
+        CHAR_TO_KEY["+"] = { code: 24, shift: true };
+        CHAR_TO_KEY["{"] = { code: 33, shift: true };
+        CHAR_TO_KEY["}"] = { code: 30, shift: true };
+        CHAR_TO_KEY["|"] = { code: 42, shift: true };
+        CHAR_TO_KEY[":"] = { code: 41, shift: true };
+        CHAR_TO_KEY['"'] = { code: 39, shift: true };
+        CHAR_TO_KEY["<"] = { code: 43, shift: true };
+        CHAR_TO_KEY[">"] = { code: 47, shift: true };
+        CHAR_TO_KEY["?"] = { code: 44, shift: true };
+        CHAR_TO_KEY["~"] = { code: 50, shift: true };
+        const SHIFT_FLAG = 0x00020000;
+        // Partition text into CGEvent-typable runs and fallback runs
+        const batches = [];
+        let currentFallback = "";
+        let currentCG = [];
+        const flushCG = () => {
+            if (currentCG.length > 0) {
+                batches.push({ cgEvent: true, chars: currentCG });
+                currentCG = [];
+            }
+        };
+        const flushFallback = () => {
+            if (currentFallback.length > 0) {
+                batches.push({ cgEvent: false, chars: currentFallback });
+                currentFallback = "";
+            }
+        };
+        for (const ch of text) {
+            const entry = CHAR_TO_KEY[ch];
+            if (entry) {
+                flushFallback();
+                currentCG.push({ code: entry.code, shift: !!entry.shift });
+            }
+            else {
+                flushCG();
+                currentFallback += ch;
+            }
+        }
+        flushCG();
+        flushFallback();
+        // Process each batch
+        for (const batch of batches) {
+            if (batch.cgEvent && Array.isArray(batch.chars)) {
+                // Build a single JXA script that types all chars in this CGEvent batch
+                const keyStatements = batch.chars.map(({ code, shift }) => {
+                    const flags = shift ? SHIFT_FLAG : 0;
+                    return `
+            kd = $.CGEventCreateKeyboardEvent(null, ${code}, true);
+            ku = $.CGEventCreateKeyboardEvent(null, ${code}, false);
+            if (${flags}) { $.CGEventSetFlags(kd, ${flags}); $.CGEventSetFlags(ku, ${flags}); }
+            $.CGEventPost(0, kd);
+            $.CGEventPost(0, ku);
+            $.CFRelease(kd);
+            $.CFRelease(ku);`;
+                }).join("\n");
+                await runJXA(`
+          ObjC.import('CoreGraphics');
+          var kd, ku;
+          ${keyStatements}
+        `);
+            }
+            else {
+                // Fallback: use osascript keystroke for unsupported chars (emoji, CJK, etc.)
+                const escaped = escapeAppleScriptString(batch.chars);
+                await execFileAsync("/usr/bin/osascript", [
+                    "-e", `tell application "System Events" to keystroke "${escaped}"`,
+                ], { timeout: 5000 });
+            }
+        }
+        return;
+    }
+    if (_platform === "linux") {
+        await execFileAsync("xdotool", [
+            "type", "--delay", String(delay), "--", text,
+        ]);
+        return;
+    }
+    throw new Error("typeText not implemented for Windows");
+}
+export async function pressKey(key, modifiers = [], _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("pressKey", { key, modifiers });
+        return;
+    }
+    if (_platform === "darwin") {
+        const keyCode = MAC_KEY_CODES[key.toLowerCase()];
+        if (keyCode === undefined) {
+            throw new Error(`Unknown key: ${key}. Supported keys: ${Object.keys(MAC_KEY_CODES).join(", ")}`);
+        }
+        // Build modifier flags
+        let flags = 0;
+        for (const mod of modifiers) {
+            const flag = MAC_MODIFIER_FLAGS[mod.toLowerCase()];
+            if (flag === undefined) {
+                throw new Error(`Unknown modifier: ${mod}. Supported: ${Object.keys(MAC_MODIFIER_FLAGS).join(", ")}`);
+            }
+            flags |= flag;
+        }
+        await runJXA(`
+      ObjC.import('CoreGraphics');
+      var flags = ${flags};
+      var keyDown = $.CGEventCreateKeyboardEvent(null, ${keyCode}, true);
+      $.CGEventSetFlags(keyDown, flags);
+      $.CGEventPost(0, keyDown);
+      var keyUp = $.CGEventCreateKeyboardEvent(null, ${keyCode}, false);
+      $.CGEventSetFlags(keyUp, flags);
+      $.CGEventPost(0, keyUp);
+      $.CFRelease(keyDown);
+      $.CFRelease(keyUp);
+    `);
+        return;
+    }
+    if (_platform === "linux") {
+        const keyArg = modifiers.length > 0 ? modifiers.join("+") + "+" + key : key;
+        await execFileAsync("xdotool", ["key", keyArg]);
+        return;
+    }
+    throw new Error("pressKey not implemented for Windows");
+}
+export async function pressShortcut(keys, _platform = process.platform) {
+    if (isDryRun()) {
+        logDryRun("pressShortcut", { keys });
+        return;
+    }
+    if (keys.length < 2) {
+        throw new Error("pressShortcut requires at least 2 keys (modifier + key)");
+    }
+    const modifiers = keys.slice(0, -1);
+    const key = keys[keys.length - 1];
+    await pressKey(key, modifiers, _platform);
+}
+// ── Cursor position ───────────────────────────────────────────────────────
+export async function getCursorPosition(_platform = process.platform) {
+    if (_platform === "darwin") {
+        const result = await runJXA(`
+      ObjC.import('CoreGraphics');
+      var ev = $.CGEventCreate(null);
+      var loc = $.CGEventGetLocation(ev);
+      $.CFRelease(ev);
+      return JSON.stringify({x: loc.x, y: loc.y});
+    `);
+        return JSON.parse(result);
+    }
+    if (_platform === "linux") {
+        const { stdout } = await execFileAsync("xdotool", ["getmouselocation"]);
+        const match = stdout.match(/x:(\d+)\s+y:(\d+)/);
+        if (!match)
+            throw new Error("Failed to parse cursor position");
+        return { x: parseInt(match[1]), y: parseInt(match[2]) };
+    }
+    throw new Error("getCursorPosition not implemented for Windows");
+}

package/dist/src/utils/screenshot.d.ts

@@ -0,0 +1,20 @@
+export interface ScreenshotEncodeOptions {
+    format?: "png" | "jpeg";
+    maxWidth?: number;
+}
+/**
+ * Capture the full screen and return a base64-encoded PNG string.
+ */
+export declare function captureFullScreen(options?: ScreenshotEncodeOptions): Promise<string>;
+/**
+ * Capture a specific window by its ID and return a base64-encoded PNG string.
+ *
+ * - macOS: windowId is the CGWindowID (use `osascript -e 'tell app "System Events" ...'` or Quartz).
+ * - Linux: windowId is the X11 window id (xdotool style).
+ * - Windows: windowId is the native HWND (hex or decimal).
+ */
+export declare function captureWindow(windowId: number | string, options?: ScreenshotEncodeOptions): Promise<string>;
+/**
+ * Capture a specific screen region and return a base64-encoded PNG string.
+ */
+export declare function captureRegion(x: number, y: number, width: number, height: number, options?: ScreenshotEncodeOptions): Promise<string>;

package/dist/src/utils/screenshot.js

@@ -0,0 +1,157 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFile, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function getPlatform() {
+    const p = process.platform;
+    if (p === "darwin" || p === "linux" || p === "win32")
+        return p;
+    throw new Error(`Unsupported platform: ${p}`);
+}
+async function tempImagePath(extension = "png") {
+    return join(tmpdir(), `ucu-screenshot-${randomUUID()}.${extension}`);
+}
+async function readAndClean(filePath) {
+    const buf = await readFile(filePath);
+    await unlink(filePath).catch(() => { });
+    return buf.toString("base64");
+}
+async function encodeForClient(filePath, options = {}) {
+    const platform = getPlatform();
+    const targetFormat = options.format ?? "png";
+    const maxWidth = options.maxWidth && options.maxWidth > 0 ? Math.round(options.maxWidth) : undefined;
+    if (platform !== "darwin" || (!maxWidth && targetFormat === "png")) {
+        return readAndClean(filePath);
+    }
+    const cleanup = [filePath];
+    let currentPath = filePath;
+    try {
+        if (maxWidth) {
+            const resizedPath = await tempImagePath(extname(currentPath).replace(".", "") || "png");
+            cleanup.push(resizedPath);
+            await execFileAsync("/usr/bin/sips", ["-Z", String(maxWidth), currentPath, "--out", resizedPath], { timeout: 15000 });
+            currentPath = resizedPath;
+        }
+        if (targetFormat === "jpeg") {
+            const jpegPath = await tempImagePath("jpg");
+            cleanup.push(jpegPath);
+            await execFileAsync("/usr/bin/sips", ["-s", "format", "jpeg", currentPath, "--out", jpegPath], { timeout: 15000 });
+            currentPath = jpegPath;
+        }
+        const buf = await readFile(currentPath);
+        return buf.toString("base64");
+    }
+    finally {
+        await Promise.all(cleanup.map((path) => unlink(path).catch(() => { })));
+    }
+}
+/**
+ * Capture the full screen and return a base64-encoded PNG string.
+ */
+export async function captureFullScreen(options) {
+    const platform = getPlatform();
+    const outFile = await tempImagePath("png");
+    switch (platform) {
+        case "darwin":
+            await execFileAsync("screencapture", ["-x", outFile]);
+            break;
+        case "linux":
+            await execFileAsync("scrot", [outFile]);
+            break;
+        case "win32":
+            await execFileAsync("powershell", [
+                "-NoProfile",
+                "-Command",
+                `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::PrimaryScreen | ForEach-Object { $bmp = New-Object System.Drawing.Bitmap($_.Bounds.Width, $_.Bounds.Height); $g = [System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen($_.Bounds.Location, [System.Drawing.Point]::Empty, $_.Bounds.Size); $bmp.Save('${outFile.replace(/'/g, "''").replace(/\\/g, "\\\\")}'); $g.Dispose(); $bmp.Dispose() }`,
+            ]);
+            break;
+    }
+    return encodeForClient(outFile, options);
+}
+/**
+ * Capture a specific window by its ID and return a base64-encoded PNG string.
+ *
+ * - macOS: windowId is the CGWindowID (use `osascript -e 'tell app "System Events" ...'` or Quartz).
+ * - Linux: windowId is the X11 window id (xdotool style).
+ * - Windows: windowId is the native HWND (hex or decimal).
+ */
+export async function captureWindow(windowId, options) {
+    const platform = getPlatform();
+    const outFile = await tempImagePath("png");
+    switch (platform) {
+        case "darwin":
+            // screencapture -l<windowId> captures a specific window
+            await execFileAsync("screencapture", ["-x", `-l${windowId}`, outFile]);
+            break;
+        case "linux": {
+            // Use import from xdotool / xwd + convert
+            const wid = String(windowId);
+            // xwd -> convert to png via ImageMagick
+            const xwdFile = outFile.replace(/\.png$/, ".xwd");
+            await execFileAsync("xwd", ["-id", wid, "-out", xwdFile]);
+            await execFileAsync("convert", [xwdFile, outFile]);
+            await unlink(xwdFile).catch(() => { });
+            break;
+        }
+        case "win32":
+            // PowerShell: capture a specific window handle
+            await execFileAsync("powershell", [
+                "-NoProfile",
+                "-Command",
+                `Add-Type -AssemblyName System.Drawing; Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using System.Drawing;
+public class WinCapture {
+  [DllImport("user32.dll")] public static extern IntPtr GetWindowRect(IntPtr hWnd, out RECT r);
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }
+  public static void CaptureWindow(IntPtr hWnd, string path) {
+    RECT r; GetWindowRect(hWnd, out r);
+    int w = r.Right - r.Left, h = r.Bottom - r.Top;
+    if (w <= 0 || h <= 0) throw new Exception("Invalid window size");
+    var bmp = new Bitmap(w, h);
+    var g = Graphics.FromImage(bmp);
+    g.CopyFromScreen(r.Left, r.Top, 0, 0, new Size(w, h));
+    bmp.Save(path);
+    g.Dispose(); bmp.Dispose();
+  }
+}
+'@; [WinCapture]::CaptureWindow([IntPtr]${windowId}, '${outFile.replace(/'/g, "''").replace(/\\/g, "\\\\")}')`,
+            ]);
+            break;
+    }
+    return encodeForClient(outFile, options);
+}
+/**
+ * Capture a specific screen region and return a base64-encoded PNG string.
+ */
+export async function captureRegion(x, y, width, height, options) {
+    const platform = getPlatform();
+    const outFile = await tempImagePath("png");
+    switch (platform) {
+        case "darwin":
+            // screencapture -R<x,y,w,h>
+            await execFileAsync("screencapture", ["-x", `-R${x},${y},${width},${height}`, outFile]);
+            break;
+        case "linux":
+            // scrot with --select for region, but that is interactive.
+            // Use import: +crop instead
+            await execFileAsync("import", [
+                "-window", "root",
+                "-crop", `${width}x${height}+${x}+${y}`,
+                outFile,
+            ]);
+            break;
+        case "win32":
+            await execFileAsync("powershell", [
+                "-NoProfile",
+                "-Command",
+                `Add-Type -AssemblyName System.Drawing; $bmp = New-Object System.Drawing.Bitmap(${width}, ${height}); $g = [System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen(${x}, ${y}, 0, 0, [System.Drawing.Size]::new(${width}, ${height})); $bmp.Save('${outFile.replace(/'/g, "''").replace(/\\/g, "\\\\")}'); $g.Dispose(); $bmp.Dispose()`,
+            ]);
+            break;
+    }
+    return encodeForClient(outFile, options);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ucu-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Universal Computer Use \u2014 desktop automation for AI agents via Model Context Protocol",
+  "type": "module",
+  "bin": {
+    "ucu-mcp": "./dist/bin/ucu-mcp.js"
+  },
+  "files": [
+    "dist/bin/",
+    "dist/src/",
+    "dist/index.js",
+    "dist/index.d.ts",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/bin/ucu-mcp.js",
+    "dev": "tsx bin/ucu-mcp.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run tests/integration/",
+    "test:macos-gui": "UCU_MACOS_GUI_SMOKE=1 vitest run tests/integration/macos-gui-smoke.test.ts"
+  },
+  "keywords": [
+    "mcp",
+    "computer-use",
+    "desktop-automation",
+    "macos",
+    "accessibility",
+    "ai-agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/2876674942/ucu-mcp-backup.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.7"
+  }
+}