usecomputer 0.0.3 → 0.0.4

package/dist/bridge.js

@@ -1,13 +1,67 @@
-// Native bridge that maps typed TS calls to the Zig N-API command dispatcher.
+// Native bridge that maps typed TS calls to direct Zig N-API methods.
 import { native } from './native-lib.js';
+import { z } from 'zod';
+const displayInfoSchema = z.object({
+    id: z.number(),
+    index: z.number(),
+    name: z.string(),
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    scale: z.number(),
+    isPrimary: z.boolean(),
+});
+const displayListSchema = z.array(displayInfoSchema);
+const windowInfoSchema = z.object({
+    id: z.number(),
+    ownerPid: z.number(),
+    ownerName: z.string(),
+    title: z.string(),
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    desktopIndex: z.number(),
+});
+const windowListSchema = z.array(windowInfoSchema);
 const unavailableError = 'Native backend is unavailable. Build it with `pnpm build:native` or `zig build` in usecomputer/.';
-function execute({ nativeModule, command, payload, }) {
-    const response = nativeModule.execute(command, JSON.stringify(payload));
-    const parsed = JSON.parse(response);
-    if (!parsed.ok) {
-        return new Error(parsed.error || `Native command failed: ${command}`);
+class NativeBridgeError extends Error {
+    code;
+    command;
+    constructor({ message, code, command, }) {
+        super(message);
+        this.name = 'NativeBridgeError';
+        this.code = code;
+        this.command = command;
     }
-    return parsed.data;
+}
+function unwrapCommand({ result, fallbackCommand, }) {
+    if (result.ok) {
+        return null;
+    }
+    const message = result.error?.message || `Native command failed: ${fallbackCommand}`;
+    return new NativeBridgeError({
+        message,
+        code: result.error?.code,
+        command: result.error?.command || fallbackCommand,
+    });
+}
+function unwrapData({ result, fallbackCommand, }) {
+    if (result.ok) {
+        if (result.data === undefined) {
+            return new NativeBridgeError({
+                message: `Native command returned no data: ${fallbackCommand}`,
+                command: fallbackCommand,
+            });
+        }
+        return result.data;
+    }
+    return new NativeBridgeError({
+        message: result.error?.message || `Native command failed: ${fallbackCommand}`,
+        code: result.error?.code,
+        command: result.error?.command || fallbackCommand,
+    });
 }
 function unavailableBridge() {
     const fail = async () => {
@@ -26,6 +80,7 @@ function unavailableBridge() {
         mouseUp: fail,
         mousePosition: fail,
         displayList: fail,
+        windowList: fail,
         clipboardGet: fail,
         clipboardSet: fail,
     };
@@ -36,91 +91,231 @@ export function createBridgeFromNative({ nativeModule }) {
     }
     return {
         async screenshot(input) {
-            const result = execute({ nativeModule, command: 'screenshot', payload: input });
+            const nativeInput = {
+                path: input.path ?? null,
+                display: input.display ?? null,
+                window: input.window ?? null,
+                region: input.region ?? null,
+                annotate: input.annotate ?? null,
+            };
+            const result = unwrapData({
+                result: nativeModule.screenshot(nativeInput),
+                fallbackCommand: 'screenshot',
+            });
             if (result instanceof Error) {
                 throw result;
             }
-            return result;
+            const coordMap = [
+                result.captureX,
+                result.captureY,
+                result.captureWidth,
+                result.captureHeight,
+                result.imageWidth,
+                result.imageHeight,
+            ].join(',');
+            const hint = [
+                'ALWAYS pass this exact coord map to click, hover, drag, and mouse move when using coordinates from this screenshot:',
+                `--coord-map "${coordMap}"`,
+                '',
+                'Example:',
+                `usecomputer click -x 400 -y 220 --coord-map "${coordMap}"`,
+            ].join('\n');
+            return {
+                path: result.path,
+                desktopIndex: result.desktopIndex,
+                captureX: result.captureX,
+                captureY: result.captureY,
+                captureWidth: result.captureWidth,
+                captureHeight: result.captureHeight,
+                imageWidth: result.imageWidth,
+                imageHeight: result.imageHeight,
+                coordMap,
+                hint,
+            };
         },
         async click(input) {
-            const result = execute({ nativeModule, command: 'click', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const nativeInput = {
+                point: input.point,
+                button: input.button ?? null,
+                count: input.count ?? null,
+            };
+            const result = nativeModule.click(nativeInput);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'click' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async typeText(input) {
-            const result = execute({ nativeModule, command: 'type-text', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const nativeInput = {
+                text: input.text,
+                delayMs: input.delayMs ?? null,
+            };
+            const result = nativeModule.typeText(nativeInput);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'typeText' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async press(input) {
-            const result = execute({ nativeModule, command: 'press', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const nativeInput = {
+                key: input.key,
+                count: input.count ?? null,
+                delayMs: input.delayMs ?? null,
+            };
+            const result = nativeModule.press(nativeInput);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'press' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async scroll(input) {
-            const result = execute({ nativeModule, command: 'scroll', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const nativeInput = {
+                direction: input.direction,
+                amount: input.amount,
+                at: input.at ?? null,
+            };
+            const result = nativeModule.scroll(nativeInput);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'scroll' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async drag(input) {
-            const result = execute({ nativeModule, command: 'drag', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const nativeInput = {
+                from: input.from,
+                to: input.to,
+                durationMs: input.durationMs ?? null,
+                button: input.button ?? null,
+            };
+            const result = nativeModule.drag(nativeInput);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'drag' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async hover(input) {
-            const result = execute({ nativeModule, command: 'hover', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const result = nativeModule.hover(input);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'hover' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async mouseMove(input) {
-            const result = execute({ nativeModule, command: 'mouse-move', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const result = nativeModule.mouseMove(input);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'mouseMove' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async mouseDown(input) {
-            const result = execute({ nativeModule, command: 'mouse-down', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const result = nativeModule.mouseDown({ button: input.button ?? null });
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'mouseDown' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async mouseUp(input) {
-            const result = execute({ nativeModule, command: 'mouse-up', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const result = nativeModule.mouseUp({ button: input.button ?? null });
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'mouseUp' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
         async mousePosition() {
-            const result = execute({ nativeModule, command: 'mouse-position', payload: {} });
+            const result = unwrapData({
+                result: nativeModule.mousePosition(),
+                fallbackCommand: 'mousePosition',
+            });
             if (result instanceof Error) {
                 throw result;
             }
             return result;
         },
         async displayList() {
-            const result = execute({ nativeModule, command: 'display-list', payload: {} });
-            if (result instanceof Error) {
-                throw result;
+            const payload = unwrapData({
+                result: nativeModule.displayList(),
+                fallbackCommand: 'displayList',
+            });
+            if (payload instanceof Error) {
+                throw payload;
             }
-            return result;
+            let parsedJson;
+            try {
+                parsedJson = JSON.parse(payload);
+            }
+            catch (e) {
+                throw new NativeBridgeError({
+                    message: 'Native displayList returned invalid JSON',
+                    command: 'displayList',
+                    code: 'INVALID_NATIVE_JSON',
+                });
+            }
+            const parsed = displayListSchema.safeParse(parsedJson);
+            if (!parsed.success) {
+                throw new NativeBridgeError({
+                    message: 'Native displayList returned invalid payload shape',
+                    command: 'displayList',
+                    code: 'INVALID_NATIVE_PAYLOAD',
+                });
+            }
+            return parsed.data.map((display) => {
+                return {
+                    id: display.id,
+                    index: display.index,
+                    name: display.name,
+                    x: display.x,
+                    y: display.y,
+                    width: display.width,
+                    height: display.height,
+                    scale: display.scale,
+                    isPrimary: display.isPrimary,
+                };
+            });
+        },
+        async windowList() {
+            const payload = unwrapData({
+                result: nativeModule.windowList(),
+                fallbackCommand: 'windowList',
+            });
+            if (payload instanceof Error) {
+                throw payload;
+            }
+            let parsedJson;
+            try {
+                parsedJson = JSON.parse(payload);
+            }
+            catch {
+                throw new NativeBridgeError({
+                    message: 'Native windowList returned invalid JSON',
+                    command: 'windowList',
+                    code: 'INVALID_NATIVE_JSON',
+                });
+            }
+            const parsed = windowListSchema.safeParse(parsedJson);
+            if (!parsed.success) {
+                throw new NativeBridgeError({
+                    message: 'Native windowList returned invalid payload shape',
+                    command: 'windowList',
+                    code: 'INVALID_NATIVE_PAYLOAD',
+                });
+            }
+            return parsed.data;
         },
         async clipboardGet() {
-            const result = execute({ nativeModule, command: 'clipboard-get', payload: {} });
+            const result = unwrapData({
+                result: nativeModule.clipboardGet(),
+                fallbackCommand: 'clipboardGet',
+            });
             if (result instanceof Error) {
                 throw result;
             }
-            return result.text;
+            return result;
         },
         async clipboardSet(input) {
-            const result = execute({ nativeModule, command: 'clipboard-set', payload: input });
-            if (result instanceof Error) {
-                throw result;
+            const result = nativeModule.clipboardSet(input);
+            const maybeError = unwrapCommand({ result, fallbackCommand: 'clipboardSet' });
+            if (maybeError instanceof Error) {
+                throw maybeError;
             }
         },
     };

package/dist/cli-parsing.test.js

@@ -1,4 +1,4 @@
-// Tests for goke CLI parsing on key automation commands.
+// Parser tests for goke CLI options and flags.
 import { describe, expect, test } from 'vitest';
 import { createCli } from './cli.js';
 describe('usecomputer cli parsing', () => {
@@ -11,20 +11,43 @@ describe('usecomputer cli parsing', () => {
     });
     test('parses screenshot options', () => {
         const cli = createCli();
-        const parsed = cli.parse(['node', 'usecomputer', 'screenshot', './shot.png', '--display', '2', '--region', '0,0,120,80'], { run: false });
+        const parsed = cli.parse(['node', 'usecomputer', 'screenshot', './shot.png', '--display', '2', '--region', '0,0,120,80'], {
+            run: false,
+        });
         expect(parsed.args[0]).toBe('./shot.png');
         expect(parsed.options.display).toBe(2);
         expect(parsed.options.region).toBe('0,0,120,80');
     });
-    test('parses scroll amount and coordinates', () => {
+    test('parses coord-map option for click and mouse move', () => {
+        const clickCli = createCli();
+        const clickParsed = clickCli.parse(['node', 'usecomputer', 'click', '-x', '100', '-y', '200', '--coord-map', '0,0,1600,900,1568,882'], {
+            run: false,
+        });
+        const moveCli = createCli();
+        const moveParsed = moveCli.parse(['node', 'usecomputer', 'mouse', 'move', '-x', '100', '-y', '200', '--coord-map', '0,0,1600,900,1568,882'], {
+            run: false,
+        });
+        expect(clickParsed.options.coordMap).toBe('0,0,1600,900,1568,882');
+        expect(moveParsed.options.coordMap).toBe('0,0,1600,900,1568,882');
+    });
+    test('parses debug-point options', () => {
         const cli = createCli();
-        const parsed = cli.parse(['node', 'usecomputer', 'scroll', 'down', '500', '--at', '10,20'], { run: false });
-        expect(parsed.args).toMatchInlineSnapshot(`
-      [
-        "down",
-        "500",
-      ]
-    `);
-        expect(parsed.options.at).toBe('10,20');
+        const parsed = cli.parse([
+            'node',
+            'usecomputer',
+            'debug-point',
+            '-x',
+            '210',
+            '-y',
+            '560',
+            '--coord-map',
+            '0,0,1720,1440,1568,1313',
+            '--output',
+            './tmp/debug-point.png',
+        ], { run: false });
+        expect(parsed.options.coordMap).toBe('0,0,1720,1440,1568,1313');
+        expect(parsed.options.output).toBe('./tmp/debug-point.png');
+        expect(parsed.options.x).toBe(210);
+        expect(parsed.options.y).toBe(560);
     });
 });

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAuDvE,wBAAgB,SAAS,CAAC,EAAE,MAAuB,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAAO,2BAyQzF;AAED,wBAAgB,MAAM,IAAI,IAAI,CAG7B"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAmC,iBAAiB,EAAc,MAAM,YAAY,CAAA;AAiOhG,wBAAgB,SAAS,CAAC,EAAE,MAAuB,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAAO,2BA+bzF;AAED,wBAAgB,MAAM,IAAI,IAAI,CAG7B"}