assistsx-js 0.1.41 → 0.2.0

package/src/log/log.ts

@@ -0,0 +1,445 @@
+/**
+ * 日志桥接：与 tools/log/AssistsLogJavascriptInterface.kt、ASWebView.kt 对齐。
+ * 使用 assistsxLog.call + assistsxLogCallback；页面级推送 onAssistsLogUpdate。
+ */
+import { CallResponse } from "../call-response";
+import { decodeBase64UTF8, generateUUID } from "../utils";
+import { LogCallMethod, type LogStreamType } from "./log-call-method";
+
+const pendingCallbacks: Map<string, (data: string) => void> = new Map();
+const streamHandlers: Map<string, (data: string) => void> = new Map();
+const subscriptionIdToCallbackId: Map<string, string> = new Map();
+
+if (typeof window !== "undefined" && !window.assistsxLogCallback) {
+    window.assistsxLogCallback = (data: string) => {
+        try {
+            const json = decodeBase64UTF8(data);
+            const response = JSON.parse(json) as {
+                callbackId?: string;
+                code?: number;
+                message?: string;
+                data?: Record<string, unknown>;
+            };
+            const callbackId = response.callbackId;
+            if (!callbackId) {
+                return;
+            }
+            if (streamHandlers.has(callbackId)) {
+                streamHandlers.get(callbackId)!(json);
+                return;
+            }
+            const pending = pendingCallbacks.get(callbackId);
+            if (pending) {
+                pending(json);
+                pendingCallbacks.delete(callbackId);
+            }
+        } catch (e) {
+            console.error("Log bridge callback error:", e);
+        }
+    };
+}
+
+/**
+ * onAssistsLogUpdate 推送的监听器列表（与 accessibilityEventListeners 风格一致）。
+ * 在页面加载本模块后，向此数组 push，或使用 log.addLogUpdateListener。
+ * 注意：若页面在 import 本模块之前已自定义 `window.onAssistsLogUpdate`，则不会安装默认分发函数，需自行解码并转发到监听器。
+ */
+export const logUpdateListeners: Array<
+    (payload: LogUpdateEvent) => void
+> = [];
+
+/**
+ * Base64 解码后的 CallResponse，data 含 stream / text
+ */
+export interface LogUpdateEvent {
+    code: number;
+    data: LogUpdateData | null;
+    message?: string;
+    callbackId?: string | null;
+}
+
+export interface LogUpdateData {
+    stream: LogStreamType;
+    text: string;
+}
+
+export interface LogSubscribeUpdatePayload {
+    text: string;
+    stream: string;
+    subscriptionId: string;
+}
+
+export interface LogUploadOptions {
+    baseUrl?: string;
+    /** PNG（默认）| JPEG | JPG | WEBP */
+    format?: "PNG" | "JPEG" | "JPG" | "WEBP" | string;
+    prettyPrint?: boolean;
+    overlayHiddenDelayMillis?: number;
+    /** 与 Kotlin handleUploadLogs / AssistsLogDiagnostics.uploadLogs 的 uploadKey 一致 */
+    uploadKey?: string;
+}
+
+/** 与 Kotlin assistsLogUploadResultToJson 对齐 */
+export interface LogUploadResult {
+    success: boolean;
+    message: string;
+    httpCode?: number;
+    responseBody?: string;
+    data?: unknown;
+    localLogFilePath?: string;
+    localScreenshotFilePath?: string;
+    localNodeTreeFilePath?: string;
+    causeMessage?: string;
+}
+
+if (typeof window !== "undefined" && !window.onAssistsLogUpdate) {
+    window.onAssistsLogUpdate = (encoded: string) => {
+        logUpdateListeners.forEach((listener) => {
+            try {
+                const decoded = decodeBase64UTF8(encoded);
+                const parsed = JSON.parse(decoded) as LogUpdateEvent;
+                listener(parsed);
+            } catch (error) {
+                console.error("Log update listener error:", error);
+            }
+        });
+    };
+}
+
+export class Log {
+    private getBridge(): NonNullable<Window["assistsxLog"]> {
+        if (typeof window === "undefined" || !window.assistsxLog) {
+            throw new Error("assistsxLog bridge is not available");
+        }
+        return window.assistsxLog;
+    }
+
+    private async asyncCall(
+        method: string,
+        args?: Record<string, unknown>,
+        timeout: number = 30
+    ): Promise<CallResponse> {
+        const uuid = generateUUID();
+        const params = {
+            method,
+            arguments: args ?? undefined,
+            callbackId: uuid,
+        };
+        const promise = new Promise<string>((resolve) => {
+            pendingCallbacks.set(uuid, (data: string) => {
+                resolve(data);
+            });
+            setTimeout(() => {
+                pendingCallbacks.delete(uuid);
+                resolve(
+                    JSON.stringify(new CallResponse(-1, null, uuid))
+                );
+            }, timeout * 1000);
+        });
+        this.getBridge().call(JSON.stringify(params));
+        const promiseResult = await promise;
+        if (typeof promiseResult === "string") {
+            const responseData = JSON.parse(promiseResult);
+            return new CallResponse(
+                responseData.code,
+                responseData.data,
+                responseData.callbackId
+            );
+        }
+        throw new Error("Log bridge call failed");
+    }
+
+    /** 读取当前日志全文 */
+    async readAllText(timeout?: number): Promise<string> {
+        const res = await this.asyncCall(
+            LogCallMethod.readAllText,
+            undefined,
+            timeout
+        );
+        const d = res.getDataOrNull() as { text?: string } | null;
+        return d?.text ?? "";
+    }
+
+    /**
+     * 获取日志服务当前域名（origin，无路径；与上传、管理后台同源）。
+     * 与 Kotlin getLogServiceBaseUrl / adminWebBaseUrl 对齐。
+     */
+    async getLogServiceBaseUrl(timeout?: number): Promise<string> {
+        const res = await this.asyncCall(
+            LogCallMethod.getLogServiceBaseUrl,
+            undefined,
+            timeout
+        );
+        const d = res.getDataOrNull() as { baseUrl?: string } | null;
+        return d?.baseUrl ?? "";
+    }
+
+    /** 清空日志 */
+    async clear(timeout?: number): Promise<boolean> {
+        const res = await this.asyncCall(
+            LogCallMethod.clear,
+            undefined,
+            timeout
+        );
+        return res.isSuccess();
+    }
+
+    /** 从文件重新加载到内存 Flow */
+    async refreshFromFile(timeout?: number): Promise<boolean> {
+        const res = await this.asyncCall(
+            LogCallMethod.refreshFromFile,
+            undefined,
+            timeout
+        );
+        return res.isSuccess();
+    }
+
+    /** 追加一行 */
+    async appendLine(
+        line: string,
+        maxLength?: number,
+        timeout?: number
+    ): Promise<boolean> {
+        const args: Record<string, unknown> = { line };
+        if (maxLength !== undefined) {
+            args.maxLength = maxLength;
+        }
+        const res = await this.asyncCall(
+            LogCallMethod.appendLine,
+            args,
+            timeout
+        );
+        return res.isSuccess();
+    }
+
+    /** 追加带时间戳的条目 */
+    async appendTimestampedEntry(
+        message: string,
+        timeout?: number
+    ): Promise<boolean> {
+        const res = await this.asyncCall(
+            LogCallMethod.appendTimestampedEntry,
+            { message },
+            timeout
+        );
+        return res.isSuccess();
+    }
+
+    /** 替换全部内容 */
+    async replaceAll(
+        content: string,
+        timeout?: number
+    ): Promise<boolean> {
+        const res = await this.asyncCall(
+            LogCallMethod.replaceAll,
+            { content },
+            timeout
+        );
+        return res.isSuccess();
+    }
+
+    /**
+     * 订阅 Flow：先收到 subscribed，再多次 update。
+     * resolve 后请保留 dispose 或调用 unsubscribe(subscriptionId) 以释放原生协程与 JS 回调。
+     */
+    async subscribe(
+        stream: LogStreamType,
+        onUpdate: (payload: LogSubscribeUpdatePayload) => void,
+        options?: { timeout?: number }
+    ): Promise<{
+        subscriptionId: string;
+        dispose: () => Promise<void>;
+    }> {
+        const self = this;
+        const callbackId = generateUUID();
+        const timeoutSec = options?.timeout ?? 30;
+
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    streamHandlers.delete(callbackId);
+                    reject(new Error("Log subscribe timeout"));
+                }
+            }, timeoutSec * 1000);
+
+            streamHandlers.set(callbackId, (raw: string) => {
+                let response: {
+                    code?: number;
+                    message?: string;
+                    data?: {
+                        event?: string;
+                        subscriptionId?: string;
+                        stream?: string;
+                        text?: string;
+                    };
+                };
+                try {
+                    response = JSON.parse(raw);
+                } catch {
+                    return;
+                }
+                const data = response.data;
+                const code = response.code;
+
+                if (typeof code === "number" && code !== 0) {
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(timer);
+                        streamHandlers.delete(callbackId);
+                        reject(
+                            new Error(
+                                response.message ?? "Log subscribe failed"
+                            )
+                        );
+                    }
+                    return;
+                }
+
+                if (data?.event === "subscribed" && data.subscriptionId) {
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(timer);
+                        const sid = data.subscriptionId;
+                        subscriptionIdToCallbackId.set(sid, callbackId);
+                        resolve({
+                            subscriptionId: sid,
+                            dispose: async () => {
+                                await self.unsubscribe(sid);
+                            },
+                        });
+                    }
+                    return;
+                }
+
+                if (data?.event === "update" && data.subscriptionId) {
+                    onUpdate({
+                        text: data.text ?? "",
+                        stream: data.stream ?? stream,
+                        subscriptionId: data.subscriptionId,
+                    });
+                }
+            });
+
+            try {
+                this.getBridge().call(
+                    JSON.stringify({
+                        method: LogCallMethod.subscribe,
+                        arguments: { stream },
+                        callbackId,
+                    })
+                );
+            } catch (e) {
+                clearTimeout(timer);
+                streamHandlers.delete(callbackId);
+                reject(e);
+            }
+        });
+    }
+
+    /** 取消订阅（与 Kotlin handleUnsubscribe 对齐） */
+    async unsubscribe(
+        subscriptionId: string,
+        timeout?: number
+    ): Promise<boolean> {
+        const cbId = subscriptionIdToCallbackId.get(subscriptionId);
+        const res = await this.asyncCall(
+            LogCallMethod.unsubscribe,
+            { subscriptionId },
+            timeout
+        );
+        if (res.isSuccess() && cbId) {
+            streamHandlers.delete(cbId);
+            subscriptionIdToCallbackId.delete(subscriptionId);
+        }
+        return res.isSuccess();
+    }
+
+    /** 截图 + 节点树 + 日志上传（需 Android API 30+） */
+    async uploadLogs(
+        options?: LogUploadOptions & { timeout?: number }
+    ): Promise<LogUploadResult> {
+        const { timeout = 60, ...args } = options ?? {};
+        const payload: Record<string, unknown> = {};
+        if (args.baseUrl !== undefined) {
+            payload.baseUrl = args.baseUrl;
+        }
+        if (args.format !== undefined) {
+            payload.format = args.format;
+        }
+        if (args.prettyPrint !== undefined) {
+            payload.prettyPrint = args.prettyPrint;
+        }
+        if (args.overlayHiddenDelayMillis !== undefined) {
+            payload.overlayHiddenDelayMillis = args.overlayHiddenDelayMillis;
+        }
+        if (args.uploadKey !== undefined) {
+            payload.uploadKey = args.uploadKey;
+        }
+        const uuid = generateUUID();
+        const params = {
+            method: LogCallMethod.uploadLogs,
+            arguments:
+                Object.keys(payload).length > 0 ? payload : undefined,
+            callbackId: uuid,
+        };
+        const promise = new Promise<string>((resolve) => {
+            pendingCallbacks.set(uuid, (data: string) => {
+                resolve(data);
+            });
+            setTimeout(() => {
+                pendingCallbacks.delete(uuid);
+                resolve(JSON.stringify({ code: -1, data: null, callbackId: uuid }));
+            }, timeout * 1000);
+        });
+        this.getBridge().call(JSON.stringify(params));
+        const rawStr = await promise;
+        const raw = JSON.parse(rawStr) as {
+            code: number;
+            data?: LogUploadResult | null;
+            message?: string;
+            callbackId?: string | null;
+        };
+        const d = raw.data;
+        if (d && typeof d === "object" && "success" in d) {
+            return d;
+        }
+        return {
+            success: raw.code === 0,
+            message:
+                typeof raw.message === "string"
+                    ? raw.message
+                    : raw.code !== 0
+                      ? "uploadLogs failed"
+                      : "",
+        };
+    }
+
+    /**
+     * 注册 onAssistsLogUpdate 推送监听（ASWebView 注入的 Base64 CallResponse，解码后见 LogUpdateEvent）
+     */
+    addLogUpdateListener(listener: (payload: LogUpdateEvent) => void): void {
+        logUpdateListeners.push(listener);
+    }
+
+    /**
+     * 移除先前通过 addLogUpdateListener 注册的同一函数引用
+     */
+    removeLogUpdateListener(listener: (payload: LogUpdateEvent) => void): void {
+        const i = logUpdateListeners.indexOf(listener);
+        if (i !== -1) {
+            logUpdateListeners.splice(i, 1);
+        }
+    }
+}
+
+/** 默认单例，用法与 floatingwindow 模块导出的 float 一致 */
+export const log = new Log();
+
+export {
+    LogCallMethod,
+    LogStream,
+    type LogCallMethodType,
+    type LogStreamType,
+} from "./log-call-method";

package/src/mlkit/mlkit.ts

@@ -2,9 +2,9 @@
  * ML Kit 文字识别相关功能
  * 提供识别屏幕中指定词组位置、识别屏幕文字内容位置的能力
  */
-import { CallResponse } from "../CallResponse";
-import { decodeBase64UTF8, generateUUID } from "../Utils";
-import { MlkitCallMethod } from "./MlkitCallMethod";
+import { CallResponse } from "../call-response";
+import { decodeBase64UTF8, generateUUID } from "../utils";
+import { MlkitCallMethod } from "./mlkit-call-method";
 
 /**
  * 识别区域接口，用于限定识别范围

package/src/network/http.ts

@@ -2,8 +2,8 @@
  * HTTP 请求相关功能
  * 提供 HTTP 请求相关的功能，包括 GET、POST、文件上传和下载
  */
-import { CallResponse } from "../CallResponse";
-import { decodeBase64UTF8, generateUUID } from "../Utils";
+import { CallResponse } from "../call-response";
+import { decodeBase64UTF8, generateUUID } from "../utils";
 
 /**
  * HTTP 响应数据接口定义

package/src/{NodeAsync.ts → node-async.ts}

@@ -2,11 +2,11 @@
  * 节点类
  * 表示界面上的一个可交互元素，包含元素的属性和可执行的操作
  */
-import { Bounds } from "./Bounds";
-import { AssistsX } from "./AssistsX";
-import { Step } from "./Step";
-import { AssistsXAsync } from "./AssistsXAsync";
-import { Node } from "./Node";
+import { Bounds } from "./bounds";
+import { AssistsX } from "./assistsx";
+import { Step } from "./step";
+import { AssistsXAsync } from "./assistsx-async";
+import { Node } from "./node";
 
 export class NodeAsync {
     private node: Node;

package/src/{Node.ts → node.ts}

@@ -2,11 +2,11 @@
  * 节点类
  * 表示界面上的一个可交互元素，包含元素的属性和可执行的操作
  */
-import { Bounds } from "./Bounds";
-import { AssistsX } from "./AssistsX";
-import { AssistsXAsync } from "./AssistsXAsync";
-import { Step } from "./Step";
-import { NodeAsync } from "./NodeAsync";
+import { Bounds } from "./bounds";
+import { AssistsX } from "./assistsx";
+import { AssistsXAsync } from "./assistsx-async";
+import { Step } from "./step";
+import { NodeAsync } from "./node-async";
 
 // 将接口改造为类
 export class Node {

package/src/{StepAsync.ts → step-async.ts}

@@ -2,14 +2,14 @@
  * 步骤执行控制类
  * 用于管理和执行自动化步骤，提供步骤的生命周期管理、状态控制和界面操作功能
  */
-import { AssistsX } from "./AssistsX";
-import { Node } from "./Node";
-import { CallMethod } from "./CallMethod";
-import { useStepStore } from "./StepStateStore";
-import { generateUUID } from "./Utils";
-import { StepError } from "./StepError";
-import { AssistsXAsync } from "./AssistsXAsync";
-import { Step } from "./Step";
+import { AssistsX } from "./assistsx";
+import { Node } from "./node";
+import { CallMethod } from "./call-method";
+import { useStepStore } from "./step-state-store";
+import { generateUUID } from "./utils";
+import { StepError } from "./step-error";
+import { AssistsXAsync } from "./assistsx-async";
+import { Step } from "./step";
 
 export class StepAsync {
     private step: Step;

package/src/{Step.ts → step.ts}

@@ -2,13 +2,13 @@
  * 步骤执行控制类
  * 用于管理和执行自动化步骤，提供步骤的生命周期管理、状态控制和界面操作功能
  */
-import { AssistsX } from "./AssistsX";
-import { Node } from "./Node";
-import { CallMethod } from "./CallMethod";
-import { useStepStore } from "./StepStateStore";
-import { generateUUID } from "./Utils";
-import { StepError, StepStopError } from "./StepError";
-import { StepAsync } from "./StepAsync";
+import { AssistsX } from "./assistsx";
+import { Node } from "./node";
+import { CallMethod } from "./call-method";
+import { useStepStore } from "./step-state-store";
+import { generateUUID } from "./utils";
+import { StepError, StepStopError } from "./step-error";
+import { StepAsync } from "./step-async";
 
 // 步骤结果类型，可以是Step实例或undefined
 export type StepResult = Step | undefined;

package/dist/AccessibilityEventFilter.d.ts

@@ -1,105 +0,0 @@
-/**
- * AccessibilityEvent过滤配置接口
- * 用于配置AccessibilityEvent的处理方式和过滤条件
- */
-export interface AccessibilityEventFilterConfig {
-    /**
-     * 包名过滤
-     * 如果为空或null，则处理所有包的事件
-     * 如果指定包名，则只处理该包的事件
-     */
-    packageName?: string | null;
-    /**
-     * 是否在子线程中处理AccessibilityEvent
-     * true: 在子线程中处理，避免阻塞主线程
-     * false: 在主线程中处理
-     */
-    processInBackground?: boolean;
-    /**
-     * 是否获取节点信息
-     * true: 获取并解析AccessibilityNodeInfo节点信息
-     * false: 不获取节点信息，提高处理性能
-     */
-    fetchNodeInfo?: boolean;
-    /**
-     * 是否启用日志输出
-     * true: 输出AccessibilityEvent处理日志
-     * false: 不输出日志
-     */
-    enableLogging?: boolean;
-    /**
-     * 事件类型过滤
-     * 如果为空，则处理所有类型的事件
-     * 如果指定类型，则只处理指定类型的事件
-     */
-    eventTypes?: number[] | null;
-    /**
-     * 是否启用事件去重
-     * true: 启用去重，避免重复处理相同事件
-     * false: 不启用去重
-     */
-    enableDeduplication?: boolean;
-}
-/**
- * AccessibilityEvent过滤配置类
- * 用于配置AccessibilityEvent的处理方式和过滤条件
- */
-export declare class AccessibilityEventFilter {
-    /**
-     * 包名过滤
-     */
-    readonly packageName: string | null;
-    /**
-     * 是否在子线程中处理AccessibilityEvent
-     */
-    readonly processInBackground: boolean;
-    /**
-     * 是否获取节点信息
-     */
-    readonly fetchNodeInfo: boolean;
-    /**
-     * 是否启用日志输出
-     */
-    readonly enableLogging: boolean;
-    /**
-     * 事件类型过滤
-     */
-    readonly eventTypes?: number[] | null;
-    /**
-     * 是否启用事件去重
-     */
-    readonly enableDeduplication: boolean;
-    constructor(config?: AccessibilityEventFilterConfig);
-    /**
-     * 检查是否应该处理指定包的事件
-     * @param targetPackageName 目标包名
-     * @returns true表示应该处理，false表示应该过滤
-     */
-    shouldProcessPackage(targetPackageName: string | null): boolean;
-    /**
-     * 检查是否应该处理指定类型的事件
-     * @param eventType 事件类型
-     * @returns true表示应该处理，false表示应该过滤
-     */
-    shouldProcessEventType(eventType: number): boolean;
-    /**
-     * 创建默认的过滤配置
-     * 所有包名，子线程处理，获取节点信息，启用日志
-     */
-    static createDefault(): AccessibilityEventFilter;
-    /**
-     * 创建高性能配置
-     * 不获取节点信息，不启用日志，启用去重
-     */
-    static createHighPerformance(): AccessibilityEventFilter;
-    /**
-     * 创建调试配置
-     * 启用所有功能，便于调试
-     */
-    static createDebug(): AccessibilityEventFilter;
-    /**
-     * 创建指定包名的过滤配置
-     * @param targetPackageName 目标包名
-     */
-    static createForPackage(targetPackageName: string): AccessibilityEventFilter;
-}