@lardexx/arenacode 2.7.0 → 2.9.0

package/src/automation/win-dll.js

@@ -0,0 +1,493 @@
+'use strict';
+
+// Windows backend: the client uses the same DLL the desktop app uses — `windows-use`
+// (exports wu_call_json / wu_free / wu_version) — through koffi, so both clients run
+// literally the same automation code. If the DLL is not found next to the client and
+// the ArenaCode executable is installed, the DLL is extracted from its resources.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { requireFfi } = require('./ffi');
+
+const WU_EXPORTS = ['wu_call_json', 'wu_free', 'wu_version'];
+
+// ------------------------------------------------------------------ PE reading
+// Small PE reader: only what is needed to walk the resource directory and pull out an
+// RCDATA blob (the DLL is stored there, RCDATA/1002, in the ArenaCode executable).
+
+function readResourceBlobs(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 0x100) return [];
+  if (buffer.readUInt16LE(0) !== 0x5a4d) return []; // MZ
+  const peOffset = buffer.readUInt32LE(0x3c);
+  if (peOffset + 0x18 > buffer.length) return [];
+  if (buffer.readUInt32LE(peOffset) !== 0x00004550) return []; // PE\0\0
+  const coff = peOffset + 4;
+  const numberOfSections = buffer.readUInt16LE(coff + 2);
+  const sizeOfOptionalHeader = buffer.readUInt16LE(coff + 16);
+  const optional = coff + 20;
+  const magic = buffer.readUInt16LE(optional);
+  const isPe32Plus = magic === 0x20b;
+  const dirOffset = optional + (isPe32Plus ? 112 : 96);
+  const resourceRva = buffer.readUInt32LE(dirOffset + 2 * 8);
+  if (!resourceRva) return [];
+
+  const sections = [];
+  for (let i = 0; i < numberOfSections; i += 1) {
+    const off = optional + sizeOfOptionalHeader + i * 40;
+    if (off + 40 > buffer.length) break;
+    sections.push({
+      virtualAddress: buffer.readUInt32LE(off + 12),
+      sizeOfRawData: buffer.readUInt32LE(off + 16),
+      pointerToRawData: buffer.readUInt32LE(off + 20),
+      virtualSize: buffer.readUInt32LE(off + 8),
+    });
+  }
+
+  const rvaToOffset = (rva) => {
+    for (const s of sections) {
+      const span = Math.max(s.sizeOfRawData, s.virtualSize);
+      if (rva >= s.virtualAddress && rva < s.virtualAddress + span) {
+        return s.pointerToRawData + (rva - s.virtualAddress);
+      }
+    }
+    return -1;
+  };
+
+  const rootOffset = rvaToOffset(resourceRva);
+  if (rootOffset < 0) return [];
+
+  const out = [];
+  const walk = (dirOffsetInFile, depth, typeId, nameId) => {
+    if (depth > 3 || dirOffsetInFile < 0 || dirOffsetInFile + 16 > buffer.length) return;
+    const named = buffer.readUInt16LE(dirOffsetInFile + 12);
+    const ids = buffer.readUInt16LE(dirOffsetInFile + 14);
+    for (let i = 0; i < named + ids; i += 1) {
+      const entry = dirOffsetInFile + 16 + i * 8;
+      if (entry + 8 > buffer.length) return;
+      const name = buffer.readUInt32LE(entry);
+      const offset = buffer.readUInt32LE(entry + 4);
+      const nextType = depth === 0 ? name : typeId;
+      const nextName = depth === 1 ? name : nameId;
+      if (offset & 0x80000000) {
+        walk(rootOffset + (offset & 0x7fffffff), depth + 1, nextType, nextName);
+      } else {
+        const dataEntry = rootOffset + offset;
+        if (dataEntry + 16 > buffer.length) continue;
+        const dataRva = buffer.readUInt32LE(dataEntry);
+        const dataSize = buffer.readUInt32LE(dataEntry + 4);
+        const dataOffset = rvaToOffset(dataRva);
+        if (dataOffset < 0 || dataOffset + dataSize > buffer.length) continue;
+        out.push({ type: nextType, name: nextName, offset: dataOffset, size: dataSize });
+      }
+    }
+  };
+  walk(rootOffset, 0, null, null);
+  return out;
+}
+
+/** Pulls windows-use.dll out of ArenaCode-x64.exe. Pure buffer work: testable anywhere. */
+function extractDllFromExe(exePath) {
+  let buf;
+  try {
+    buf = fs.readFileSync(exePath);
+  } catch {
+    return null;
+  }
+  for (const blob of readResourceBlobs(buf)) {
+    if (blob.size < 1024) continue;
+    const slice = buf.subarray(blob.offset, blob.offset + blob.size);
+    if (slice.readUInt16LE(0) !== 0x5a4d) continue;
+    if (!slice.includes(Buffer.from('wu_call_json'))) continue;
+    return Buffer.from(slice);
+  }
+  return null;
+}
+
+// ------------------------------------------------------------------ location
+
+function cacheDir() {
+  const base = process.env.LOCALAPPDATA || path.join(os.homedir(), '.local', 'share');
+  return path.join(base, 'arenacode');
+}
+
+/** The DLL shipped inside the npm package: nothing else has to be installed. */
+function packagedDll() {
+  return path.join(__dirname, '..', '..', 'vendor', 'windows-use', 'windows-use.dll');
+}
+
+function candidateExes() {
+  const out = [];
+  const push = (p) => {
+    if (p) out.push(p);
+  };
+  push(process.env.ARENACODE_EXE);
+  const home = os.homedir();
+  const appdata = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+  const local = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+  const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+  const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+  for (const dir of [
+    path.join(local, 'ArenaCode'),
+    path.join(appdata, 'ArenaCode'),
+    path.join(programFiles, 'ArenaCode'),
+    path.join(programFilesX86, 'ArenaCode'),
+    path.join(home, 'ArenaCode'),
+    path.join(home, 'Desktop'),
+    path.join(home, 'Downloads'),
+  ]) {
+    push(path.join(dir, 'ArenaCode-x64.exe'));
+    push(path.join(dir, 'ArenaCode.exe'));
+  }
+  return out;
+}
+
+function candidateDlls() {
+  const out = [];
+  if (process.env.ARENACODE_WINDOWS_USE_DLL) out.push(process.env.ARENACODE_WINDOWS_USE_DLL);
+  out.push(packagedDll());
+  const home = os.homedir();
+  const local = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+  const appdata = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+  out.push(path.join(cacheDir(), 'windows-use.dll'));
+  for (const dir of [path.join(local, 'ArenaCode'), path.join(appdata, 'ArenaCode'), path.dirname(process.execPath)]) {
+    out.push(path.join(dir, 'windows-use.dll'));
+  }
+  return out;
+}
+
+let dllPath = null;
+let dllChecked = false;
+
+function locate() {
+  if (dllChecked) return dllPath;
+  dllChecked = true;
+  for (const candidate of candidateDlls()) {
+    try {
+      if (fs.existsSync(candidate) && fs.statSync(candidate).size > 1024) {
+        dllPath = candidate;
+        return dllPath;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  // last resort: extract it from the desktop client, once, into the cache
+  for (const exe of candidateExes()) {
+    try {
+      if (!fs.existsSync(exe)) continue;
+    } catch {
+      continue;
+    }
+    const blob = extractDllFromExe(exe);
+    if (!blob) continue;
+    for (const target of [path.join(cacheDir(), 'windows-use.dll'), path.join(os.tmpdir(), `arenacode-windows-use-${process.pid}.dll`)]) {
+      try {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, blob);
+        dllPath = target;
+        return dllPath;
+      } catch {
+        /* try the next location */
+      }
+    }
+  }
+  return null;
+}
+
+// --------------------------------------------------------------------- binding
+
+let bindings = null;
+let loadError = null;
+
+function load() {
+  if (bindings) return bindings;
+  if (process.platform !== 'win32') {
+    loadError = 'windows-use.dll is only usable on Windows';
+    return null;
+  }
+  const file = locate();
+  if (!file) {
+    loadError = 'windows-use.dll not found (set ARENACODE_WINDOWS_USE_DLL, or reinstall the npm package)';
+    return null;
+  }
+  try {
+    const koffi = requireFfi();
+    const lib = koffi.load(file);
+    bindings = {
+      path: file,
+      koffi,
+      callJson: lib.func('const char* wu_call_json(const char* request)'),
+      free: lib.func('void wu_free(char* pointer)'),
+      version: lib.func('const char* wu_version()'),
+    };
+    return bindings;
+  } catch (err) {
+    loadError = `windows-use.dll could not be loaded: ${err.message}`;
+    return null;
+  }
+}
+
+function version() {
+  const b = load();
+  if (!b) return null;
+  try {
+    return String(b.version());
+  } catch {
+    return null;
+  }
+}
+
+/** Raw call: {"tool": "...", "args": {...}} in, {"ok":true,"result":…} out. */
+function raw(request) {
+  const b = load();
+  if (!b) return { ok: false, error: loadError || 'windows-use.dll unavailable' };
+  let outPtr = null;
+  try {
+    outPtr = b.callJson(JSON.stringify(request));
+    if (!outPtr) return { ok: false, error: 'windows-use returned NULL' };
+    const text =
+      typeof outPtr === 'string' ? outPtr : String(b.koffi.decode(outPtr, 'char', 4 * 1024 * 1024)).split('\0')[0];
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === 'object' ? parsed : { ok: false, error: 'unreadable answer' };
+  } catch (err) {
+    return { ok: false, error: `windows-use call failed: ${err.message}` };
+  } finally {
+    try {
+      if (outPtr && typeof outPtr !== 'string') b.free(outPtr);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+// Tool names and argument keys, mined from the DLL's own symbols and string table
+// (wu::api::{click_tool,desktop_state,…}), so nothing here is guessed at runtime.
+const TOOLS = {
+  click: 'click_tool',
+  move: 'move_tool',
+  button: 'mouse_button_tool',
+  scroll: 'scroll_tool',
+  type: 'type_tool',
+  type_focus: 'type_focus_tool',
+  shortcut: 'shortcut_tool',
+  multi_select: 'multi_select_tool',
+  multi_edit: 'multi_edit_tool',
+  wait: 'wait_tool',
+  app: 'app_tool',
+  state: 'desktop_state',
+  apps: 'apps_list_tool',
+};
+
+function tool(kind, args = {}) {
+  const name = TOOLS[kind] || kind;
+  return raw({ tool: name, args });
+}
+
+/** The value inside {"ok":true,"result":…}, or {ok:false,error} unchanged. */
+function result(answer) {
+  if (!answer || typeof answer !== 'object') return { ok: false, error: 'no answer' };
+  if (answer.ok === false) return { ok: false, error: answer.error || 'windows-use error' };
+  const value = 'result' in answer ? answer.result : answer;
+  if (value && typeof value === 'object' && !Array.isArray(value)) return { ok: true, ...value };
+  return { ok: true, result: value };
+}
+
+function pickWindow(list, name) {
+  const clean = (list || []).filter((w) => w && w.name);
+  if (!clean.length) return null;
+  const wanted = String(name || '').toLowerCase().trim();
+  if (!wanted) return clean[0];
+  return (
+    clean.find((w) => String(w.name).toLowerCase() === wanted) ||
+    clean.find((w) => String(w.name).toLowerCase().includes(wanted)) ||
+    clean.find((w) => wanted.includes(String(w.name).toLowerCase())) ||
+    null
+  );
+}
+
+// ------------------------------------------------------------------ backend API
+// Same shapes as src/automation.js, so the dispatcher can swap it in wholesale.
+
+const backend = {
+  name: 'windows-use.dll',
+
+  available() {
+    const b = load();
+    if (!b) return { ok: false, backend: 'windows', error: loadError || 'windows-use.dll unavailable' };
+    return { ok: true, backend: 'windows', detail: `windows-use.dll ${version() || ''}`.trim(), dll: b.path };
+  },
+
+  screenSize() {
+    const r = backend.state();
+    if (r.ok && r.system && r.system.screen_size) {
+      return { ok: true, width: r.system.screen_size.width, height: r.system.screen_size.height };
+    }
+    return { ok: false, error: r.error || 'screen size unavailable' };
+  },
+
+  windows() {
+    const r = backend.state();
+    return r.ok ? { ok: true, windows: r.windows || [] } : r;
+  },
+
+  activeWindow() {
+    const r = backend.state();
+    if (!r.ok) return r;
+    const active = r.active_window || {};
+    return { ok: true, name: active.name || '', handle: active.handle ?? null };
+  },
+
+  findWindow(name) {
+    const list = backend.windows();
+    if (!list.ok) return list;
+    const hit = pickWindow(list.windows, name);
+    return hit ? { ok: true, window: hit } : { ok: false, error: `window not found: ${name}` };
+  },
+
+  state(handle = null) {
+    const args = { use_accessibility: true, use_vision: false, use_annotation: false };
+    if (handle) args.handle = handle;
+    const r = result(tool('state', args));
+    if (!r.ok) return r;
+    return {
+      ok: true,
+      windows: r.windows || [],
+      active_window: r.active_window || null,
+      interactive_elements: r.interactive_elements || [],
+      scrollable_elements: r.scrollable_elements || [],
+      interactive_elements_text: r.interactive_elements_text || '',
+      scrollable_elements_text: r.scrollable_elements_text || '',
+      tree_status: r.tree_status || '',
+      active_desktop: r.active_desktop ?? null,
+      all_desktops: r.all_desktops ?? null,
+      system: r.system || {},
+      metadata: { depth: r.depth, kind: r.kind, is_browser: r.is_browser },
+    };
+  },
+
+  moveMouse(x, y) {
+    const r = result(tool('move', { loc: [Math.round(x), Math.round(y)] }));
+    return r.ok ? { ok: true, x, y } : r;
+  },
+
+  click(x, y, { button = 'left', count = 1 } = {}) {
+    const clicks = Math.max(1, Math.min(2, Math.trunc(count) || 1));
+    const r = result(tool('click', { loc: [Math.round(x), Math.round(y)], button, clicks }));
+    return r.ok ? { ok: true, x, y, button, count } : r;
+  },
+
+  mouseButton(x, y, button, down) {
+    const r = result(tool('button', { loc: [Math.round(x), Math.round(y)], button, action: down ? 'down' : 'up' }));
+    return r.ok ? { ok: true, x, y, button } : r;
+  },
+
+  drag(x, y, x2, y2) {
+    const down = backend.mouseButton(x, y, 'left', true);
+    if (!down.ok) return down;
+    const moved = backend.moveMouse(x2, y2);
+    if (!moved.ok) return moved;
+    const up = backend.mouseButton(x2, y2, 'left', false);
+    return up.ok ? { ok: true, from: [x, y], to: [x2, y2] } : up;
+  },
+
+  scroll(amount, x = null, y = null) {
+    const times = Math.max(1, Math.abs(Math.trunc(amount) || 1));
+    const args = { direction: 'vertical', wheel_times: times };
+    if (x !== null && y !== null) args.loc = [Math.round(x), Math.round(y)];
+    const r = result(tool('scroll', args));
+    return r.ok ? { ok: true, amount } : r;
+  },
+
+  typeText(text, x = null, y = null) {
+    if (x !== null && y !== null) {
+      const clicked = backend.click(x, y);
+      if (!clicked.ok) return clicked;
+    }
+    const r = result(tool('type', { text: String(text) }));
+    return r.ok ? { ok: true, chars: String(text).length, typed: String(text).length } : r;
+  },
+
+  pressKeys(combo) {
+    const r = result(tool('shortcut', { shortcut: String(combo) }));
+    return r.ok ? { ok: true, keys: combo } : r;
+  },
+
+  focusWindow(name) {
+    const found = backend.findWindow(name);
+    if (!found.ok) return found;
+    const r = result(tool('app', { mode: 'switch', name: found.window.name }));
+    return r.ok ? { ok: true, name: found.window.name, handle: found.window.handle, matched: found.window.name } : r;
+  },
+
+  resizeWindow(name, x, y, width, height) {
+    const found = backend.findWindow(name);
+    if (!found.ok) return found;
+    const r = result(tool('app', { mode: 'resize', name: found.window.name, loc: [x, y], size: [width, height] }));
+    return r.ok ? { ok: true, name: found.window.name, x, y, width, height } : r;
+  },
+
+  launchApp(name) {
+    const r = result(tool('app', { mode: 'launch', name: String(name) }));
+    return r.ok ? { ok: true, app: name } : r;
+  },
+
+  listApps() {
+    const r = result(tool('apps', {}));
+    if (!r.ok) return r;
+    const apps = r.apps || (Array.isArray(r.result) ? r.result : []);
+    return { ok: true, apps };
+  },
+
+  screenshot(dest, { annotate = false } = {}) {
+    const r = result(tool('state', { use_accessibility: false, use_vision: true, use_annotation: Boolean(annotate) }));
+    if (!r.ok) return r;
+    const base64 = r.screenshot_png_base64 || '';
+    if (!base64) return { ok: false, error: 'no screenshot in windows-use answer' };
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, Buffer.from(base64, 'base64'));
+    const size = (r.system && r.system.screen_size) || { width: 0, height: 0 };
+    return {
+      ok: true,
+      file: dest,
+      width: size.width,
+      height: size.height,
+      mime: 'image/png',
+      annotated: Boolean(annotate),
+      elements: (r.interactive_elements || []).length,
+    };
+  },
+
+  sysinfo() {
+    const r = result(tool('state', { use_accessibility: false, use_vision: false }));
+    const system = (r.ok && r.system) || {};
+    return {
+      ok: true,
+      system: {
+        windows_version: system.windows_version || os.release(),
+        os_version: system.os_version || os.release(),
+        screen_size: system.screen_size || { width: 0, height: 0 },
+        user_account_type: system.user_account_type || 'Local Account',
+        default_language: system.default_language || '',
+        dpi_scaling: system.dpi_scaling || 1,
+      },
+    };
+  },
+};
+
+module.exports = {
+  WU_EXPORTS,
+  TOOLS,
+  readResourceBlobs,
+  extractDllFromExe,
+  locate,
+  load,
+  version,
+  tool,
+  result,
+  raw,
+  backend,
+  get loadError() {
+    return loadError;
+  },
+};