claude-code/packages/@ant/computer-use-input/src/backends/linux.ts

/**
 * Linux backend for computer-use-input
 *
 * Uses xdotool for mouse and keyboard simulation.
 * Requires: xdotool (apt install xdotool)
 */

import type { FrontmostAppInfo, InputBackend } from '../types.js'

// ---------------------------------------------------------------------------
// Shell helper — run a command and return trimmed stdout
// ---------------------------------------------------------------------------

function run(cmd: string[]): string {
  const result = Bun.spawnSync({
    cmd,
    stdout: 'pipe',
    stderr: 'pipe',
  })
  return new TextDecoder().decode(result.stdout).trim()
}

async function runAsync(cmd: string[]): Promise<string> {
  const proc = Bun.spawn(cmd, { stdout: 'pipe', stderr: 'pipe' })
  const out = await new Response(proc.stdout).text()
  await proc.exited
  return out.trim()
}

// ---------------------------------------------------------------------------
// xdotool key name mapping
// ---------------------------------------------------------------------------

const KEY_MAP: Record<string, string> = {
  return: 'Return', enter: 'Return', tab: 'Tab', space: 'space',
  backspace: 'BackSpace', delete: 'Delete', escape: 'Escape', esc: 'Escape',
  left: 'Left', up: 'Up', right: 'Right', down: 'Down',
  home: 'Home', end: 'End', pageup: 'Prior', pagedown: 'Next',
  f1: 'F1', f2: 'F2', f3: 'F3', f4: 'F4', f5: 'F5', f6: 'F6',
  f7: 'F7', f8: 'F8', f9: 'F9', f10: 'F10', f11: 'F11', f12: 'F12',
  shift: 'shift', lshift: 'shift', rshift: 'shift',
  control: 'ctrl', ctrl: 'ctrl', lcontrol: 'ctrl', rcontrol: 'ctrl',
  alt: 'alt', option: 'alt', lalt: 'alt', ralt: 'alt',
  win: 'super', meta: 'super', command: 'super', cmd: 'super', super: 'super',
  insert: 'Insert', printscreen: 'Print', pause: 'Pause',
  numlock: 'Num_Lock', capslock: 'Caps_Lock', scrolllock: 'Scroll_Lock',
}

const MODIFIER_KEYS = new Set([
  'shift', 'lshift', 'rshift', 'control', 'ctrl', 'lcontrol', 'rcontrol',
  'alt', 'option', 'lalt', 'ralt', 'win', 'meta', 'command', 'cmd', 'super',
])

function mapKey(name: string): string {
  return KEY_MAP[name.toLowerCase()] ?? name
}

// ---------------------------------------------------------------------------
// xdotool mouse button mapping
// ---------------------------------------------------------------------------

function mouseButtonNum(button: 'left' | 'right' | 'middle'): string {
  return button === 'left' ? '1' : button === 'right' ? '3' : '2'
}

// ---------------------------------------------------------------------------
// Implementation
// ---------------------------------------------------------------------------

export const moveMouse: InputBackend['moveMouse'] = async (x, y, _animated) => {
  run(['xdotool', 'mousemove', '--sync', String(Math.round(x)), String(Math.round(y))])
}

export const mouseLocation: InputBackend['mouseLocation'] = async () => {
  const out = run(['xdotool', 'getmouselocation'])
  // Output format: "x:123 y:456 screen:0 window:12345678"
  const xMatch = out.match(/x:(\d+)/)
  const yMatch = out.match(/y:(\d+)/)
  return {
    x: xMatch ? Number(xMatch[1]) : 0,
    y: yMatch ? Number(yMatch[1]) : 0,
  }
}

export const mouseButton: InputBackend['mouseButton'] = async (button, action, count) => {
  const btn = mouseButtonNum(button)
  if (action === 'click') {
    const n = count ?? 1
    run(['xdotool', 'click', '--repeat', String(n), btn])
  } else if (action === 'press') {
    run(['xdotool', 'mousedown', btn])
  } else {
    run(['xdotool', 'mouseup', btn])
  }
}

export const mouseScroll: InputBackend['mouseScroll'] = async (amount, direction) => {
  // xdotool click 4=scroll up, 5=scroll down, 6=scroll left, 7=scroll right
  // Positive amount = down/right, negative = up/left
  if (direction === 'vertical') {
    const btn = amount >= 0 ? '5' : '4'
    const repeats = Math.abs(Math.round(amount))
    if (repeats > 0) {
      run(['xdotool', 'click', '--repeat', String(repeats), btn])
    }
  } else {
    const btn = amount >= 0 ? '7' : '6'
    const repeats = Math.abs(Math.round(amount))
    if (repeats > 0) {
      run(['xdotool', 'click', '--repeat', String(repeats), btn])
    }
  }
}

export const key: InputBackend['key'] = async (keyName, action) => {
  const mapped = mapKey(keyName)
  if (action === 'press') {
    run(['xdotool', 'keydown', mapped])
  } else {
    run(['xdotool', 'keyup', mapped])
  }
}

export const keys: InputBackend['keys'] = async (parts) => {
  // xdotool key accepts "modifier+modifier+key" format
  const modifiers: string[] = []
  let finalKey: string | null = null

  for (const part of parts) {
    if (MODIFIER_KEYS.has(part.toLowerCase())) {
      modifiers.push(mapKey(part))
    } else {
      finalKey = part
    }
  }
  if (!finalKey) return

  const combo = [...modifiers, mapKey(finalKey)].join('+')
  run(['xdotool', 'key', combo])
}

export const typeText: InputBackend['typeText'] = async (text) => {
  run(['xdotool', 'type', '--delay', '12', text])
}

export const getFrontmostAppInfo: InputBackend['getFrontmostAppInfo'] = () => {
  try {
    const windowId = run(['xdotool', 'getactivewindow'])
    if (!windowId) return null

    const pidStr = run(['xdotool', 'getwindowpid', windowId])
    if (!pidStr) return null

    const pid = pidStr.trim()

    // Read the executable path from /proc
    let exePath = ''
    try {
      exePath = run(['readlink', '-f', `/proc/${pid}/exe`])
    } catch { /* ignore */ }

    // Read the process name from /proc/comm
    let appName = ''
    try {
      appName = run(['cat', `/proc/${pid}/comm`])
    } catch { /* ignore */ }

    if (!exePath && !appName) return null
    return { bundleId: exePath || `/proc/${pid}/exe`, appName: appName || 'unknown' }
  } catch {
    return null
  }
}