usecomputer 0.0.2 → 0.0.4

package/src/bridge.ts

@@ -1,37 +1,114 @@
-// 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, type NativeModule } from './native-lib.js'
+import { z } from 'zod'
 import type {
   ClickInput,
+  DisplayInfo,
   DragInput,
+  NativeCommandResult,
+  NativeDataResult,
   Point,
   PressInput,
+  Region,
   ScreenshotInput,
   ScreenshotResult,
   ScrollInput,
   TypeInput,
   UseComputerBridge,
-  DisplayInfo,
+  WindowInfo,
 } from './types.js'
 
+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<T>({
-  nativeModule,
-  command,
-  payload,
+class NativeBridgeError extends Error {
+  readonly code?: string
+  readonly command?: string
+
+  constructor({
+    message,
+    code,
+    command,
+  }: {
+    message: string
+    code?: string
+    command?: string
+  }) {
+    super(message)
+    this.name = 'NativeBridgeError'
+    this.code = code
+    this.command = command
+  }
+}
+
+function unwrapCommand({
+  result,
+  fallbackCommand,
+}: {
+  result: NativeCommandResult
+  fallbackCommand: string
+}): Error | null {
+  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<T>({
+  result,
+  fallbackCommand,
 }: {
-  nativeModule: NativeModule
-  command: string
-  payload: unknown
+  result: NativeDataResult<T>
+  fallbackCommand: string
 }): Error | T {
-  const response = nativeModule.execute(command, JSON.stringify(payload))
-  const parsed = JSON.parse(response) as { ok: boolean; data?: T; error?: string }
-  if (!parsed.ok) {
-    return new Error(parsed.error || `Native command failed: ${command}`)
+  if (result.ok) {
+    if (result.data === undefined) {
+      return new NativeBridgeError({
+        message: `Native command returned no data: ${fallbackCommand}`,
+        command: fallbackCommand,
+      })
+    }
+    return result.data
   }
-  return parsed.data as T
+  return new NativeBridgeError({
+    message: result.error?.message || `Native command failed: ${fallbackCommand}`,
+    code: result.error?.code,
+    command: result.error?.command || fallbackCommand,
+  })
 }
 
 function unavailableBridge(): UseComputerBridge {
@@ -52,6 +129,7 @@ function unavailableBridge(): UseComputerBridge {
     mouseUp: fail,
     mousePosition: fail,
     displayList: fail,
+    windowList: fail,
     clipboardGet: fail,
     clipboardSet: fail,
   }
@@ -64,91 +142,253 @@ export function createBridgeFromNative({ nativeModule }: { nativeModule: NativeM
 
   return {
     async screenshot(input: ScreenshotInput): Promise<ScreenshotResult> {
-      const result = execute<ScreenshotResult>({ nativeModule, command: 'screenshot', payload: input })
+      const nativeInput: {
+        path: string | null
+        display: number | null
+        window: number | null
+        region: Region | null
+        annotate: boolean | null
+      } = {
+        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: ClickInput): Promise<void> {
-      const result = execute<null>({ nativeModule, command: 'click', payload: input })
-      if (result instanceof Error) {
-        throw result
+      const nativeInput: { point: Point; button: 'left' | 'right' | 'middle' | null; count: number | null } = {
+        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: TypeInput): Promise<void> {
-      const result = execute<null>({ nativeModule, command: 'type-text', payload: input })
-      if (result instanceof Error) {
-        throw result
+      const nativeInput: { text: string; delayMs: number | null } = {
+        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: PressInput): Promise<void> {
-      const result = execute<null>({ nativeModule, command: 'press', payload: input })
-      if (result instanceof Error) {
-        throw result
+      const nativeInput: { key: string; count: number | null; delayMs: number | null } = {
+        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: ScrollInput): Promise<void> {
-      const result = execute<null>({ nativeModule, command: 'scroll', payload: input })
-      if (result instanceof Error) {
-        throw result
+      const nativeInput: { direction: string; amount: number; at: Point | null } = {
+        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: DragInput): Promise<void> {
-      const result = execute<null>({ nativeModule, command: 'drag', payload: input })
-      if (result instanceof Error) {
-        throw result
+      const nativeInput: {
+        from: Point
+        to: Point
+        durationMs: number | null
+        button: 'left' | 'right' | 'middle' | null
+      } = {
+        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: Point): Promise<void> {
-      const result = execute<null>({ 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: Point): Promise<void> {
-      const result = execute<null>({ 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: { button: 'left' | 'right' | 'middle' }): Promise<void> {
-      const result = execute<null>({ 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: { button: 'left' | 'right' | 'middle' }): Promise<void> {
-      const result = execute<null>({ 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(): Promise<Point> {
-      const result = execute<Point>({ nativeModule, command: 'mouse-position', payload: {} })
+      const result = unwrapData({
+        result: nativeModule.mousePosition(),
+        fallbackCommand: 'mousePosition',
+      })
       if (result instanceof Error) {
         throw result
       }
       return result
     },
     async displayList(): Promise<DisplayInfo[]> {
-      const result = execute<DisplayInfo[]>({ 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: unknown
+      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(): Promise<WindowInfo[]> {
+      const payload = unwrapData({
+        result: nativeModule.windowList(),
+        fallbackCommand: 'windowList',
+      })
+      if (payload instanceof Error) {
+        throw payload
+      }
+
+      let parsedJson: unknown
+      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(): Promise<string> {
-      const result = execute<{ text: string }>({ 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: { text: string }): Promise<void> {
-      const result = execute<null>({ 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/src/cli-parsing.test.ts

@@ -0,0 +1,61 @@
+// Parser tests for goke CLI options and flags.
+
+import { describe, expect, test } from 'vitest'
+import { createCli } from './cli.js'
+
+describe('usecomputer cli parsing', () => {
+  test('parses click options with typed defaults', () => {
+    const cli = createCli()
+    const parsed = cli.parse(['node', 'usecomputer', 'click', '100,200', '--count', '2'], { run: false })
+    expect(parsed.args[0]).toBe('100,200')
+    expect(parsed.options.count).toBe(2)
+    expect(parsed.options.button).toBe('left')
+  })
+
+  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,
+    })
+    expect(parsed.args[0]).toBe('./shot.png')
+    expect(parsed.options.display).toBe(2)
+    expect(parsed.options.region).toBe('0,0,120,80')
+  })
+
+  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',
+      '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)
+  })
+})