usecomputer 0.0.3 → 0.0.4

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

@@ -1,10 +1,25 @@
-// Optional host smoke test for the real native click command.
+// Optional host smoke test for direct native mouse methods.
 
 import { describe, expect, test } from 'vitest'
+import { z } from 'zod'
 import { native } from './native-lib.js'
 
 const runNativeSmoke = process.env.USECOMPUTER_NATIVE_SMOKE === '1'
 
+const displayListSchema = z.array(
+  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(),
+  }),
+)
+
 describe('native click smoke', () => {
   const smokeTest = runNativeSmoke ? test : test.skip
 
@@ -14,23 +29,19 @@ describe('native click smoke', () => {
       return
     }
 
-    const response = native.execute(
-      'click',
-      JSON.stringify({
-        point: { x: 10, y: 10 },
-        button: 'left',
-        count: 1,
-      }),
-    )
+    const response = native.click({
+      point: { x: 10, y: 10 },
+      button: 'left',
+      count: 1,
+    })
 
-    const parsed = JSON.parse(response) as { ok: boolean; data?: null; error?: string }
-    expect(parsed).toMatchInlineSnapshot(`
+    expect(response).toMatchInlineSnapshot(`
       {
-        "data": null,
+        "error": null,
         "ok": true,
       }
     `)
-    expect(typeof parsed.ok).toBe('boolean')
+    expect(response.ok).toBe(true)
   })
 
   smokeTest('executes mouse-move/down/up/position/hover/drag without crashing', () => {
@@ -39,49 +50,19 @@ describe('native click smoke', () => {
       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 }
+    const moveResponse = native.mouseMove({ x: 0, y: 0 })
+    const downResponse = native.mouseDown({ button: 'left' })
+    const upResponse = native.mouseUp({ button: 'left' })
+    const positionResponse = native.mousePosition()
+    const hoverResponse = native.hover({ x: 0, y: 0 })
+    const dragResponse = native.drag({
+      from: { x: 0, y: 0 },
+      to: { x: 0, y: 0 },
+      button: 'left',
+      durationMs: 10,
+    })
+    const typeResponse = native.typeText({ text: 'h', delayMs: 1 })
+    const pressResponse = native.press({ key: 'backspace', count: 1, delayMs: 1 })
 
     expect({
       moveResponse,
@@ -90,33 +71,44 @@ describe('native click smoke', () => {
       positionResponse,
       hoverResponse,
       dragResponse,
+      typeResponse,
+      pressResponse,
     }).toMatchInlineSnapshot(`
       {
         "downResponse": {
-          "data": null,
+          "error": null,
           "ok": true,
         },
         "dragResponse": {
-          "data": null,
+          "error": null,
           "ok": true,
         },
         "hoverResponse": {
-          "data": null,
+          "error": null,
           "ok": true,
         },
         "moveResponse": {
-          "data": null,
+          "error": null,
           "ok": true,
         },
         "positionResponse": {
           "data": {
-            "x": 20,
-            "y": 20,
+            "x": 0,
+            "y": 0,
           },
+          "error": null,
+          "ok": true,
+        },
+        "pressResponse": {
+          "error": null,
+          "ok": true,
+        },
+        "typeResponse": {
+          "error": null,
           "ok": true,
         },
         "upResponse": {
-          "data": null,
+          "error": null,
           "ok": true,
         },
       }
@@ -127,5 +119,31 @@ describe('native click smoke', () => {
     expect(positionResponse.ok).toBe(true)
     expect(hoverResponse.ok).toBe(true)
     expect(dragResponse.ok).toBe(true)
+    expect(typeResponse.ok).toBe(true)
+    expect(pressResponse.ok).toBe(true)
+  })
+
+  smokeTest('returns display payload for desktop list command', () => {
+    expect(native).toBeTruthy()
+    if (!native) {
+      return
+    }
+
+    const result = native.displayList()
+    expect(result.ok).toBe(true)
+    if (!result.ok || !result.data) {
+      return
+    }
+
+    const parsedJson: unknown = JSON.parse(result.data)
+    const parsed = displayListSchema.safeParse(parsedJson)
+    expect(parsed.success).toBe(true)
+    if (!parsed.success) {
+      return
+    }
+
+    expect(parsed.data.length).toBeGreaterThan(0)
+    expect(parsed.data[0]?.width).toBeGreaterThan(0)
+    expect(parsed.data[0]?.height).toBeGreaterThan(0)
   })
 })

package/src/native-lib.ts

@@ -2,11 +2,49 @@
 
 import os from 'node:os'
 import { createRequire } from 'node:module'
+import type {
+  MouseButton,
+  NativeCommandResult,
+  NativeDataResult,
+  Point,
+  Region,
+} from './types.js'
+
+type NativeScreenshotOutput = {
+  path: string
+  desktopIndex: number
+  captureX: number
+  captureY: number
+  captureWidth: number
+  captureHeight: number
+  imageWidth: number
+  imageHeight: number
+}
 
 const require = createRequire(import.meta.url)
 
 export interface NativeModule {
-  execute(command: string, payloadJson: string): string
+  screenshot(input: {
+    path: string | null
+    display: number | null
+    window: number | null
+    region: Region | null
+    annotate: boolean | null
+  }): NativeDataResult<NativeScreenshotOutput>
+  click(input: { point: Point; button: MouseButton | null; count: number | null }): NativeCommandResult
+  typeText(input: { text: string; delayMs: number | null }): NativeCommandResult
+  press(input: { key: string; count: number | null; delayMs: number | null }): NativeCommandResult
+  scroll(input: { direction: string; amount: number; at: Point | null }): NativeCommandResult
+  drag(input: { from: Point; to: Point; durationMs: number | null; button: MouseButton | null }): NativeCommandResult
+  hover(input: Point): NativeCommandResult
+  mouseMove(input: Point): NativeCommandResult
+  mouseDown(input: { button: MouseButton | null }): NativeCommandResult
+  mouseUp(input: { button: MouseButton | null }): NativeCommandResult
+  mousePosition(): NativeDataResult<Point>
+  displayList(): NativeDataResult<string>
+  windowList(): NativeDataResult<string>
+  clipboardGet(): NativeDataResult<string>
+  clipboardSet(input: { text: string }): NativeCommandResult
 }
 
 function loadCandidate(path: string): NativeModule | null {

package/src/terminal-table.test.ts

@@ -0,0 +1,44 @@
+// Tests aligned terminal table formatting for deterministic CLI rendering.
+
+import { describe, expect, test } from 'vitest'
+import { renderAlignedTable } from './terminal-table.js'
+
+describe('terminal table', () => {
+  test('renders aligned columns for mixed widths', () => {
+    const lines = renderAlignedTable({
+      rows: [
+        { id: 2, app: 'Zed', size: '1720x1440' },
+        { id: 102, app: 'Google Chrome', size: '3440x1440' },
+      ],
+      columns: [
+        {
+          header: 'id',
+          align: 'right',
+          value: (row) => {
+            return String(row.id)
+          },
+        },
+        {
+          header: 'app',
+          value: (row) => {
+            return row.app
+          },
+        },
+        {
+          header: 'size',
+          align: 'right',
+          value: (row) => {
+            return row.size
+          },
+        },
+      ],
+    })
+
+    expect(lines.join('\n')).toMatchInlineSnapshot(`
+      " id  app                 size
+      ---  -------------  ---------
+        2  Zed            1720x1440
+      102  Google Chrome  3440x1440"
+    `)
+  })
+})

package/src/terminal-table.ts

@@ -0,0 +1,88 @@
+// Generic aligned terminal table renderer for CLI command output.
+
+export type TableColumn<Row> = {
+  header: string
+  align?: 'left' | 'right'
+  value: (row: Row) => string
+}
+
+export function renderAlignedTable<Row>({
+  rows,
+  columns,
+}: {
+  rows: Row[]
+  columns: TableColumn<Row>[]
+}): string[] {
+  if (columns.length === 0) {
+    return []
+  }
+
+  const widthByColumn = columns.map((column) => {
+    const rowWidth = rows.reduce((maxWidth, row) => {
+      const width = printableWidth(column.value(row))
+      return Math.max(maxWidth, width)
+    }, 0)
+    return Math.max(printableWidth(column.header), rowWidth)
+  })
+
+  const formatCell = ({
+    value,
+    width,
+    align,
+  }: {
+    value: string
+    width: number
+    align: 'left' | 'right'
+  }): string => {
+    const currentWidth = printableWidth(value)
+    const padSize = Math.max(0, width - currentWidth)
+    const padding = ' '.repeat(padSize)
+    if (align === 'right') {
+      return `${padding}${value}`
+    }
+    return `${value}${padding}`
+  }
+
+  const renderRow = ({
+    values,
+  }: {
+    values: string[]
+  }): string => {
+    return values.map((value, index) => {
+      const column = columns[index]
+      if (!column) {
+        return value
+      }
+      return formatCell({
+        value,
+        width: widthByColumn[index] ?? value.length,
+        align: column.align ?? 'left',
+      })
+    }).join('  ')
+  }
+
+  const header = renderRow({
+    values: columns.map((column) => {
+      return column.header
+    }),
+  })
+
+  const divider = widthByColumn.map((width) => {
+    return '-'.repeat(width)
+  }).join('  ')
+
+  const lines = rows.map((row) => {
+    return renderRow({
+      values: columns.map((column) => {
+        return column.value(row)
+      }),
+    })
+  })
+
+  return [header, divider, ...lines]
+}
+
+function printableWidth(value: string): number {
+  const ansiStripped = value.replace(/\u001b\[[0-9;]*m/g, '')
+  return ansiStripped.length
+}

package/src/types.ts

@@ -16,8 +16,18 @@ export type Region = {
   height: number
 }
 
+export type CoordMap = {
+  captureX: number
+  captureY: number
+  captureWidth: number
+  captureHeight: number
+  imageWidth: number
+  imageHeight: number
+}
+
 export type DisplayInfo = {
   id: number
+  index: number
   name: string
   x: number
   y: number
@@ -27,15 +37,37 @@ export type DisplayInfo = {
   isPrimary: boolean
 }
 
+export type WindowInfo = {
+  id: number
+  ownerPid: number
+  ownerName: string
+  title: string
+  x: number
+  y: number
+  width: number
+  height: number
+  desktopIndex: number
+}
+
 export type ScreenshotInput = {
   path?: string
   display?: number
+  window?: number
   region?: Region
   annotate?: boolean
 }
 
 export type ScreenshotResult = {
   path: string
+  desktopIndex: number
+  captureX: number
+  captureY: number
+  captureWidth: number
+  captureHeight: number
+  imageWidth: number
+  imageHeight: number
+  coordMap: string
+  hint: string
 }
 
 export type ClickInput = {
@@ -69,6 +101,23 @@ export type DragInput = {
   button: MouseButton
 }
 
+export type NativeErrorObject = {
+  code: string
+  message: string
+  command: string
+}
+
+export type NativeCommandResult = {
+  ok: boolean
+  error?: NativeErrorObject
+}
+
+export type NativeDataResult<T> = {
+  ok: boolean
+  data?: T
+  error?: NativeErrorObject
+}
+
 export interface UseComputerBridge {
   screenshot(input: ScreenshotInput): Promise<ScreenshotResult>
   click(input: ClickInput): Promise<void>
@@ -82,6 +131,7 @@ export interface UseComputerBridge {
   mouseUp(input: { button: MouseButton }): Promise<void>
   mousePosition(): Promise<Point>
   displayList(): Promise<DisplayInfo[]>
+  windowList(): Promise<WindowInfo[]>
   clipboardGet(): Promise<string>
   clipboardSet(input: { text: string }): Promise<void>
 }