usecomputer 0.0.1 → 0.0.2

package/src/command-parsers.test.ts

@@ -0,0 +1,50 @@
+// Tests for parsing coordinates, regions, directions, and keyboard modifiers.
+
+import { describe, expect, test } from 'vitest'
+import { parseDirection, parseModifiers, parsePoint, parseRegion } from './command-parsers.js'
+
+describe('command parsers', () => {
+  test('parses x,y points', () => {
+    const result = parsePoint('100,200')
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "x": 100,
+        "y": 200,
+      }
+    `)
+  })
+
+  test('rejects invalid points', () => {
+    const result = parsePoint('100')
+    expect(result instanceof Error).toBe(true)
+    expect(result instanceof Error ? result.message : '').toMatchInlineSnapshot(`"Invalid point "100". Expected x,y"`)
+  })
+
+  test('parses x,y,width,height regions', () => {
+    const result = parseRegion('10,20,300,400')
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "height": 400,
+        "width": 300,
+        "x": 10,
+        "y": 20,
+      }
+    `)
+  })
+
+  test('parses modifiers with normalization', () => {
+    expect(parseModifiers(' CMD,shift, alt ')).toMatchInlineSnapshot(`
+      [
+        "cmd",
+        "shift",
+        "alt",
+      ]
+    `)
+  })
+
+  test('validates scroll direction', () => {
+    expect(parseDirection('down')).toBe('down')
+    const invalid = parseDirection('diagonal')
+    expect(invalid instanceof Error).toBe(true)
+  })
+})

package/src/command-parsers.ts

@@ -0,0 +1,60 @@
+// Parser helpers for CLI values such as coordinates, regions, and key modifiers.
+
+import type { Point, Region, ScrollDirection } from './types.js'
+
+export function parsePoint(input: string): Error | Point {
+  const parts = input.split(',').map((value) => {
+    return value.trim()
+  })
+  if (parts.length !== 2) {
+    return new Error(`Invalid point \"${input}\". Expected x,y`)
+  }
+  const x = Number(parts[0])
+  const y = Number(parts[1])
+  if (!Number.isFinite(x) || !Number.isFinite(y)) {
+    return new Error(`Invalid point \"${input}\". Coordinates must be numbers`)
+  }
+  return { x, y }
+}
+
+export function parseRegion(input: string): Error | Region {
+  const parts = input.split(',').map((value) => {
+    return value.trim()
+  })
+  if (parts.length !== 4) {
+    return new Error(`Invalid region \"${input}\". Expected x,y,width,height`)
+  }
+  const x = Number(parts[0])
+  const y = Number(parts[1])
+  const width = Number(parts[2])
+  const height = Number(parts[3])
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(width) || !Number.isFinite(height)) {
+    return new Error(`Invalid region \"${input}\". Values must be numbers`)
+  }
+  if (width <= 0 || height <= 0) {
+    return new Error(`Invalid region \"${input}\". Width and height must be greater than 0`)
+  }
+  return { x, y, width, height }
+}
+
+export function parseModifiers(input?: string): string[] {
+  if (!input) {
+    return []
+  }
+  return input
+    .split(',')
+    .map((value) => {
+      return value.trim().toLowerCase()
+    })
+    .filter((value) => {
+      return value.length > 0
+    })
+}
+
+export function parseDirection(input: string): Error | ScrollDirection {
+  const normalized = input.trim().toLowerCase()
+  if (normalized === 'up' || normalized === 'down' || normalized === 'left' || normalized === 'right') {
+    return normalized
+  }
+  return new Error(`Invalid direction \"${input}\". Expected up, down, left, or right`)
+}

package/src/index.ts

@@ -1,5 +1,6 @@
-// usecomputer — fast computer automation CLI for AI agents.
-// Controls any desktop via accessibility APIs, mouse, keyboard, and screen capture.
-// Cross-platform: macOS, Linux, Windows.
+// Public API exports for usecomputer parser, bridge, and CLI modules.
 
-export {}
+export { createCli } from './cli.js'
+export { createBridge, createBridgeFromNative } from './bridge.js'
+export * from './types.js'
+export * from './command-parsers.js'

package/src/native-click-smoke.test.ts

@@ -0,0 +1,131 @@
+// Optional host smoke test for the real native click command.
+
+import { describe, expect, test } from 'vitest'
+import { native } from './native-lib.js'
+
+const runNativeSmoke = process.env.USECOMPUTER_NATIVE_SMOKE === '1'
+
+describe('native click smoke', () => {
+  const smokeTest = runNativeSmoke ? test : test.skip
+
+  smokeTest('executes click command without crashing', () => {
+    expect(native).toBeTruthy()
+    if (!native) {
+      return
+    }
+
+    const response = native.execute(
+      'click',
+      JSON.stringify({
+        point: { x: 10, y: 10 },
+        button: 'left',
+        count: 1,
+      }),
+    )
+
+    const parsed = JSON.parse(response) as { ok: boolean; data?: null; error?: string }
+    expect(parsed).toMatchInlineSnapshot(`
+      {
+        "data": null,
+        "ok": true,
+      }
+    `)
+    expect(typeof parsed.ok).toBe('boolean')
+  })
+
+  smokeTest('executes mouse-move/down/up/position/hover/drag without crashing', () => {
+    expect(native).toBeTruthy()
+    if (!native) {
+      return
+    }
+
+    const moveResponse = JSON.parse(
+      native.execute(
+        'mouse-move',
+        JSON.stringify({
+          x: 20,
+          y: 20,
+        }),
+      ),
+    ) as { ok: boolean; data?: null; error?: string }
+
+    const downResponse = JSON.parse(
+      native.execute('mouse-down', JSON.stringify({ button: 'left' })),
+    ) as { ok: boolean; data?: null; error?: string }
+
+    const upResponse = JSON.parse(
+      native.execute('mouse-up', JSON.stringify({ button: 'left' })),
+    ) as { ok: boolean; data?: null; error?: string }
+
+    const positionResponse = JSON.parse(
+      native.execute('mouse-position', JSON.stringify({})),
+    ) as { ok: boolean; data?: { x: number; y: number }; error?: string }
+
+    const hoverResponse = JSON.parse(
+      native.execute(
+        'hover',
+        JSON.stringify({
+          x: 24,
+          y: 24,
+        }),
+      ),
+    ) as { ok: boolean; data?: null; error?: string }
+
+    const dragResponse = JSON.parse(
+      native.execute(
+        'drag',
+        JSON.stringify({
+          from: { x: 24, y: 24 },
+          to: { x: 30, y: 30 },
+          button: 'left',
+          durationMs: 10,
+        }),
+      ),
+    ) as { ok: boolean; data?: null; error?: string }
+
+    expect({
+      moveResponse,
+      downResponse,
+      upResponse,
+      positionResponse,
+      hoverResponse,
+      dragResponse,
+    }).toMatchInlineSnapshot(`
+      {
+        "downResponse": {
+          "data": null,
+          "ok": true,
+        },
+        "dragResponse": {
+          "data": null,
+          "ok": true,
+        },
+        "hoverResponse": {
+          "data": null,
+          "ok": true,
+        },
+        "moveResponse": {
+          "data": null,
+          "ok": true,
+        },
+        "positionResponse": {
+          "data": {
+            "x": 20,
+            "y": 20,
+          },
+          "ok": true,
+        },
+        "upResponse": {
+          "data": null,
+          "ok": true,
+        },
+      }
+    `)
+    expect(moveResponse.ok).toBe(true)
+    expect(downResponse.ok).toBe(true)
+    expect(upResponse.ok).toBe(true)
+    expect(positionResponse.ok).toBe(true)
+    expect(hoverResponse.ok).toBe(true)
+    expect(dragResponse.ok).toBe(true)
+  })
+})

package/src/native-lib.ts

@@ -0,0 +1,38 @@
+// ESM native loader for the usecomputer Zig addon using createRequire.
+
+import os from 'node:os'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+export interface NativeModule {
+  execute(command: string, payloadJson: string): string
+}
+
+function loadCandidate(path: string): NativeModule | null {
+  try {
+    return require(path) as NativeModule
+  } catch {
+    return null
+  }
+}
+
+function loadNativeModule(): NativeModule | null {
+  const dev = loadCandidate('../zig-out/lib/usecomputer.node')
+  if (dev) {
+    return dev
+  }
+
+  const platform = os.platform()
+  const arch = os.arch()
+  const target = `${platform}-${arch}`
+
+  const packaged = loadCandidate(`../dist/${target}/usecomputer.node`)
+  if (packaged) {
+    return packaged
+  }
+
+  return null
+}
+
+export const native = loadNativeModule()

package/src/types.ts

@@ -0,0 +1,87 @@
+// Shared types for usecomputer command parsing and backend bridge calls.
+
+export type MouseButton = 'left' | 'right' | 'middle'
+
+export type ScrollDirection = 'up' | 'down' | 'left' | 'right'
+
+export type Point = {
+  x: number
+  y: number
+}
+
+export type Region = {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export type DisplayInfo = {
+  id: number
+  name: string
+  x: number
+  y: number
+  width: number
+  height: number
+  scale: number
+  isPrimary: boolean
+}
+
+export type ScreenshotInput = {
+  path?: string
+  display?: number
+  region?: Region
+  annotate?: boolean
+}
+
+export type ScreenshotResult = {
+  path: string
+}
+
+export type ClickInput = {
+  point: Point
+  button: MouseButton
+  count: number
+  modifiers: string[]
+}
+
+export type TypeInput = {
+  text: string
+  delayMs?: number
+}
+
+export type PressInput = {
+  key: string
+  count: number
+  delayMs?: number
+}
+
+export type ScrollInput = {
+  direction: ScrollDirection
+  amount: number
+  at?: Point
+}
+
+export type DragInput = {
+  from: Point
+  to: Point
+  durationMs?: number
+  button: MouseButton
+}
+
+export interface UseComputerBridge {
+  screenshot(input: ScreenshotInput): Promise<ScreenshotResult>
+  click(input: ClickInput): Promise<void>
+  typeText(input: TypeInput): Promise<void>
+  press(input: PressInput): Promise<void>
+  scroll(input: ScrollInput): Promise<void>
+  drag(input: DragInput): Promise<void>
+  hover(input: Point): Promise<void>
+  mouseMove(input: Point): Promise<void>
+  mouseDown(input: { button: MouseButton }): Promise<void>
+  mouseUp(input: { button: MouseButton }): Promise<void>
+  mousePosition(): Promise<Point>
+  displayList(): Promise<DisplayInfo[]>
+  clipboardGet(): Promise<string>
+  clipboardSet(input: { text: string }): Promise<void>
+}