ucu-mcp 0.5.1 → 0.6.0

package/dist/src/platform/macos/input.js

@@ -2,13 +2,37 @@ import { execFileSync } from "node:child_process";
 import { click as inputClick, doubleClick as inputDoubleClick, move as inputMove, drag as inputDrag, scroll as inputScroll, typeText, pressShortcut } from "../../utils/input.js";
 import { PlatformError } from "../../util/errors.js";
 import { rethrowInputError, errorMessage } from "./helpers.js";
+/**
+ * Process names that must NEVER receive per-process input injection (security).
+ * Per-process posting bypasses the frontmost/focus requirement, so without this
+ * denylist an attacker could deliver keystrokes/clicks directly into a password
+ * manager or auth dialog. These fall back to HID-tap (which at least requires
+ * the app to be frontmost / visible to the user).
+ */
+const SENSITIVE_PROCESS_HINTS = [
+    "keychainaccess", "1password", "lastpass", "bitwarden", "securityagent",
+    "authd", "loginwindow", "applekeychain", "dashlane",
+];
+/** Resolve the per-process event target from the active focus_app target (pid + windowNumber). */
+function targetOf() {
+    const t = this.activeTarget;
+    if (!t || !t.pid || t.pid <= 0)
+        return undefined;
+    // Security: never route per-process events into sensitive apps (password managers / auth).
+    const name = (t.appName || "").toLowerCase();
+    if (SENSITIVE_PROCESS_HINTS.some((h) => name.includes(h))) {
+        return undefined; // forces HID-tap fallback (requires frontmost)
+    }
+    return { pid: t.pid, windowNumber: t.windowNumber };
+}
 export async function click(x, y, button, doubleClick) {
     try {
+        const target = targetOf.call(this);
         if (doubleClick) {
-            await inputDoubleClick(x, y, button);
+            return await inputDoubleClick(x, y, button, process.platform, target);
         }
         else {
-            await inputClick(x, y, button);
+            return await inputClick(x, y, button, process.platform, target);
         }
     }
     catch (error) {
@@ -17,7 +41,7 @@ export async function click(x, y, button, doubleClick) {
 }
 export async function move(x, y) {
     try {
-        await inputMove(x, y);
+        return await inputMove(x, y, process.platform, targetOf.call(this));
     }
     catch (error) {
         rethrowInputError(error, "move");
@@ -25,7 +49,7 @@ export async function move(x, y) {
 }
 export async function drag(startX, startY, endX, endY, button, duration) {
     try {
-        await inputDrag(startX, startY, endX, endY, button, duration);
+        return await inputDrag(startX, startY, endX, endY, button, duration, process.platform, targetOf.call(this));
     }
     catch (error) {
         rethrowInputError(error, "drag");
@@ -33,7 +57,7 @@ export async function drag(startX, startY, endX, endY, button, duration) {
 }
 export async function scroll(x, y, deltaX, deltaY) {
     try {
-        await inputScroll(x, y, deltaX, deltaY);
+        return await inputScroll(x, y, deltaX, deltaY, process.platform, targetOf.call(this));
     }
     catch (error) {
         rethrowInputError(error, "scroll");
@@ -55,8 +79,8 @@ export function getCursorPosition() {
     }
 }
 export async function type(text, delay) {
-    await typeText(text, delay);
+    return await typeText(text, delay, process.platform, targetOf.call(this));
 }
 export async function key(keys) {
-    await pressShortcut(keys);
+    return await pressShortcut(keys, process.platform, targetOf.call(this));
 }

package/dist/src/platform/macos/window.d.ts

@@ -2,5 +2,7 @@ import type { MacOSPlatform } from "./base.js";
 import type { AppInfo, AppTarget, WindowInfo, BrowserContext } from "../base.js";
 export declare function listApps(this: MacOSPlatform): Promise<AppInfo[]>;
 export declare function focusApp(this: MacOSPlatform, app: string): Promise<AppTarget>;
+/** Call the skylight-helper keepAlive command for a pid (best-effort, non-throwing). */
+export declare function keepTargetAxAlive(this: MacOSPlatform, pid: number): Promise<void>;
 export declare function getActiveBrowserContext(this: MacOSPlatform, app?: string): Promise<BrowserContext | undefined>;
 export declare function listWindows(this: MacOSPlatform, _includeMinimized?: boolean): Promise<WindowInfo[]>;

package/dist/src/platform/macos/window.js

@@ -58,14 +58,20 @@ export async function focusApp(app) {
         try {
             const extras = await this.findMenuBarExtra(app);
             if (extras.length > 0) {
+                // Use the hosting process pid (SystemUIServer or app itself) so per-process
+                // event posting works for tray clicks (no global cursor move).
+                const trayPid = extras[0]?.pid || 0;
                 this.activeTarget = {
                     targetId: randomUUID(),
                     appName: app,
-                    pid: 0,
+                    pid: trayPid,
                     windowId: "tray",
                     title: "",
                     capturedAt: new Date().toISOString(),
                 };
+                if (trayPid > 0) {
+                    this.keepTargetAxAlive(trayPid).catch(() => { });
+                }
                 return this.activeTarget;
             }
         }
@@ -90,9 +96,29 @@ export async function focusApp(app) {
         windowId: target.id,
         title: target.title,
         capturedAt: new Date().toISOString(),
+        windowNumber: target.windowNumber,
     };
+    // AX keepalive: keep the target's accessibility tree live when occluded/background,
+    // so AXPress on Electron/Tauri controls doesn't silently no-op. Best-effort.
+    this.keepTargetAxAlive(target.pid).catch(() => { });
     return this.activeTarget;
 }
+/** Call the skylight-helper keepAlive command for a pid (best-effort, non-throwing). */
+export async function keepTargetAxAlive(pid) {
+    const helperPath = resolveNativeHelper.call(this, "skylight", "skylight-helper");
+    if (!helperPath)
+        return;
+    try {
+        execFileSync(helperPath, [], {
+            input: JSON.stringify({ command: "keepAlive", pid }),
+            encoding: "utf8",
+            timeout: 5000,
+        });
+    }
+    catch {
+        // keepAlive is best-effort; ignore failures (helper missing / SPI unavailable).
+    }
+}
 export async function getActiveBrowserContext(app) {
     const appName = app || this.activeTarget?.appName;
     if (!appName)
@@ -201,6 +227,7 @@ function listWindowsNative() {
             bounds: w.bounds,
             isMinimized: !w.isOnScreen,
             isOnScreen: w.isOnScreen,
+            windowNumber: w.windowNumber,
         }));
     }
     catch {

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

@@ -9,14 +9,20 @@
  * Windows: Uses SendInput (stub).
  * Linux: Uses xdotool (stub).
  */
-export declare function click(x: number, y: number, button?: "left" | "right" | "middle", _platform?: string): Promise<void>;
-export declare function doubleClick(x: number, y: number, button?: "left" | "right" | "middle", _platform?: string): Promise<void>;
-export declare function move(x: number, y: number, _platform?: string): Promise<void>;
-export declare function drag(fromX: number, fromY: number, toX: number, toY: number, button?: "left" | "right" | "middle", duration?: number, _platform?: string): Promise<void>;
-export declare function scroll(x: number, y: number, deltaX: number, deltaY: number, _platform?: string): Promise<void>;
-export declare function typeText(text: string, delay?: number, _platform?: string): Promise<void>;
-export declare function pressKey(key: string, modifiers?: string[], _platform?: string): Promise<void>;
-export declare function pressShortcut(keys: string[], _platform?: string): Promise<void>;
+import type { DispatchMethod } from "../platform/base.js";
+/** Per-process event target. When pid > 0, input is routed via skylight-helper (no cursor move). */
+export interface InputTarget {
+    pid?: number;
+    windowNumber?: number;
+}
+export declare function click(x: number, y: number, button?: "left" | "right" | "middle", _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function doubleClick(x: number, y: number, button?: "left" | "right" | "middle", _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function move(x: number, y: number, _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function drag(fromX: number, fromY: number, toX: number, toY: number, button?: "left" | "right" | "middle", duration?: number, _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function scroll(x: number, y: number, deltaX: number, deltaY: number, _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function typeText(text: string, delay?: number, _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function pressKey(key: string, modifiers?: string[], _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
+export declare function pressShortcut(keys: string[], _platform?: string, target?: InputTarget): Promise<DispatchMethod | void>;
 export declare function getCursorPosition(_platform?: string): Promise<{
     x: number;
     y: number;

package/dist/src/utils/input.js

@@ -18,33 +18,93 @@ const execFileAsync = promisify(execFile);
 // ── Native CGEvent helper (macOS) ──────────────────────────────────────
 // JXA (osascript -l JavaScript) cannot call CGEventPost without segfault.
 // We ship a small Swift binary that does native CGEvent injection instead.
+//
+// v0.6.0: two helpers. `skylight-helper` posts events per-process via
+// SLEventPostToPid (private SkyLight SPI) so the global cursor does NOT move
+// and the foreground is NOT stolen — matching Codex computer-use. `cgevent-helper`
+// (legacy) posts to the HID event tap, which moves the cursor. We prefer
+// skylight when a target pid is available; fall back to cgevent otherwise.
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // In dev: src/utils/input.ts → native/cgevent/cgevent-helper
 // In prod: dist/src/utils/input.js → dist/native/cgevent/cgevent-helper
-const nativeHelperPath = join(__dirname, "..", "..", "..", "native", "cgevent", "cgevent-helper");
-// Fallback: try from project root (dev mode)
-const nativeHelperPathAlt = join(__dirname, "..", "..", "native", "cgevent", "cgevent-helper");
+const cgeventHelperPath = join(__dirname, "..", "..", "..", "native", "cgevent", "cgevent-helper");
+const cgeventHelperPathAlt = join(__dirname, "..", "..", "native", "cgevent", "cgevent-helper");
+const skylightHelperPath = join(__dirname, "..", "..", "..", "native", "skylight", "skylight-helper");
+const skylightHelperPathAlt = join(__dirname, "..", "..", "native", "skylight", "skylight-helper");
 import { existsSync } from "node:fs";
-const resolvedNativePath = existsSync(nativeHelperPath) ? nativeHelperPath : nativeHelperPathAlt;
-let _nativeAvailable;
-function isNativeAvailable() {
-    if (_nativeAvailable !== undefined)
-        return _nativeAvailable;
+const resolvedCgeventPath = existsSync(cgeventHelperPath) ? cgeventHelperPath : cgeventHelperPathAlt;
+const resolvedSkylightPath = existsSync(skylightHelperPath) ? skylightHelperPath : skylightHelperPathAlt;
+let _cgeventAvailable;
+let _skylightAvailable;
+function isCgeventAvailable() {
+    if (_cgeventAvailable !== undefined)
+        return _cgeventAvailable;
     try {
-        const stdout = execFileSync(resolvedNativePath, [], {
+        const stdout = execFileSync(resolvedCgeventPath, [], {
             input: '{"command":"ping"}',
             encoding: "utf8",
             timeout: 3000,
         });
-        _nativeAvailable = stdout.includes('"ok"');
+        _cgeventAvailable = stdout.includes('"ok"');
     }
     catch {
-        _nativeAvailable = false;
+        _cgeventAvailable = false;
     }
-    return _nativeAvailable;
+    return _cgeventAvailable;
 }
-function runNativeChecked(payload) {
-    const raw = execFileSync(resolvedNativePath, [], {
+function isSkylightAvailable() {
+    if (_skylightAvailable !== undefined)
+        return _skylightAvailable;
+    if (!existsSync(resolvedSkylightPath)) {
+        _skylightAvailable = false;
+        return false;
+    }
+    try {
+        const stdout = execFileSync(resolvedSkylightPath, [], {
+            input: '{"command":"ping"}',
+            encoding: "utf8",
+            timeout: 3000,
+        });
+        _skylightAvailable = stdout.includes('"ok"');
+    }
+    catch {
+        _skylightAvailable = false;
+    }
+    return _skylightAvailable;
+}
+/** @deprecated use isCgeventAvailable — kept for external callers/tests. */
+function isNativeAvailable() {
+    return isCgeventAvailable();
+}
+/**
+ * Run an input command via the best available helper.
+ * - target.pid > 0 AND skylight available → skylight-helper (per-process, no cursor move). Returns "per-pid".
+ * - otherwise → cgevent-helper (HID tap, moves cursor). Returns "hid-tap".
+ * If skylight is chosen but errors at runtime, falls back to cgevent (HID-tap) rather than throwing.
+ * Throws only if BOTH helpers fail.
+ */
+function runInputChecked(payload, target) {
+    const useSkylight = !!target?.pid && target.pid > 0 && isSkylightAvailable();
+    if (useSkylight) {
+        const fullPayload = { ...payload, pid: target.pid, windowNumber: target.windowNumber };
+        try {
+            const raw = execFileSync(resolvedSkylightPath, [], {
+                input: JSON.stringify(fullPayload),
+                encoding: "utf8",
+                timeout: 10000,
+            }).trim();
+            const resp = JSON.parse(raw);
+            if (!resp.error) {
+                return (resp.method === "per-pid") ? "per-pid" : "hid-tap";
+            }
+            // skylight errored at runtime (SPI filtered / event build failed) → fall through to cgevent.
+        }
+        catch {
+            // skylight crashed/timed out → fall through to cgevent.
+        }
+    }
+    // cgevent path (HID-tap) — the reliable fallback.
+    const raw = execFileSync(resolvedCgeventPath, [], {
         input: JSON.stringify(payload),
         encoding: "utf8",
         timeout: 10000,
@@ -53,6 +113,11 @@ function runNativeChecked(payload) {
     if (resp.error) {
         throw new Error(`native helper error: ${resp.error}`);
     }
+    return "hid-tap";
+}
+/** @deprecated use runInputChecked — kept for external callers/tests. */
+function runNativeChecked(payload) {
+    runInputChecked(payload);
 }
 // ── Dry-run mode ──────────────────────────────────────────────────────────
 const isDryRun = () => process.env.UCU_DRY_RUN === "true";
@@ -112,15 +177,14 @@ async function runJXA(script, timeout = 5000) {
     return stdout.trim();
 }
 // ── Mouse operations (CGEvent — background, no focus steal) ───────────────
-export async function click(x, y, button = "left", _platform = process.platform) {
+export async function click(x, y, button = "left", _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("click", { x, y, button });
         return;
     }
     if (_platform === "darwin") {
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "click", x, y, button });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "click", x, y, button }, target);
         }
         const btnType = { left: 0, right: 1, middle: 2 }[button];
         await runJXA(`
@@ -144,15 +208,14 @@ export async function click(x, y, button = "left", _platform = process.platform)
     // Windows
     throw new Error("click not implemented for Windows");
 }
-export async function doubleClick(x, y, button = "left", _platform = process.platform) {
+export async function doubleClick(x, y, button = "left", _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("doubleClick", { x, y, button });
         return;
     }
     if (_platform === "darwin") {
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "doubleClick", x, y, button });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "doubleClick", x, y, button }, target);
         }
         const btnType = { left: 0, right: 1, middle: 2 }[button];
         await runJXA(`
@@ -182,15 +245,14 @@ export async function doubleClick(x, y, button = "left", _platform = process.pla
     await new Promise(r => setTimeout(r, 50));
     await click(x, y, button, _platform);
 }
-export async function move(x, y, _platform = process.platform) {
+export async function move(x, y, _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("move", { x, y });
         return;
     }
     if (_platform === "darwin") {
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "move", x, y });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "move", x, y }, target);
         }
         await runJXA(`
       ObjC.import('CoreGraphics');
@@ -207,15 +269,14 @@ export async function move(x, y, _platform = process.platform) {
     }
     throw new Error("move not implemented for Windows");
 }
-export async function drag(fromX, fromY, toX, toY, button = "left", duration = 300, _platform = process.platform) {
+export async function drag(fromX, fromY, toX, toY, button = "left", duration = 300, _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("drag", { fromX, fromY, toX, toY, button, duration });
         return;
     }
     if (_platform === "darwin") {
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "drag", fromX, fromY, toX, toY, button, durationMs: duration });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "drag", fromX, fromY, toX, toY, button, durationMs: duration }, target);
         }
         const btnType = { left: 0, right: 1, middle: 2 }[button];
         const steps = Math.max(2, Math.min(60, Math.ceil(duration / 16)));
@@ -257,15 +318,14 @@ export async function drag(fromX, fromY, toX, toY, button = "left", duration = 3
     }
     throw new Error("drag not implemented for Windows");
 }
-export async function scroll(x, y, deltaX, deltaY, _platform = process.platform) {
+export async function scroll(x, y, deltaX, deltaY, _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("scroll", { x, y, deltaX, deltaY });
         return;
     }
     if (_platform === "darwin") {
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "scroll", x, y, deltaX, deltaY });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "scroll", x, y, deltaX, deltaY }, target);
         }
         const verticalDelta = -deltaY;
         const horizontalDelta = deltaX;
@@ -292,7 +352,7 @@ export async function scroll(x, y, deltaX, deltaY, _platform = process.platform)
     throw new Error("scroll not implemented for Windows");
 }
 // ── Keyboard operations (CGEvent — background) ────────────────────────────
-export async function typeText(text, delay = 20, _platform = process.platform) {
+export async function typeText(text, delay = 20, _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("typeText", { text: text.slice(0, 50), delay });
         return;
@@ -377,8 +437,8 @@ export async function typeText(text, delay = 20, _platform = process.platform) {
         // Process each batch
         for (const batch of batches) {
             if (batch.cgEvent && Array.isArray(batch.chars)) {
-                if (isNativeAvailable()) {
-                    runNativeChecked({ command: "typeBatch", keys: batch.chars });
+                if (isCgeventAvailable() || isSkylightAvailable()) {
+                    runInputChecked({ command: "typeBatch", keys: batch.chars }, target);
                 }
                 else {
                     // Build a single JXA script that types all chars in this CGEvent batch
@@ -418,7 +478,7 @@ export async function typeText(text, delay = 20, _platform = process.platform) {
     }
     throw new Error("typeText not implemented for Windows");
 }
-export async function pressKey(key, modifiers = [], _platform = process.platform) {
+export async function pressKey(key, modifiers = [], _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("pressKey", { key, modifiers });
         return;
@@ -443,9 +503,8 @@ export async function pressKey(key, modifiers = [], _platform = process.platform
             }
             flags |= flag;
         }
-        if (isNativeAvailable()) {
-            runNativeChecked({ command: "pressKey", keyCode, flags });
-            return;
+        if (isCgeventAvailable() || isSkylightAvailable()) {
+            return runInputChecked({ command: "pressKey", keyCode, flags }, target);
         }
         await runJXA(`
       ObjC.import('CoreGraphics');
@@ -468,7 +527,7 @@ export async function pressKey(key, modifiers = [], _platform = process.platform
     }
     throw new Error("pressKey not implemented for Windows");
 }
-export async function pressShortcut(keys, _platform = process.platform) {
+export async function pressShortcut(keys, _platform = process.platform, target) {
     if (isDryRun()) {
         logDryRun("pressShortcut", { keys });
         return;
@@ -478,7 +537,7 @@ export async function pressShortcut(keys, _platform = process.platform) {
     }
     const modifiers = keys.slice(0, -1);
     const key = keys[keys.length - 1];
-    await pressKey(key, modifiers, _platform);
+    return await pressKey(key, modifiers, _platform, target);
 }
 // ── Cursor position ───────────────────────────────────────────────────────
 export async function getCursorPosition(_platform = process.platform) {