screenhand 0.1.0 → 0.1.1

package/dist/native/bridge-client.js

@@ -1,173 +0,0 @@
-import { spawn } from "node:child_process";
-import { EventEmitter } from "node:events";
-import path from "node:path";
-import { createInterface } from "node:readline";
-/**
- * Per-method timeout overrides (ms).
- * Methods not listed here use the default 10s timeout.
- */
-const METHOD_TIMEOUTS = {
-    "app.launch": 30_000,
-    "cg.captureScreen": 15_000,
-    "cg.captureWindow": 15_000,
-    "vision.ocr": 20_000,
-    "vision.findText": 20_000,
-};
-/**
- * Resolves the correct native bridge binary path for the current platform.
- */
-function defaultBinaryPath() {
-    const base = import.meta.dirname ?? process.cwd();
-    if (process.platform === "win32") {
-        return path.resolve(base, "../../native/windows-bridge/bin/Release/net8.0-windows/windows-bridge.exe");
-    }
-    // macOS (default)
-    return path.resolve(base, "../../native/macos-bridge/.build/release/macos-bridge");
-}
-/**
- * Platform-aware native bridge client.
- * Spawns the correct bridge binary (macOS Swift or Windows C#) based on the OS,
- * communicating via the same JSON-RPC-over-stdio protocol.
- *
- * Drop-in replacement for the original MacOSBridgeClient.
- */
-export class BridgeClient extends EventEmitter {
-    process = null;
-    nextId = 1;
-    pending = new Map();
-    binaryPath;
-    restarting = false;
-    started = false;
-    constructor(binaryPath) {
-        super();
-        this.binaryPath = binaryPath ?? defaultBinaryPath();
-    }
-    async start() {
-        if (this.started)
-            return;
-        await this.spawn();
-        this.started = true;
-    }
-    async stop() {
-        this.started = false;
-        if (this.process) {
-            this.process.kill();
-            this.process = null;
-        }
-        // Reject all pending
-        for (const [id, pending] of this.pending) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error("Bridge stopped"));
-            this.pending.delete(id);
-        }
-    }
-    async call(method, params, timeoutMs) {
-        const effectiveTimeout = timeoutMs ?? METHOD_TIMEOUTS[method] ?? 10_000;
-        if (!this.process || this.process.exitCode !== null) {
-            await this.restart();
-        }
-        const id = this.nextId++;
-        const request = { id, method };
-        if (params) {
-            request.params = params;
-        }
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Bridge call "${method}" timed out after ${effectiveTimeout}ms`));
-            }, effectiveTimeout);
-            this.pending.set(id, {
-                resolve: resolve,
-                reject,
-                timer,
-            });
-            const line = JSON.stringify(request) + "\n";
-            this.process.stdin.write(line);
-        });
-    }
-    async ping() {
-        return this.call("ping");
-    }
-    async checkPermissions() {
-        return this.call("check_permissions");
-    }
-    async spawn() {
-        const child = spawn(this.binaryPath, [], {
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        child.on("error", (err) => {
-            this.emit("error", err);
-            if (this.started) {
-                this.restart().catch(() => { });
-            }
-        });
-        child.on("exit", (code) => {
-            this.emit("exit", code);
-            if (this.started && !this.restarting) {
-                this.restart().catch(() => { });
-            }
-        });
-        // Parse stdout line by line
-        const rl = createInterface({ input: child.stdout });
-        rl.on("line", (line) => {
-            this.handleLine(line);
-        });
-        // Log stderr
-        child.stderr?.on("data", (data) => {
-            this.emit("stderr", data.toString());
-        });
-        this.process = child;
-    }
-    handleLine(line) {
-        let response;
-        try {
-            response = JSON.parse(line);
-        }
-        catch {
-            return; // Ignore malformed lines
-        }
-        // Event (streaming notification from observer)
-        if (response.event) {
-            this.emit("ax-event", response.event);
-            return;
-        }
-        // Response to a pending request
-        const pending = this.pending.get(response.id);
-        if (!pending)
-            return;
-        this.pending.delete(response.id);
-        clearTimeout(pending.timer);
-        if (response.error) {
-            pending.reject(new Error(response.error.message));
-        }
-        else {
-            pending.resolve(response.result);
-        }
-    }
-    async restart() {
-        if (this.restarting)
-            return;
-        this.restarting = true;
-        // Reject all pending requests
-        for (const [id, pending] of this.pending) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error("Bridge process crashed, restarting"));
-            this.pending.delete(id);
-        }
-        try {
-            if (this.process) {
-                this.process.kill();
-                this.process = null;
-            }
-            await this.spawn();
-            this.emit("restart");
-        }
-        finally {
-            this.restarting = false;
-        }
-    }
-}
-/**
- * @deprecated Use BridgeClient instead. This alias exists for backward compatibility.
- */
-export const MacOSBridgeClient = BridgeClient;

package/dist/native/macos-bridge-client.js

@@ -1,5 +0,0 @@
-/**
- * @deprecated Import from "./bridge-client.js" instead.
- * This file re-exports for backward compatibility.
- */
-export { BridgeClient, BridgeClient as MacOSBridgeClient } from "./bridge-client.js";

package/dist/runtime/accessibility-adapter.js

@@ -1,377 +0,0 @@
-import { toAXRole } from "./ax-role-map.js";
-const POLL_INTERVAL_MS = 100;
-export class AccessibilityAdapter {
-    bridge;
-    sessions = new Map();
-    sessionsByProfile = new Map();
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    async attach(profile) {
-        const existing = this.sessionsByProfile.get(profile);
-        if (existing)
-            return existing.info;
-        // Ensure bridge is started
-        await this.bridge.start();
-        // Check accessibility permissions
-        const perms = await this.bridge.checkPermissions();
-        if (!perms.trusted) {
-            throw new Error("Accessibility permission not granted. Go to System Settings → Privacy & Security → Accessibility and enable this app.");
-        }
-        const info = {
-            sessionId: `ax_session_${profile}_${Date.now()}`,
-            profile,
-            createdAt: new Date().toISOString(),
-            adapterType: "accessibility",
-        };
-        // Default to frontmost app
-        const frontmost = await this.bridge.call("app.frontmost");
-        const state = {
-            info,
-            pid: frontmost.pid,
-            bundleId: frontmost.bundleId,
-            appName: frontmost.name,
-        };
-        this.sessions.set(info.sessionId, state);
-        this.sessionsByProfile.set(profile, state);
-        return info;
-    }
-    async getAppContext(sessionId) {
-        const state = this.requireSession(sessionId);
-        // Get window title from AX tree
-        let windowTitle = "";
-        try {
-            const tree = await this.bridge.call("ax.getElementTree", {
-                pid: state.pid,
-                maxDepth: 1,
-            });
-            const window = tree.children?.find((c) => c.role === "AXWindow");
-            windowTitle = window?.title ?? "";
-        }
-        catch {
-            // Ignore tree errors
-        }
-        return {
-            bundleId: state.bundleId,
-            appName: state.appName,
-            pid: state.pid,
-            windowTitle,
-        };
-    }
-    async getPageMeta(sessionId) {
-        const ctx = await this.getAppContext(sessionId);
-        return {
-            url: ctx.url ?? `app://${ctx.bundleId}`,
-            title: ctx.windowTitle || ctx.appName,
-        };
-    }
-    async navigate(sessionId, url, _timeoutMs) {
-        // For desktop apps, "navigate" means launching/focusing an app by bundle ID
-        const state = this.requireSession(sessionId);
-        if (url.startsWith("app://")) {
-            const bundleId = url.slice(6);
-            const result = await this.bridge.call("app.launch", { bundleId });
-            state.pid = result.pid;
-            state.bundleId = result.bundleId;
-            state.appName = result.appName;
-        }
-        return this.getPageMeta(sessionId);
-    }
-    async locate(sessionId, target, timeoutMs) {
-        const state = this.requireSession(sessionId);
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            try {
-                const params = this.buildFindParams(target, state.pid);
-                const result = await this.bridge.call("ax.findElement", params);
-                if (result) {
-                    const located = {
-                        handleId: result.handleId,
-                        locatorUsed: `ax:${target.type}`,
-                        role: result.role,
-                        label: result.title,
-                    };
-                    if (result.bounds) {
-                        located.coordinates = result.bounds;
-                    }
-                    return located;
-                }
-            }
-            catch {
-                // Element not found yet, keep polling
-            }
-            await sleep(POLL_INTERVAL_MS);
-        }
-        return null;
-    }
-    async click(sessionId, element) {
-        const state = this.requireSession(sessionId);
-        const elementPath = this.parseElementPath(element.handleId);
-        if (elementPath) {
-            await this.bridge.call("ax.performAction", {
-                pid: state.pid,
-                elementPath,
-                action: "AXPress",
-            });
-        }
-        else if (element.coordinates) {
-            // Fallback to coordinate click
-            const cx = element.coordinates.x + element.coordinates.width / 2;
-            const cy = element.coordinates.y + element.coordinates.height / 2;
-            await this.bridge.call("cg.mouseClick", { x: cx, y: cy });
-        }
-        else {
-            throw new Error("Cannot click: no element path or coordinates");
-        }
-    }
-    async setValue(sessionId, element, text, clear) {
-        const state = this.requireSession(sessionId);
-        const elementPath = this.parseElementPath(element.handleId);
-        if (clear && elementPath) {
-            // Try AX value set first
-            try {
-                await this.bridge.call("ax.setElementValue", {
-                    pid: state.pid,
-                    elementPath,
-                    value: text,
-                });
-                return;
-            }
-            catch {
-                // Fallback: click, select all, type
-            }
-        }
-        // Fallback: click to focus, select all if clearing, then type
-        await this.click(sessionId, element);
-        await sleep(50);
-        if (clear) {
-            await this.bridge.call("cg.keyCombo", { keys: ["cmd", "a"] });
-            await sleep(50);
-        }
-        await this.bridge.call("cg.typeText", { text });
-    }
-    async getValue(sessionId, element) {
-        const state = this.requireSession(sessionId);
-        const elementPath = this.parseElementPath(element.handleId);
-        if (!elementPath)
-            return "";
-        const result = await this.bridge.call("ax.getElementValue", {
-            pid: state.pid,
-            elementPath,
-        });
-        return result.value;
-    }
-    async waitFor(sessionId, condition, timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            const met = await this.checkCondition(sessionId, condition);
-            if (met)
-                return true;
-            await sleep(POLL_INTERVAL_MS);
-        }
-        return false;
-    }
-    async extract(sessionId, target, format) {
-        const state = this.requireSession(sessionId);
-        if (format === "text") {
-            // Get element tree and extract text content
-            const element = await this.locate(sessionId, target, 1500);
-            if (!element)
-                throw new Error("Extract target not found");
-            const result = await this.getValue(sessionId, element);
-            return result || element.label || "";
-        }
-        if (format === "json") {
-            // Return the AX tree as JSON
-            const tree = await this.bridge.call("ax.getElementTree", {
-                pid: state.pid,
-                maxDepth: 3,
-            });
-            return tree;
-        }
-        // table format: return element tree in tabular form
-        const tree = await this.bridge.call("ax.getElementTree", {
-            pid: state.pid,
-            maxDepth: 2,
-        });
-        return {
-            headers: ["role", "title", "value"],
-            rows: this.flattenTree(tree).map((n) => [n.role, n.title ?? "", n.value ?? ""]),
-        };
-    }
-    async screenshot(sessionId, region) {
-        const state = this.requireSession(sessionId);
-        // Get window list to find the window ID for the app
-        const windows = await this.bridge.call("app.windows");
-        const appWindow = windows.find((w) => w.pid === state.pid);
-        if (appWindow) {
-            const result = await this.bridge.call("cg.captureWindow", { windowId: appWindow.windowId });
-            return result.path;
-        }
-        // Fallback to screen capture with region
-        const result = await this.bridge.call("cg.captureScreen", region ? { region } : {});
-        return result.path;
-    }
-    // ── Desktop-specific methods ──
-    async launchApp(sessionId, bundleId) {
-        const state = this.requireSession(sessionId);
-        const result = await this.bridge.call("app.launch", { bundleId });
-        // Update session to track new app
-        state.pid = result.pid;
-        state.bundleId = result.bundleId;
-        state.appName = result.appName;
-        return {
-            bundleId: result.bundleId,
-            appName: result.appName,
-            pid: result.pid,
-            windowTitle: "",
-        };
-    }
-    async focusApp(sessionId, bundleId) {
-        const state = this.requireSession(sessionId);
-        await this.bridge.call("app.focus", { bundleId });
-        // Update PID if different app
-        if (bundleId !== state.bundleId) {
-            const apps = await this.bridge.call("app.list");
-            const app = apps.find((a) => a.bundleId === bundleId);
-            if (app) {
-                state.pid = app.pid;
-                state.bundleId = bundleId;
-                state.appName = app.name;
-            }
-        }
-    }
-    async listApps(_sessionId) {
-        return this.bridge.call("app.list");
-    }
-    async listWindows(_sessionId) {
-        return this.bridge.call("app.windows");
-    }
-    async menuClick(sessionId, menuPath) {
-        const state = this.requireSession(sessionId);
-        await this.bridge.call("ax.menuClick", { pid: state.pid, menuPath });
-    }
-    async keyCombo(_sessionId, keys) {
-        await this.bridge.call("cg.keyCombo", { keys });
-    }
-    async elementTree(sessionId, maxDepth, _root) {
-        const state = this.requireSession(sessionId);
-        return this.bridge.call("ax.getElementTree", {
-            pid: state.pid,
-            maxDepth: maxDepth ?? 5,
-        });
-    }
-    async drag(sessionId, from, to) {
-        if (!from.coordinates || !to.coordinates) {
-            throw new Error("Drag requires elements with coordinates");
-        }
-        const fromX = from.coordinates.x + from.coordinates.width / 2;
-        const fromY = from.coordinates.y + from.coordinates.height / 2;
-        const toX = to.coordinates.x + to.coordinates.width / 2;
-        const toY = to.coordinates.y + to.coordinates.height / 2;
-        await this.bridge.call("cg.mouseDrag", { fromX, fromY, toX, toY });
-    }
-    async scroll(_sessionId, direction, amount, element) {
-        let x = 500;
-        let y = 400;
-        if (element?.coordinates) {
-            x = element.coordinates.x + element.coordinates.width / 2;
-            y = element.coordinates.y + element.coordinates.height / 2;
-        }
-        const deltaMap = {
-            up: { deltaX: 0, deltaY: -amount },
-            down: { deltaX: 0, deltaY: amount },
-            left: { deltaX: -amount, deltaY: 0 },
-            right: { deltaX: amount, deltaY: 0 },
-        };
-        const delta = deltaMap[direction];
-        await this.bridge.call("cg.scroll", { x, y, ...delta });
-    }
-    // ── Private helpers ──
-    requireSession(sessionId) {
-        const state = this.sessions.get(sessionId);
-        if (!state)
-            throw new Error(`Session not found: ${sessionId}`);
-        return state;
-    }
-    buildFindParams(target, pid) {
-        const params = { pid };
-        switch (target.type) {
-            case "role":
-                params.role = toAXRole(target.role);
-                params.title = target.name;
-                params.exact = target.exact ?? true;
-                break;
-            case "text":
-                params.title = target.value;
-                params.exact = target.exact ?? true;
-                break;
-            case "selector":
-                // For AX, treat selector as an identifier
-                params.identifier = target.value;
-                break;
-            case "ax_path":
-                // Direct path resolution handled differently
-                params.role = target.path[target.path.length - 1];
-                break;
-            case "ax_attribute":
-                params[target.attribute] = target.value;
-                break;
-            case "coordinates":
-                // Can't find by coordinates via AX, will fallback to vision
-                throw new Error("Cannot locate by coordinates using accessibility adapter");
-            case "image":
-                throw new Error("Cannot locate by image using accessibility adapter");
-        }
-        return params;
-    }
-    parseElementPath(handleId) {
-        // Handle IDs from the bridge are formatted as "ax_0_1_2"
-        if (!handleId.startsWith("ax_"))
-            return null;
-        const parts = handleId.slice(3).split("_");
-        const indices = parts.map(Number).filter((n) => !isNaN(n));
-        return indices.length > 0 ? indices : null;
-    }
-    async checkCondition(sessionId, condition) {
-        switch (condition.type) {
-            case "element_exists": {
-                const found = await this.locate(sessionId, condition.target, 100);
-                return found !== null;
-            }
-            case "element_gone": {
-                const found = await this.locate(sessionId, condition.target, 100);
-                return found === null;
-            }
-            case "window_title_matches": {
-                const ctx = await this.getAppContext(sessionId);
-                return new RegExp(condition.regex).test(ctx.windowTitle);
-            }
-            case "text_appears": {
-                const found = await this.locate(sessionId, { type: "text", value: condition.text }, 100);
-                return found !== null;
-            }
-            case "app_idle":
-                // Simplified: always return true after a short delay
-                return true;
-            case "selector_visible":
-            case "selector_hidden":
-            case "url_matches":
-            case "spinner_disappears":
-                // Browser-specific conditions not fully supported
-                return false;
-        }
-    }
-    flattenTree(node) {
-        const result = [node];
-        if (node.children) {
-            for (const child of node.children) {
-                result.push(...this.flattenTree(child));
-            }
-        }
-        return result;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/dist/runtime/app-adapter.js

@@ -1,48 +0,0 @@
-/**
- * Placeholder adapter that returns stubs for all methods.
- * Used for testing or when no real adapter is configured.
- */
-export class PlaceholderAppAdapter {
-    async attach(profile) {
-        return {
-            sessionId: `session_${profile}_${Date.now()}`,
-            profile,
-            createdAt: new Date().toISOString(),
-        };
-    }
-    async getAppContext(_sessionId) {
-        return {
-            bundleId: "com.placeholder",
-            appName: "Placeholder",
-            pid: 0,
-            windowTitle: "Placeholder Session",
-        };
-    }
-    async getPageMeta(_sessionId) {
-        return { url: "about:blank", title: "Placeholder Session" };
-    }
-    async navigate(_sessionId, url, _timeoutMs) {
-        return { url, title: "Placeholder Navigation" };
-    }
-    async locate(_sessionId, _target, _timeoutMs) {
-        throw new Error("App adapter not implemented: locate");
-    }
-    async click(_sessionId, _element) {
-        throw new Error("App adapter not implemented: click");
-    }
-    async setValue(_sessionId, _element, _text, _clear) {
-        throw new Error("App adapter not implemented: setValue");
-    }
-    async getValue(_sessionId, _element) {
-        throw new Error("App adapter not implemented: getValue");
-    }
-    async waitFor(_sessionId, _condition, _timeoutMs) {
-        throw new Error("App adapter not implemented: waitFor");
-    }
-    async extract(_sessionId, _target, _format) {
-        throw new Error("App adapter not implemented: extract");
-    }
-    async screenshot(_sessionId, _region) {
-        throw new Error("App adapter not implemented: screenshot");
-    }
-}