@maaxyz/maa-node 0.0.1-alpha.2

package/dist/resource.d.ts

@@ -0,0 +1,36 @@
+import { Job, JobSource } from './job';
+import maa from './maa';
+import { CustomActionCallback, CustomRecognizerCallback } from './types';
+export type ResourceNotify = {
+    res_id: maa.ResId;
+    path: string;
+} & ({
+    msg: 'StartLoading';
+} | {
+    msg: 'LoadingCompleted' | 'LoadingFailed';
+    hash: string;
+});
+export declare class ResourceBase {
+    #private;
+    handle: maa.ResourceHandle;
+    notify(message: string, details_json: string): maa.MaybePromise<void>;
+    set parsed_notify(cb: (msg: ResourceNotify) => maa.MaybePromise<void>);
+    constructor(handle: maa.ResourceHandle);
+    destroy(): void;
+    set inference_device(id: keyof typeof maa.InferenceDevice | number);
+    set inference_execution_provider(provider: keyof typeof maa.InferenceExecutionProvider);
+    register_custom_recognizer(name: string, func: CustomRecognizerCallback): void;
+    unregister_custom_recognizer(name: string): void;
+    clear_custom_recognizer(): void;
+    register_custom_action(name: string, func: CustomActionCallback): void;
+    unregister_custom_action(name: string): void;
+    clear_custom_action(): void;
+    post_path(path: string): Job<maa.ResId, JobSource<maa.ResId>>;
+    clear(): void;
+    get loaded(): boolean;
+    get hash(): string | null;
+    get task_list(): string[] | null;
+}
+export declare class Resource extends ResourceBase {
+    constructor();
+}

package/dist/tasker.d.ts

@@ -0,0 +1,128 @@
+import { ControllerBase } from './controller';
+import { Job, JobSource } from './job';
+import maa from './maa';
+import { ResourceBase } from './resource';
+type TaskDetail = ReturnType<TaskerBase['task_detail']>;
+declare class TaskJob extends Job<maa.TaskId, JobSource<maa.TaskId>> {
+    #private;
+    constructor(tasker: TaskerBase, source: JobSource<maa.TaskId>, id: maa.TaskId);
+    get(): {
+        entry: string;
+        nodes: ({
+            name: string;
+            reco: {
+                name: string;
+                algorithm: string;
+                hit: boolean;
+                box: maa.Rect;
+                detail: string;
+                raw: ArrayBuffer;
+                draws: ArrayBuffer[];
+            } | null;
+            completed: boolean;
+        } | null)[];
+        status: maa.Status;
+    } | null;
+    wait(): Promise<this> & {
+        status: Promise<maa.Status>;
+        done: Promise<boolean>;
+        succeeded: Promise<boolean>;
+        failed: Promise<boolean>;
+    } & {
+        get: () => Promise<TaskDetail>;
+    };
+}
+export type TaskerNotify = {
+    task_id: maa.TaskId;
+    entry: string;
+    hash: string;
+    uuid: string;
+} & ({
+    msg: 'Task.Started' | 'Task.Completed' | 'Task.Failed';
+} | {
+    msg: 'Debug.RecognitionResult' | 'Debug.Hit';
+    current: string;
+    recognition: {
+        reco_id: maa.RecoId;
+        name: string;
+        /**
+         * Won't be `null` for msg `Debug.Hit`
+         */
+        box: maa.FlatRect | null;
+        detail: string;
+    };
+} | {
+    msg: 'Focus.ReadyToRun' | 'Focus.Completed' | 'Debug.ReadyToRun' | 'Debug.Completed';
+    current: string;
+    node: {
+        node_id: maa.NodeId;
+        name: string;
+        reco_id: maa.RecoId;
+        times: number;
+        completed: boolean;
+    };
+} | {
+    msg: 'Debug.ListToRecognize' | 'Debug.MissAll';
+    current: string;
+    list: string[];
+});
+export declare class TaskerBase {
+    #private;
+    handle: maa.TaskerHandle;
+    notify(message: string, details_json: string): maa.MaybePromise<void>;
+    set parsed_notify(cb: (msg: TaskerNotify) => maa.MaybePromise<void>);
+    constructor(handle: maa.TaskerHandle);
+    destroy(): void;
+    bind(slave: ControllerBase | ResourceBase): void;
+    post_pipeline(entry: string, param?: Record<string, unknown>): TaskJob;
+    get inited(): boolean;
+    get running(): boolean;
+    post_stop(): TaskJob;
+    get resource(): ResourceBase | null;
+    get controller(): ControllerBase | null;
+    clear_cache(): void;
+    recognition_detail(id: maa.RecoId): {
+        name: string;
+        algorithm: string;
+        hit: boolean;
+        box: maa.Rect;
+        detail: string;
+        raw: ArrayBuffer;
+        draws: ArrayBuffer[];
+    } | null;
+    node_detail(id: maa.NodeId): {
+        name: string;
+        reco: {
+            name: string;
+            algorithm: string;
+            hit: boolean;
+            box: maa.Rect;
+            detail: string;
+            raw: ArrayBuffer;
+            draws: ArrayBuffer[];
+        } | null;
+        completed: boolean;
+    } | null;
+    task_detail(id: maa.TaskId): {
+        entry: string;
+        nodes: ({
+            name: string;
+            reco: {
+                name: string;
+                algorithm: string;
+                hit: boolean;
+                box: maa.Rect;
+                detail: string;
+                raw: ArrayBuffer;
+                draws: ArrayBuffer[];
+            } | null;
+            completed: boolean;
+        } | null)[];
+        status: maa.Status;
+    } | null;
+    latest_node(task: string): maa.NodeId | null;
+}
+export declare class Tasker extends TaskerBase {
+    constructor();
+}
+export {};

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+import { Context } from './context';
+import maa from './maa';
+export interface CustomRecognizerSelf {
+    context: Context;
+    id: maa.TaskId;
+    task: string;
+    name: string;
+    param: unknown;
+    image: maa.ImageData;
+    roi: maa.Rect;
+}
+export interface CustomActionSelf {
+    context: Context;
+    id: maa.TaskId;
+    task: string;
+    name: string;
+    param: unknown;
+    recoId: maa.RecoId;
+    box: maa.Rect;
+}
+type CustomCallback<Self, Ret> = (this: Self, self: Self) => maa.MaybePromise<Ret>;
+export type CustomRecognizerCallback = CustomCallback<CustomRecognizerSelf, [
+    out_box: maa.Rect,
+    out_detail: string
+] | null>;
+export type CustomActionCallback = CustomCallback<CustomActionSelf, boolean>;
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@maaxyz/maa-node",
+    "author": "nekosu",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "node scripts/build.mjs && tsc"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/MaaXYZ/MaaFramework.git"
+    },
+    "engines": {
+        "node": ">= 20.0.0"
+    },
+    "devDependencies": {
+        "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+        "@tsconfig/node20": "^20.1.4",
+        "@types/node": "^20",
+        "esbuild": "^0.21.5",
+        "prettier": "^3.3.2",
+        "typescript": "^5.4.5"
+    },
+    "version": "0.0.1-alpha.2",
+    "optionalDependencies": {
+        "@maaxyz/maa-node-darwin-arm64": "0.0.1-alpha.2",
+        "@maaxyz/maa-node-darwin-x64": "0.0.1-alpha.2",
+        "@maaxyz/maa-node-linux-arm64": "0.0.1-alpha.2",
+        "@maaxyz/maa-node-linux-x64": "0.0.1-alpha.2",
+        "@maaxyz/maa-node-win32-arm64": "0.0.1-alpha.2",
+        "@maaxyz/maa-node-win32-x64": "0.0.1-alpha.2"
+    }
+}

package/scripts/build.mjs

@@ -0,0 +1,20 @@
+import { build } from 'esbuild'
+import { copyFileSync, mkdirSync } from 'fs'
+
+build({
+    entryPoints: ['src/index.ts'],
+    outdir: 'dist',
+    platform: 'node',
+    external: [
+        '@maaxyz/maa-node-win32-x64',
+        '@maaxyz/maa-node-win32-arm64',
+        '@maaxyz/maa-node-linux-x64',
+        '@maaxyz/maa-node-linux-arm64',
+        '@maaxyz/maa-node-darwin-x64',
+        '@maaxyz/maa-node-darwin-arm64'
+    ],
+    bundle: true
+})
+
+mkdirSync('dist', { recursive: true })
+copyFileSync('src/maa.d.ts', 'dist/maa.d.ts')

package/src/context.ts

@@ -0,0 +1,78 @@
+import * as maa from './maa'
+import { TaskerBase } from './tasker'
+
+export class Context {
+    handle: maa.ContextHandle
+    #tasker: TaskerBase
+
+    constructor(handle: maa.ContextHandle) {
+        this.handle = handle
+        this.#tasker = new TaskerBase(maa.context_get_tasker(this.handle))
+    }
+
+    async run_pipeline(entry: string, pipeline_override: Record<string, unknown> = {}) {
+        const id = await maa.context_run_pipeline(
+            this.handle,
+            entry,
+            JSON.stringify(pipeline_override)
+        )
+        return this.#tasker.task_detail(id)
+    }
+
+    async run_recognition(
+        entry: string,
+        image: ArrayBuffer | Buffer,
+        pipeline_override: Record<string, unknown> = {}
+    ) {
+        if (image instanceof Buffer) {
+            image = image.buffer
+        }
+        const id = await maa.context_run_recognition(
+            this.handle,
+            entry,
+            JSON.stringify(pipeline_override),
+            image
+        )
+        return this.#tasker.recognition_detail(id)
+    }
+
+    async run_action(
+        entry: string,
+        box: maa.Rect,
+        reco_detail: string,
+        pipeline_override: Record<string, unknown> = {}
+    ) {
+        const id = await maa.context_run_action(
+            this.handle,
+            entry,
+            JSON.stringify(pipeline_override),
+            box,
+            reco_detail
+        )
+        return this.#tasker.node_detail(id)
+    }
+
+    override_pipeline(pipeline_override: Record<string, unknown>) {
+        if (!maa.context_override_pipeline(this.handle, JSON.stringify(pipeline_override))) {
+            throw 'Context override_pipeline failed'
+        }
+    }
+
+    override_next(name: string, next: string[]) {
+        if (!maa.context_override_next(this.handle, name, next)) {
+            throw 'Context override_next failed'
+        }
+    }
+
+    get task_id() {
+        return maa.context_get_task_id(this.handle)
+    }
+
+    get tasker() {
+        return this.#tasker
+    }
+
+    clone() {
+        return new Context(maa.context_clone(this.handle))
+    }
+}

package/src/controller.ts

@@ -0,0 +1,366 @@
+import path from 'path'
+
+import { Job, JobSource } from './job'
+import maa, { ImageData } from './maa'
+
+class ImageJob extends Job<maa.CtrlId, JobSource<maa.CtrlId>> {
+    #ctrl: ControllerBase
+
+    constructor(ctrl: ControllerBase, source: JobSource<maa.CtrlId>, id: maa.CtrlId) {
+        super(source, id)
+
+        this.#ctrl = ctrl
+    }
+
+    get() {
+        if (this.done) {
+            return this.#ctrl.cached_image
+        } else {
+            return null
+        }
+    }
+
+    wait() {
+        const superPro = super.wait()
+        const pro = superPro as typeof superPro & {
+            get: () => Promise<ArrayBuffer | null>
+        }
+        pro.get = () => {
+            return new Promise(resolve => {
+                pro.then(self => {
+                    resolve(self.get())
+                })
+            })
+        }
+        return pro
+    }
+}
+
+export type ControllerNotify =
+    | ({
+          adb: string
+          address: string
+      } & (
+          | {
+                msg: 'UUIDGot'
+                uuid: string
+            }
+          | {
+                msg: 'UUIDGetFailed'
+            }
+          | {
+                msg: 'ConnectSuccess'
+            }
+          | {
+                msg: 'ConnectFailed'
+                why: 'ConnectFailed' | 'UUIDGetFailed'
+            }
+          | {
+                msg:
+                    | 'ScreencapInited'
+                    | 'ScreencapInitFailed'
+                    | 'TouchinputInited'
+                    | 'TouchinputInitFailed'
+            }
+      ))
+    | {
+          msg: 'Action.Started' | 'Action.Completed' | 'Action.Failed'
+          ctrl_id: maa.CtrlId
+          uuid: string
+      }
+
+export class ControllerBase {
+    handle: maa.ControllerHandle
+    #source: JobSource<maa.CtrlId>
+
+    notify(message: string, details_json: string): maa.MaybePromise<void> {}
+
+    set parsed_notify(cb: (msg: ControllerNotify) => maa.MaybePromise<void>) {
+        this.notify = (msg, details) => {
+            return cb({
+                msg: msg.replace(/^Controller\./, '') as any,
+                ...JSON.parse(details)
+            })
+        }
+    }
+
+    constructor(handle: maa.ControllerHandle) {
+        this.handle = handle
+        this.#source = {
+            status: id => maa.controller_status(this.handle, id),
+            wait: id => maa.controller_wait(this.handle, id)
+        }
+    }
+
+    destroy() {
+        maa.controller_destroy(this.handle)
+    }
+
+    set screenshot_target_long_side(value: number) {
+        if (!maa.controller_set_option_screenshot_target_long_side(this.handle, value)) {
+            throw 'Controller set screenshot_target_long_side failed'
+        }
+    }
+
+    set screenshot_target_short_side(value: number) {
+        if (!maa.controller_set_option_screenshot_target_short_side(this.handle, value)) {
+            throw 'Controller set screenshot_target_short_side failed'
+        }
+    }
+
+    set screenshot_use_raw_size(value: boolean) {
+        if (!maa.controller_set_option_screenshot_use_raw_size(this.handle, value)) {
+            throw 'Controller set screenshot_use_raw_size failed'
+        }
+    }
+
+    set recording(value: boolean) {
+        if (!maa.controller_set_option_recording(this.handle, value)) {
+            throw 'Controller set recording failed'
+        }
+    }
+
+    post_connection() {
+        return new Job(this.#source, maa.controller_post_connection(this.handle))
+    }
+
+    post_click(x: number, y: number) {
+        return new Job(this.#source, maa.controller_post_click(this.handle, x, y))
+    }
+
+    post_swipe(x1: number, y1: number, x2: number, y2: number, duration: number) {
+        return new Job(
+            this.#source,
+            maa.controller_post_swipe(this.handle, x1, y1, x2, y2, duration)
+        )
+    }
+
+    post_press_key(keycode: number) {
+        return new Job(this.#source, maa.controller_post_press_key(this.handle, keycode))
+    }
+
+    post_input_text(text: string) {
+        return new Job(this.#source, maa.controller_post_input_text(this.handle, text))
+    }
+
+    post_start_app(intent: string) {
+        return new Job(this.#source, maa.controller_post_start_app(this.handle, intent))
+    }
+
+    post_stop_app(intent: string) {
+        return new Job(this.#source, maa.controller_post_stop_app(this.handle, intent))
+    }
+
+    post_touch_down(contact: number, x: number, y: number, pressure: number) {
+        return new Job(
+            this.#source,
+            maa.controller_post_touch_down(this.handle, contact, x, y, pressure)
+        )
+    }
+
+    post_touch_move(contact: number, x: number, y: number, pressure: number) {
+        return new Job(
+            this.#source,
+            maa.controller_post_touch_move(this.handle, contact, x, y, pressure)
+        )
+    }
+
+    post_touch_up(contact: number) {
+        return new Job(this.#source, maa.controller_post_touch_up(this.handle, contact))
+    }
+
+    post_screencap() {
+        return new ImageJob(this, this.#source, maa.controller_post_screencap(this.handle))
+    }
+
+    get connected() {
+        return maa.controller_connected(this.handle)
+    }
+
+    get cached_image() {
+        return maa.controller_cached_image(this.handle)
+    }
+
+    get uuid() {
+        return maa.controller_get_uuid(this.handle)
+    }
+}
+
+export class AdbController extends ControllerBase {
+    constructor(
+        adb_path: string,
+        address: string,
+        screencap_methods: maa.ScreencapOrInputMethods,
+        input_methods: maa.ScreencapOrInputMethods,
+        config: string,
+        agent?: string
+    ) {
+        let ws: WeakRef<this>
+        const h = maa.adb_controller_create(
+            adb_path,
+            address,
+            screencap_methods,
+            input_methods,
+            config,
+            agent ?? AdbController.agent_path(),
+            (message, details_json) => {
+                ws.deref()?.notify(message, details_json)
+            }
+        )
+        if (!h) {
+            throw 'AdbController create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+
+    static agent_path() {
+        return path.join(__dirname, '..', 'agent')
+    }
+
+    static async find(adb?: string) {
+        return maa.find_adb(adb ?? null)
+    }
+}
+
+export class Win32Controller extends ControllerBase {
+    constructor(
+        hwnd: maa.DesktopHandle | null,
+        screencap_methods: maa.ScreencapOrInputMethods,
+        input_methods: maa.ScreencapOrInputMethods
+    ) {
+        let ws: WeakRef<this>
+        const h = maa.win32_controller_create(
+            hwnd ?? ('0' as maa.DesktopHandle),
+            screencap_methods,
+            input_methods,
+            (message, details_json) => {
+                ws.deref()?.notify(message, details_json)
+            }
+        )
+        if (!h) {
+            throw 'Win32Controller create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+
+    static find() {
+        return maa.find_desktop()
+    }
+}
+
+export class DbgController extends ControllerBase {
+    constructor(read_path: string, write_path: string, type: maa.Uint64, config: string) {
+        let ws: WeakRef<this>
+        const h = maa.dbg_controller_create(
+            read_path,
+            write_path,
+            type,
+            config,
+            (message, details_json) => {
+                ws.deref()?.notify(message, details_json)
+            }
+        )
+        if (!h) {
+            throw 'DbgController create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+}
+
+export abstract class CustomControllerActor {
+    abstract connect(): maa.MaybePromise<boolean>
+    abstract request_uuid(): maa.MaybePromise<string | null>
+    abstract start_app(intent: string): maa.MaybePromise<boolean>
+    abstract stop_app(intent: string): maa.MaybePromise<boolean>
+    abstract screencap(): maa.MaybePromise<ImageData | null>
+    abstract click(x: number, y: number): maa.MaybePromise<boolean>
+    abstract swipe(
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number,
+        duration: number
+    ): maa.MaybePromise<boolean>
+    abstract touch_down(
+        contact: number,
+        x: number,
+        y: number,
+        pressure: number
+    ): maa.MaybePromise<boolean>
+    abstract touch_move(
+        contact: number,
+        x: number,
+        y: number,
+        pressure: number
+    ): maa.MaybePromise<boolean>
+    abstract touch_up(contact: number): maa.MaybePromise<boolean>
+    abstract press_key(keycode: number): maa.MaybePromise<boolean>
+    abstract input_text(text: string): maa.MaybePromise<boolean>
+}
+
+export class CustomControllerActorDefaultImpl extends CustomControllerActor {
+    connect(): maa.MaybePromise<boolean> {
+        return false
+    }
+    request_uuid(): maa.MaybePromise<string | null> {
+        return null
+    }
+    start_app(intent: string): maa.MaybePromise<boolean> {
+        return false
+    }
+    stop_app(intent: string): maa.MaybePromise<boolean> {
+        return false
+    }
+    screencap(): maa.MaybePromise<ImageData | null> {
+        return null
+    }
+    click(x: number, y: number): maa.MaybePromise<boolean> {
+        return false
+    }
+    swipe(
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number,
+        duration: number
+    ): maa.MaybePromise<boolean> {
+        return false
+    }
+    touch_down(contact: number, x: number, y: number, pressure: number): maa.MaybePromise<boolean> {
+        return false
+    }
+    touch_move(contact: number, x: number, y: number, pressure: number): maa.MaybePromise<boolean> {
+        return false
+    }
+    touch_up(contact: number): maa.MaybePromise<boolean> {
+        return false
+    }
+    press_key(keycode: number): maa.MaybePromise<boolean> {
+        return false
+    }
+    input_text(text: string): maa.MaybePromise<boolean> {
+        return false
+    }
+}
+
+export class CustomController extends ControllerBase {
+    constructor(actor: CustomControllerActor) {
+        let ws: WeakRef<this>
+        const h = maa.custom_controller_create(
+            (action, ...param) => {
+                return (actor[action] as any)(...param)
+            },
+            (message, details_json) => {
+                ws.deref()?.notify(message, details_json)
+            }
+        )
+        if (!h) {
+            throw 'CustomController create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+}