@bryce3310687963/android-toolkit 0.0.0-stage → 1.0.50

package/index.d.ts

@@ -0,0 +1,346 @@
+export interface AndroidContext {
+    runId: string;
+    query: string;
+    serial: string;
+    packageName: string;
+    adbPath: string;
+    actorKey?: string;
+    appVersion?: string;
+    slotKey?: string;
+    instanceId?: string;
+    externalIp?: string;
+}
+
+export interface ViewBounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+}
+
+export interface ViewNode {
+    resourceId: string;
+    id: string;
+    text: string;
+    contentDesc: string;
+    className: string;
+    packageName: string;
+    bounds: ViewBounds;
+    clickable: boolean;
+    enabled: boolean;
+    focusable: boolean;
+    focused: boolean;
+    scrollable: boolean;
+    visible: boolean;
+    children: ViewNode[];
+}
+
+export type ViewSelector = {
+    id?: string;
+    text?: string;
+    textContains?: string;
+    contentDesc?: string;
+    className?: string;
+};
+
+export interface WebViewHookConfig {
+    name: string | string[];
+    value: string[];
+}
+
+export interface DeviceCacheFileOptions {
+    dirName: string;
+    fileName: string;
+    text?: string;
+    timeoutMs?: number;
+    maxBuffer?: number;
+}
+
+export namespace Constants {
+    export const Code: Record<string, number>;
+    export const Status: Record<string, string>;
+    export const StoragePath: {
+        Input: '/apify_storage/input.json';
+        Output: '/apify_storage/output.json';
+    };
+    export const UnicodeIme: {
+        packageName: string;
+        component: string;
+        inputAction: string;
+    };
+    export const WebViewBridge: {
+        packageName: string;
+        actionCommand: string;
+        cacheDir: string;
+        hookConfigFile: string;
+        commandDir: string;
+        resultDir: string;
+    };
+    export const ActorKey: {
+        DoubaoAndroid: 'doubao.android';
+        ErineAndroid: 'erine.android';
+        WechatAndroid: 'wechat.android';
+        QwenAndroid: 'qwen.android';
+        YuanbaoAndroid: 'yuanbao.android';
+        XhsAndroid: 'xhs.android';
+    };
+    export const ActorInfo: Record<string, {
+        key: string;
+        name: string;
+        icon: string;
+        webviews: WebViewHookConfig[];
+        share: {
+            mode: 'clipboard';
+            prefix: string;
+            xurl: unknown[];
+        };
+    }>;
+}
+
+export namespace Errors {
+    export class CrawlerError extends Error {
+        code: number;
+        context: Record<string, unknown>;
+        constructor(input?: string | {
+            message?: string;
+            code?: number;
+            context?: Record<string, unknown>;
+        });
+        static isCrawlerError(error: unknown): boolean;
+        static from(error: unknown, fallback?: {
+            code?: number;
+            context?: Record<string, unknown>;
+        }): CrawlerError;
+    }
+    export function serializeError(error: unknown): Record<string, unknown>;
+}
+
+export interface LoggerAdapter {
+    info(message: string): void;
+    warning?(message: string): void;
+    warn?(message: string): void;
+    error?(message: string): void;
+    debug?(message: string): void;
+}
+
+export interface LoggerTemplate {
+    step(step: string, status?: string, details?: unknown, level?: 'info' | 'warn' | 'warning' | 'error' | 'success' | 'start' | 'debug'): void;
+    taskStart(detail?: unknown): void;
+    taskSuccess(detail?: unknown): void;
+    taskFail(detail?: unknown, error?: unknown): void;
+    launchStart(detail?: unknown): void;
+    launchSuccess(detail?: unknown): void;
+    launchFail(detail?: unknown, error?: unknown): void;
+    inputMethodSnapshotFail(error?: unknown): void;
+    inputMethodRestoreFail(error?: unknown): void;
+    stepStart(step?: string, detail?: unknown): void;
+    stepSuccess(step?: string, detail?: unknown): void;
+    stepFail(step?: string, error?: unknown): void;
+    stepRetry(step?: string, attempt?: unknown): void;
+    adbExec(detail?: unknown): void;
+    adbRetry(detail?: unknown): void;
+    mutationWaitStart(detail?: unknown): void;
+    mutationWaitSuccess(detail?: unknown): void;
+    mutationWaitWarn(detail?: unknown): void;
+    webViewCommand(detail?: unknown): void;
+    webViewSuccess(detail?: unknown): void;
+    webViewWarn(detail?: unknown): void;
+    webViewFail(error?: unknown): void;
+    screenshotStart(detail?: unknown): void;
+    screenshotDone(detail?: unknown): void;
+    shareStart(detail?: unknown): void;
+    shareSuccess(detail?: unknown): void;
+    shareFail(error?: unknown): void;
+    dataPush(detail?: unknown): void;
+    dataPushFail(error?: unknown): void;
+    info(message: string, detail?: unknown): void;
+    success(message: string, detail?: unknown): void;
+    warning(message: string, detail?: unknown): void;
+    warn(message: string, detail?: unknown): void;
+    error(message: string, detail?: unknown): void;
+    debug(message: string, detail?: unknown): void;
+    start(message: string, detail?: unknown): void;
+}
+
+export interface LoggerModule {
+    setLogger(logger: LoggerAdapter | null): void;
+    createLogger(scope?: string): ScopedLoggerModule;
+    useTemplate(logger?: LoggerAdapter | null): LoggerTemplate;
+    start(message: string, detail?: unknown): void;
+    success(message: string, detail?: unknown): void;
+    fail(message: string, error?: unknown): void;
+    warn(message: string, detail?: unknown): void;
+    warning(message: string, detail?: unknown): void;
+    error(message: string, detail?: unknown): void;
+    info(message: string, detail?: unknown): void;
+    debug(message: string, detail?: unknown): void;
+    duration(startedAt: number): string;
+}
+
+export interface ScopedLoggerModule {
+    start(message: string, detail?: unknown): void;
+    success(message: string, detail?: unknown): void;
+    fail(message: string, error?: unknown): void;
+    warn(message: string, detail?: unknown): void;
+    warning(message: string, detail?: unknown): void;
+    error(message: string, detail?: unknown): void;
+    info(message: string, detail?: unknown): void;
+    debug(message: string, detail?: unknown): void;
+    useTemplate(): LoggerTemplate;
+}
+
+export interface LogTemplate {
+    key: string;
+    label: string;
+    group: string;
+    attention: 'low' | 'medium' | 'high' | 'critical';
+    patterns: RegExp[];
+    defaultSelected?: boolean;
+}
+
+export interface NetworkCaptureModule {
+    path(ctx: AndroidContext, fileName?: string): string;
+    clear(ctx: AndroidContext, options?: {dirPath?: string}): Promise<boolean>;
+    writeRules(ctx: AndroidContext, options?: {rulesJson?: string | Record<string, unknown>}): Promise<boolean>;
+    readText(ctx: AndroidContext, fileName: string, options?: {maxBuffer?: number}): Promise<string>;
+}
+
+export interface AndroidToolkit {
+    Launch: {
+        run(handler: (args: {
+            input: Record<string, unknown>;
+            ctx: AndroidContext;
+            kit: AndroidToolkitRuntime;
+            ApifyKit: AndroidToolkitRuntime['ApifyKit'];
+        }) => Promise<void>, options?: Record<string, unknown>): Promise<void>;
+    };
+    ApifyKit: {
+        useApifyKit(options?: Record<string, unknown>): Promise<AndroidToolkitRuntime['ApifyKit']>;
+    };
+    DeviceInput: AndroidToolkitRuntime['DeviceInput'];
+    DeviceView: AndroidToolkitRuntime['DeviceView'];
+    DeviceSQLite: AndroidToolkitRuntime['DeviceSQLite'];
+    Device: AndroidToolkitRuntime['Device'];
+    Mutation: AndroidToolkitRuntime['Mutation'];
+    NetworkCapture: NetworkCaptureModule;
+    Share: AndroidToolkitRuntime['Share'];
+    WebView: AndroidToolkitRuntime['WebView'];
+    Constants: typeof Constants;
+    Errors: typeof Errors;
+    Logger: LoggerModule;
+    LOG_TEMPLATES: LogTemplate[];
+    $Internals: {
+        LOG_TEMPLATES: LogTemplate[];
+        stripAnsi(input: unknown): string;
+    };
+    Context: {
+        createAndroidContext(input?: Record<string, unknown>, defaults?: Record<string, unknown>): AndroidContext;
+        firstNonEmpty(...values: unknown[]): string;
+        requireNonEmpty(value: unknown, name: string): string;
+    };
+}
+
+export interface AndroidToolkitRuntime {
+    ApifyKit: {
+        runStep<T>(step: string, target: unknown, actionFn: () => Promise<T>, options?: Record<string, unknown>): Promise<T>;
+        runStepLoose<T>(step: string, target: unknown, actionFn: () => Promise<T>, options?: Record<string, unknown>): Promise<T>;
+        pushSuccess(data?: Record<string, unknown>, options?: Record<string, unknown>): Promise<void>;
+        pushFailed(error: unknown, meta?: Record<string, unknown>): Promise<void>;
+        pushArtifact(data?: Record<string, unknown>): Promise<void>;
+        hasPushed(): boolean;
+    };
+    Device: Record<string, (...args: any[]) => Promise<any>> & {
+        writeCacheFile(ctx: AndroidContext, options: DeviceCacheFileOptions): Promise<string>;
+        clearAppCache(ctx: AndroidContext, packageName?: string): Promise<void>;
+    };
+    DeviceSQLite: {
+        query(ctx: AndroidContext, options: Record<string, unknown>): Promise<Record<string, unknown>>;
+        health(ctx: AndroidContext, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    };
+    DeviceInput: {
+        click(ctx: AndroidContext, selectorOrPoint: ViewSelector | ViewBounds | {x: number; y: number}, options?: Record<string, unknown>): Promise<DeviceClickResult>;
+        tap(ctx: AndroidContext, selectorOrPoint: ViewSelector | ViewBounds | {x: number; y: number}, options?: Record<string, unknown>): Promise<DeviceClickResult>;
+        fill(ctx: AndroidContext, selector: ViewSelector, text: string, options?: Record<string, unknown>): Promise<DeviceFillResult>;
+        type(ctx: AndroidContext, selector: ViewSelector, text: string, options?: Record<string, unknown>): Promise<DeviceFillResult>;
+        press(ctx: AndroidContext, key: string, options?: Record<string, unknown>): Promise<void>;
+        pressEnter(ctx: AndroidContext, options?: Record<string, unknown>): Promise<void>;
+        scroll(ctx: AndroidContext, selector: ViewSelector, direction: 'up' | 'down'): Promise<void>;
+        scrollStep(ctx: AndroidContext, selector: ViewSelector, direction: 'up' | 'down', options?: Record<string, unknown>): Promise<void>;
+        scrollToEnd(ctx: AndroidContext, selector: ViewSelector, options?: { settleMs?: number; optional?: boolean; timeoutMs?: number }): Promise<DeviceScrollResult>;
+        scrollToTop(ctx: AndroidContext, selector: ViewSelector, options?: { settleMs?: number; optional?: boolean; timeoutMs?: number }): Promise<DeviceScrollResult>;
+    };
+    DeviceView: {
+        snapshot(ctx: AndroidContext, options?: Record<string, unknown>): Promise<{xml: string; tree: ViewNode[]; roots: ViewNode[]; flat: ViewNode[]; nodes: ViewNode[]}>;
+        find(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<ViewNode>;
+        findAll(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<ViewNode[]>;
+        waitFor(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<ViewNode>;
+        bounds(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<ViewBounds>;
+        text(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<string>;
+        exists(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<boolean>;
+        isScrollable(ctx: AndroidContext, selector: ViewSelector, options?: Record<string, unknown>): Promise<boolean>;
+        hashNode(node: ViewNode): string;
+    };
+    Mutation: {
+        waitForStable(ctx: AndroidContext, selectors: ViewSelector | ViewSelector[] | string | string[], options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+        waitForStableAcrossRoots(ctx: AndroidContext, selectors: ViewSelector | ViewSelector[] | string | string[], options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+        useMonitor(ctx: AndroidContext, selectors: ViewSelector | ViewSelector[] | string | string[], options?: Record<string, unknown>): Promise<{stop(): Promise<Record<string, unknown>>}>;
+    };
+    NetworkCapture: NetworkCaptureModule;
+    WebView: {
+        configureHook(ctx: AndroidContext, actorInfo?: {webviews?: WebViewHookConfig[]}, options?: Record<string, unknown>): Promise<boolean>;
+        list(ctx: AndroidContext, options?: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+        evaluate(ctx: AndroidContext, js: string, options?: Record<string, unknown>): Promise<{
+            id: string;
+            ok: boolean;
+            url: string;
+            title: string;
+            value: unknown;
+            error: string;
+        }>;
+        snapshot(ctx: AndroidContext, options?: Record<string, unknown>): Promise<{
+            url: string;
+            title: string;
+            text: string;
+            html: string;
+            raw: Record<string, unknown>;
+        }>;
+        waitForStable(ctx: AndroidContext, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+        click(ctx: AndroidContext, target?: string | Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    };
+    Share: {
+        captureScreen(ctx: AndroidContext, options?: Record<string, unknown>): Promise<string>;
+        captureLink(ctx: AndroidContext, options?: Record<string, unknown>): Promise<{link: string; source: string; payloadSnapshot: string}>;
+    };
+    Logger: LoggerModule;
+}
+
+export interface DeviceClickResult {
+    target?: ViewNode;
+    actual?: ViewNode;
+    point: {x: number; y: number};
+}
+
+export interface DeviceFillResult {
+    target?: ViewNode;
+    chars: number;
+}
+
+export interface DeviceScrollResult {
+    swipes: number;
+    stableRounds: number;
+    hash: string;
+    hashSource: string;
+    capped: boolean;
+    inferredBoundary?: boolean;
+}
+
+export function useAndroidToolKit(): AndroidToolkit;
+export namespace useAndroidToolKit {
+    const Mode: {
+        default: 'default';
+    };
+}

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@bryce3310687963/android-toolkit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.50",
+  "description": "Native Android automation toolkit for Apify-compatible actors.",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./browser.d.ts",
+        "default": "./dist/browser.js"
+      },
+      "types": "./index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./browser": {
+      "types": "./browser.d.ts",
+      "default": "./dist/browser.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "browser.d.ts",
+    "index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node build.js",
+    "check": "node --check index.js && node --check entrys/node.js && node --check entrys/browser.js && node --check build.js && find src -name '*.js' -maxdepth 3 -print0 | xargs -0 -n1 node --check",
+    "test": "node --test test/*.test.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^4.5.1",
+    "jimp": "^1.6.1",
+    "json-cycle": "^1.5.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}