bunbot/dist/index.js

Desktop automation for Bun.

// src/index.ts
import {ptr as toPtr} from "bun:ffi";

// src/ffi.ts
import {dlopen, FFIType, suffix} from "bun:ffi";
var { platform, arch } = process;
var filename;
if (arch === "x64") {
  filename = `../release/readline-${platform}-amd64.${suffix}`;
} else {
  filename = `../release/readline-${platform}-${arch}.${suffix}`;
}
var location = new URL(filename, import.meta.url).pathname;
var { symbols } = dlopen(location, {
  GetVersion: {
    args: [],
    returns: FFIType.ptr
  },
  GetPixelColor: {
    args: [FFIType.int, FFIType.int],
    returns: FFIType.ptr
  },
  GetScreenSize: {
    args: [],
    returns: FFIType.ptr
  },
  GetScaleSize: {
    args: [],
    returns: FFIType.ptr
  },
  SetMouseSleep: {
    args: [FFIType.int],
    returns: FFIType.void
  },
  ScrollMouse: {
    args: [FFIType.int, FFIType.int],
    returns: FFIType.void
  },
  Move: {
    args: [FFIType.int, FFIType.int],
    returns: FFIType.void
  },
  Drag: {
    args: [FFIType.int, FFIType.int],
    returns: FFIType.void
  },
  MoveSmooth: {
    args: [FFIType.int, FFIType.int, FFIType.f64, FFIType.f64],
    returns: FFIType.bool
  },
  GetMousePos: {
    args: [],
    returns: FFIType.ptr
  },
  Click: {
    args: [FFIType.ptr, FFIType.bool],
    returns: FFIType.void
  },
  TypeStr: {
    args: [FFIType.ptr],
    returns: FFIType.void
  },
  KeyTap: {
    args: [FFIType.ptr, FFIType.ptr],
    returns: FFIType.ptr
  },
  GetText: {
    args: [FFIType.ptr],
    returns: FFIType.ptr
  },
  FreeString: {
    args: [FFIType.ptr],
    returns: FFIType.void
  }
});

// src/utils.ts
import {CString} from "bun:ffi";
function encode(data) {
  return utf8e.encode(data + "\0");
}
function toString(ptr) {
  const str = new CString(ptr);
  symbols.FreeString(str.ptr);
  return str.toString();
}
var utf8e = new TextEncoder;

// src/index.ts
class Bunbot {
  constructor() {
  }
  freeString(ptr) {
    symbols.FreeString(ptr);
  }
  getRobotGoVersion() {
    const ptr = symbols.GetVersion();
    return toString(ptr);
  }
  getPixelColor(x, y) {
    const ptr = symbols.GetPixelColor(x, y);
    return toString(ptr);
  }
  getScreenSize() {
    const ptr = symbols.GetScreenSize();
    return JSON.parse(toString(ptr));
  }
  getScaleSize() {
    const ptr = symbols.GetScaleSize();
    return JSON.parse(toString(ptr));
  }
  setMouseSleep(millisecond) {
    symbols.SetMouseSleep(millisecond);
  }
  scrollMouse(x, y) {
    symbols.ScrollMouse(x, y);
  }
  moveMouse(x, y) {
    symbols.Move(x, y);
  }
  dragMouse(x, y) {
    symbols.Drag(x, y);
  }
  moveMouseSmooth(x, y, low = 0, high = 0) {
    symbols.MoveSmooth(x, y, high, low);
  }
  getMousePosition() {
    const ptr = symbols.GetMousePos();
    return JSON.parse(toString(ptr));
  }
  click(button = "left", doubleClick = false) {
    symbols.Click(toPtr(encode(button)), doubleClick);
  }
  type(text) {
    symbols.TypeStr(toPtr(encode(text)));
  }
  tap(key, ...modifiers) {
    const keyPtr = toPtr(encode(key));
    const modifiersPtr = toPtr(encode(modifiers));
    symbols.KeyTap(keyPtr, modifiersPtr);
  }
  getText(imagePath) {
    const ptr = symbols.GetText(toPtr(encode(imagePath)));
    const { result, error } = JSON.parse(toString(ptr));
    if (error !== "") {
      throw new Error(error);
    }
    return result;
  }
}
var src_default = Bunbot;
export {
  src_default as default,
  Bunbot
};