@skrillex1224/android-toolkit 1.0.3 → 1.0.5

package/dist/index.cjs

@@ -40,6 +40,7 @@ var import_node_fs = __toESM(require("node:fs"), 1);
 var constants_exports = {};
 __export(constants_exports, {
   ActorInfo: () => ActorInfo,
+  AppiumSettings: () => AppiumSettings,
   Code: () => Code,
   Status: () => Status,
   UnicodeIme: () => UnicodeIme
@@ -56,7 +57,7 @@ var Code = Object.freeze({
   ContentUnavailable: 30010003,
   SourceExtractionFailed: 30010004,
   AutomationFailed: 30010005,
-  FridaUnavailable: 30010008,
+  DataAccessUnavailable: 30010008,
   AppNotInstalled: 30010009
 });
 var Status = Object.freeze({
@@ -66,7 +67,12 @@ var Status = Object.freeze({
 var UnicodeIme = Object.freeze({
   packageName: "io.appium.settings",
   component: "io.appium.settings/.UnicodeIME",
-  inputTextAction: "ADB_INPUT_TEXT"
+  inputAction: "ADB_INPUT_TEXT"
+});
+var AppiumSettings = Object.freeze({
+  packageName: "io.appium.settings",
+  clipboardReceiver: "io.appium.settings/.receivers.ClipboardReceiver",
+  clipboardGetAction: "io.appium.settings.clipboard.get"
 });
 var normalizeShare = (share) => {
   const source = share && typeof share === "object" ? share : {};
@@ -111,7 +117,6 @@ function createAndroidContext(input = {}, defaults = {}) {
     serial: firstNonEmpty(defaults.serial, device.serial),
     packageName: firstNonEmpty(defaults.packageName, device.packageName),
     adbPath: firstNonEmpty(defaults.adbPath, process.env.ANDROID_TOOLKIT_ADB_PATH),
-    fridaPath: firstNonEmpty(defaults.fridaPath, process.env.ANDROID_TOOLKIT_FRIDA_PATH),
     appVersion: firstNonEmpty(defaults.appVersion, device.appVersion),
     slotKey: firstNonEmpty(defaults.slotKey, device.slotKey),
     instanceId: firstNonEmpty(defaults.instanceId, device.instanceId),
@@ -297,6 +302,8 @@ var Device = {
   screenshotPng,
   screenshotBase64,
   dumpUiXml,
+  readClipboard,
+  clearClipboard,
   wakeAndUnlock,
   hideKeyboard,
   isKeyboardVisible,
@@ -428,10 +435,12 @@ async function pressEnter(ctx) {
 }
 async function typeText(ctx, text2) {
   await ensureUnicodeIme(ctx);
-  await adbShell(ctx, ["am", "broadcast", "-a", UnicodeIme.inputTextAction, "--es", "msg", String(text2 ?? "")], {
-    timeoutMs: 3e4,
-    maxBuffer: 4 * 1024 * 1024
+  const value = String(text2 ?? "");
+  if (!value) return;
+  await adbShell(ctx, ["input", "text", shellSingleQuote(encodeUnicodeImeText(value))], {
+    timeoutMs: Math.max(15e3, value.length * 300)
   });
+  await sleep(1200);
 }
 async function ensureUnicodeIme(ctx) {
   const out = await adbShell(ctx, ["ime", "list", "-s"], { timeoutMs: 15e3 });
@@ -457,26 +466,71 @@ async function screenshotPng(ctx) {
 async function screenshotBase64(ctx) {
   return `data:image/png;base64,${(await screenshotPng(ctx)).toString("base64")}`;
 }
-async function dumpUiXml(ctx) {
-  const dumpPath = `/data/local/tmp/android-toolkit-window-${Date.now()}-${Math.random().toString(16).slice(2)}.xml`;
-  await adbShell(ctx, ["rm", "-f", dumpPath], { timeoutMs: 1e4 }).catch(() => {
-  });
-  await adbShell(ctx, ["uiautomator", "dump", dumpPath], {
-    timeoutMs: 3e4,
-    maxBuffer: 4 * 1024 * 1024
+async function readClipboard(ctx) {
+  const out = await adbShell(ctx, [
+    "am",
+    "broadcast",
+    "-n",
+    AppiumSettings.clipboardReceiver,
+    "-a",
+    AppiumSettings.clipboardGetAction
+  ], {
+    timeoutMs: 8e3,
+    maxBuffer: 1024 * 1024
+  }).catch((error) => {
+    throw new CrawlerError({
+      message: `source_extraction_failed: Appium Settings clipboard receiver unavailable ${error?.message || String(error)}`,
+      code: Code.SourceExtractionFailed,
+      context: { receiver: AppiumSettings.clipboardReceiver }
+    });
   });
-  try {
-    const raw = await adbShell(ctx, ["cat", dumpPath], {
-      timeoutMs: 3e4,
-      maxBuffer: 16 * 1024 * 1024
+  const text2 = normalizeAppiumClipboardBroadcast(out);
+  if (!text2) {
+    throw new CrawlerError({
+      message: "source_extraction_failed: ADB clipboard is empty",
+      code: Code.SourceExtractionFailed,
+      context: { receiver: AppiumSettings.clipboardReceiver, output: String(out || "").slice(0, 1e3) }
     });
-    const start = String(raw || "").indexOf("<?xml");
-    if (start < 0) throw new CrawlerError({ message: `automation_failed: uiautomator dump missing xml: ${raw}`, code: Code.AutomationFailed });
-    return String(raw || "").slice(start).trim();
-  } finally {
+  }
+  return text2;
+}
+async function clearClipboard(ctx) {
+  Logger.info("Device.clearClipboard skipped", {
+    reason: "Android shell clipboard set is not portable; captureLink validates by link change."
+  });
+}
+async function dumpUiXml(ctx) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const dumpPath = `/data/local/tmp/android-toolkit-window-${Date.now()}-${Math.random().toString(16).slice(2)}.xml`;
     await adbShell(ctx, ["rm", "-f", dumpPath], { timeoutMs: 1e4 }).catch(() => {
     });
+    try {
+      await adbShell(ctx, ["uiautomator", "dump", dumpPath], {
+        timeoutMs: 3e4,
+        maxBuffer: 4 * 1024 * 1024
+      });
+      const raw = await adbShell(ctx, ["cat", dumpPath], {
+        timeoutMs: 3e4,
+        maxBuffer: 16 * 1024 * 1024
+      });
+      const start = String(raw || "").indexOf("<?xml");
+      if (start < 0) throw new CrawlerError({ message: `automation_failed: uiautomator dump missing xml: ${raw}`, code: Code.AutomationFailed });
+      return String(raw || "").slice(start).trim();
+    } catch (error) {
+      lastError = error;
+      Logger.warn("uiautomator dump retry", { attempt, message: error?.message || String(error) });
+      await sleep(350 * attempt);
+    } finally {
+      await adbShell(ctx, ["rm", "-f", dumpPath], { timeoutMs: 1e4 }).catch(() => {
+      });
+    }
   }
+  throw CrawlerError.isCrawlerError(lastError) ? lastError : new CrawlerError({
+    message: `automation_failed: uiautomator dump failed ${lastError?.message || String(lastError || "")}`.trim(),
+    code: Code.AutomationFailed,
+    context: { lastError: lastError?.message || String(lastError || "") }
+  });
 }
 async function wakeAndUnlock(ctx) {
   await pressKey(ctx, "KEYCODE_WAKEUP").catch(() => {
@@ -514,11 +568,51 @@ function requireValue(value, name) {
 }
 function isAdbUnavailableError(error) {
   const message = String(error?.message || error || "");
-  return /ENOENT|spawn .*adb|not found|No such file|device .* not found|no devices|offline/i.test(message);
+  return /ENOENT|spawn .*adb|device .* not found|no devices|offline/i.test(message);
 }
 function compactArgs(args) {
   return args.map(String).join(" ").slice(0, 500);
 }
+function encodeUnicodeImeText(text2) {
+  let out = "";
+  let buffer = "";
+  const flush = () => {
+    if (!buffer) return;
+    const bytes = Buffer.alloc(buffer.length * 2);
+    for (let index = 0; index < buffer.length; index += 1) {
+      bytes.writeUInt16BE(buffer.charCodeAt(index), index * 2);
+    }
+    out += `&${bytes.toString("base64").replace(/\//g, ",").replace(/=+$/g, "")}-`;
+    buffer = "";
+  };
+  for (const char of String(text2 || "")) {
+    const code = char.charCodeAt(0);
+    if (code >= 32 && code <= 126) {
+      flush();
+      out += char === "&" ? "&-" : char;
+    } else {
+      buffer += char;
+    }
+  }
+  flush();
+  return out;
+}
+function shellSingleQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function normalizeAppiumClipboardBroadcast(value) {
+  const out = String(value || "");
+  if (!/Broadcast completed:\s*result=-1\b/.test(out)) return "";
+  const match = /data="([^"]*)"/.exec(out) || /data=([^\s]+)/.exec(out);
+  const base64 = match ? String(match[1] || "").trim() : "";
+  if (!base64) return "";
+  try {
+    return Buffer.from(base64, "base64").toString("utf8").trim();
+  } catch {
+    return "";
+  }
+}
+var $DeviceInternalsForTest = Object.freeze({});
 
 // src/apify-kit.js
 var instance = null;
@@ -711,16 +805,19 @@ async function waitFor(ctx, selector, options = {}) {
   const intervalMs = Number(options.intervalMs || options.pollIntervalMs || 500);
   const deadline = Date.now() + timeoutMs;
   let lastError = null;
+  let sawCleanPoll = false;
   while (Date.now() < deadline) {
     try {
       const node = await find(ctx, selector, { ...options, optional: true });
+      sawCleanPoll = true;
+      lastError = null;
       if (node) return node;
     } catch (error) {
       lastError = error;
     }
     await sleep(intervalMs);
   }
-  if (lastError) throw lastError;
+  if (lastError && !sawCleanPoll) throw lastError;
   throw new CrawlerError({
     message: `automation_failed: \u7B49\u5F85 View \u8D85\u65F6 ${selectorLabel(selector)}`,
     code: Code.AutomationFailed,
@@ -907,9 +1004,27 @@ async function click(ctx, selectorOrPoint, options = {}) {
   return { target, actual, point };
 }
 async function fill(ctx, selector, text2, options = {}) {
-  await click(ctx, selector, options);
-  await Device.typeText(ctx, text2);
+  const value = String(text2 ?? "");
+  const clicked = await click(ctx, selector, {
+    ...options,
+    settleMs: Number(options.focusSettleMs || 350)
+  });
+  try {
+    await Device.typeText(ctx, value);
+  } catch (error) {
+    throw new CrawlerError({
+      message: `automation_failed: View \u5199\u5165\u6587\u672C\u5931\u8D25 ${JSON.stringify(selector)}`,
+      code: Code.AutomationFailed,
+      context: { selector, error: error?.message || String(error) }
+    });
+  }
+  Logger.info("DeviceInput.fill", {
+    selector,
+    target: simplifyNode(clicked.actual || clicked.target),
+    chars: value.length
+  });
   await sleep(Number(options.settleMs || 350));
+  return { target: clicked.actual || clicked.target, chars: value.length };
 }
 async function press(ctx, key) {
   await Device.pressKey(ctx, key);
@@ -997,160 +1112,18 @@ function simplifyNode(node) {
   };
 }
 
-// src/internals/frida-script.js
+// src/device-sqlite.js
 var import_node_child_process2 = require("node:child_process");
-var import_node_fs2 = require("node:fs");
+var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = __toESM(require("node:path"), 1);
-async function runFridaScriptInternal(ctx, source, options = {}) {
-  await assertFridaReady(ctx);
-  const label = String(options.label || "frida-script");
-  const marker = String(options.marker || "ANDROID_TOOLKIT_SCRIPT_JSON ");
-  const pid = await resolvePid(ctx, options.packageName || ctx.packageName);
-  const scriptPath = writeTempScript(source, label);
-  const args = [
-    "-q",
-    "-t",
-    String(Number(options.fridaTimeoutSeconds || 8)),
-    "-D",
-    ctx.serial,
-    "-p",
-    pid,
-    "-l",
-    scriptPath
-  ];
-  Logger.info("frida script start", { label, pid, timeoutMs: Number(options.timeoutMs || 12e3) });
-  try {
-    return await runFridaProcess(ctx.fridaPath, args, {
-      marker,
-      timeoutMs: Number(options.timeoutMs || 12e3),
-      maxLines: Number(options.maxLines || 1500)
-    });
-  } finally {
-    (0, import_node_fs2.rmSync)(import_node_path.default.dirname(scriptPath), { recursive: true, force: true });
-  }
-}
-async function resolveFridaPid(ctx, packageName = ctx.packageName) {
-  return resolvePid(ctx, packageName);
-}
-async function assertFridaReady(ctx) {
-  if (!ctx?.fridaPath) {
-    throw new CrawlerError({
-      message: "frida_unavailable: ANDROID_TOOLKIT_FRIDA_PATH is required",
-      code: Code.FridaUnavailable
-    });
-  }
-  if (!ctx?.serial) {
-    throw new CrawlerError({
-      message: "frida_unavailable: device serial is required",
-      code: Code.FridaUnavailable
-    });
-  }
-}
-async function resolvePid(ctx, packageName = ctx.packageName) {
-  const target = String(packageName || "").trim();
-  if (!target) {
-    throw new CrawlerError({
-      message: "frida_unavailable: packageName is required",
-      code: Code.FridaUnavailable
-    });
-  }
-  const out = await Device.adbShell(ctx, ["pidof", target], { timeoutMs: 8e3 }).catch(() => "");
-  const pid = String(out || "").trim().split(/\s+/).find(Boolean);
-  if (!pid) {
-    throw new CrawlerError({
-      message: `frida_unavailable: target app pid not found ${target}`,
-      code: Code.FridaUnavailable,
-      context: { packageName: target }
-    });
-  }
-  return pid;
-}
-function runFridaProcess(fridaPath, args, options) {
-  return new Promise((resolve, reject) => {
-    const events = [];
-    const lines = [];
-    let buffer = "";
-    let finished = false;
-    const child = (0, import_node_child_process2.spawn)(fridaPath, args, { stdio: ["ignore", "pipe", "pipe"] });
-    const timer = setTimeout(() => {
-      if (finished) return;
-      finished = true;
-      child.kill("SIGTERM");
-      reject(new CrawlerError({
-        message: `frida_unavailable: frida script timeout ${options.timeoutMs}ms`,
-        code: Code.FridaUnavailable,
-        context: { lines: lines.slice(-40) }
-      }));
-    }, options.timeoutMs);
-    const consumeLine = (line) => {
-      const text2 = String(line || "").trim();
-      if (!text2) return;
-      lines.push(text2);
-      if (lines.length > options.maxLines) lines.shift();
-      const markerIndex = text2.indexOf(options.marker);
-      if (markerIndex < 0) return;
-      const jsonText = text2.slice(markerIndex + options.marker.length).trim();
-      try {
-        events.push(JSON.parse(jsonText));
-      } catch (error) {
-        events.push({ type: "parse_error", error: error?.message || String(error), line: text2 });
-      }
-    };
-    const onChunk = (chunk) => {
-      buffer += chunk.toString("utf8");
-      let index = buffer.indexOf("\n");
-      while (index >= 0) {
-        consumeLine(buffer.slice(0, index));
-        buffer = buffer.slice(index + 1);
-        index = buffer.indexOf("\n");
-      }
-    };
-    child.stdout.on("data", onChunk);
-    child.stderr.on("data", onChunk);
-    child.on("error", (error) => {
-      if (finished) return;
-      finished = true;
-      clearTimeout(timer);
-      reject(new CrawlerError({
-        message: `frida_unavailable: ${error?.message || String(error)}`,
-        code: Code.FridaUnavailable
-      }));
-    });
-    child.on("close", () => {
-      if (finished) return;
-      finished = true;
-      clearTimeout(timer);
-      if (buffer.trim()) consumeLine(buffer);
-      const parsed = events.filter((event) => event?.type !== "parse_error");
-      if (parsed.length === 0) {
-        reject(new CrawlerError({
-          message: "frida_unavailable: script emitted no event",
-          code: Code.FridaUnavailable,
-          context: { lines: lines.slice(-40), events }
-        }));
-        return;
-      }
-      resolve(parsed.at(-1));
-    });
-  });
-}
-function writeTempScript(source, label) {
-  const dir = (0, import_node_fs2.mkdtempSync)(import_node_path.default.join((0, import_node_os.tmpdir)(), `android-toolkit-${safeName(label)}-`));
-  const scriptPath = import_node_path.default.join(dir, "script.js");
-  (0, import_node_fs2.writeFileSync)(scriptPath, String(source || ""), "utf8");
-  return scriptPath;
-}
-function safeName(value) {
-  return String(value || "script").replace(/[^a-z0-9_-]+/gi, "-").slice(0, 80);
-}
-
-// src/frida-client.js
-var Frida = {
-  querySQLite,
+var import_node_util2 = require("node:util");
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var DeviceSQLite = {
+  query,
   health
 };
-async function querySQLite(ctx, options = {}) {
+async function query(ctx, options = {}) {
   if (!options.sql) {
     throw new CrawlerError({
       message: "invalid_request: sql is required",
@@ -1165,118 +1138,186 @@ async function querySQLite(ctx, options = {}) {
     dbNameExcludes: normalizeStringArray(options.dbNameExcludes),
     sql: String(options.sql || ""),
     args: normalizeStringArray(options.args),
-    maxRows: Math.max(1, Number(options.maxRows || 200))
+    maxRows: Math.max(1, Number(options.maxRows || 200)),
+    label: String(options.label || "query-sqlite")
   };
-  const event = await runFridaScriptInternal(ctx, sqliteScript(config), {
-    label: options.label || "query-sqlite",
-    packageName: options.packageName || ctx.packageName,
-    timeoutMs: options.timeoutMs || 3e4,
-    fridaTimeoutSeconds: options.fridaTimeoutSeconds || 25,
-    maxLines: options.maxLines || 4e3
-  });
-  if (!event.ok) {
+  if (!config.dbPath && !config.dbDir) {
     throw new CrawlerError({
-      message: `content_unavailable: sqlite query failed ${event.error || ""}`.trim(),
-      code: Code.ContentUnavailable,
-      context: event
+      message: "invalid_request: dbPath or dbDir is required",
+      code: Code.InvalidRequest
+    });
+  }
+  const startedAt = Date.now();
+  const dir = await (0, import_promises.mkdtemp)(import_node_path.default.join((0, import_node_os.tmpdir)(), "android-toolkit-sqlite-"));
+  try {
+    const dbPaths = await resolveDeviceDbPaths(ctx, config);
+    if (dbPaths.length === 0) {
+      throw new CrawlerError({
+        message: "data_access_unavailable: sqlite database not found",
+        code: Code.DataAccessUnavailable,
+        context: { dbDir: config.dbDir, dbPath: config.dbPath, dbNamePrefix: config.dbNamePrefix }
+      });
+    }
+    const databases = [];
+    for (const dbPath of dbPaths) {
+      const localDbPath = await pullDatabaseSnapshot(ctx, dbPath, dir);
+      const result = await queryLocalSQLite(localDbPath, config);
+      databases.push({
+        dbPath,
+        columns: result.columns,
+        rows: result.rows,
+        rowCount: result.rows.length,
+        truncated: result.truncated
+      });
+    }
+    Logger.info("DeviceSQLite.query", {
+      label: config.label,
+      databaseCount: databases.length,
+      rowCount: databases.reduce((total, item) => total + item.rowCount, 0),
+      duration: Logger.duration(startedAt)
+    });
+    return { ok: true, databases, rows: databases.length === 1 ? databases[0].rows : [] };
+  } finally {
+    await (0, import_promises.rm)(dir, { recursive: true, force: true }).catch(() => {
     });
   }
-  return event;
 }
-async function health(ctx) {
-  if (!ctx?.fridaPath) {
+async function health(ctx, options = {}) {
+  const packageName = String(options.packageName || ctx?.packageName || "").trim();
+  if (!packageName) {
     throw new CrawlerError({
-      message: "frida_unavailable: ANDROID_TOOLKIT_FRIDA_PATH is required",
-      code: Code.FridaUnavailable
+      message: "invalid_request: packageName is required",
+      code: Code.InvalidRequest
     });
   }
-  if (!ctx?.serial) {
+  await adbSuShell(ctx, `test -d ${shellQuote(`/data/data/${packageName}`)}`, {
+    timeoutMs: Number(options.timeoutMs || 1e4)
+  });
+  return { ok: true, packageName };
+}
+async function resolveDeviceDbPaths(ctx, config) {
+  if (config.dbPath) return [config.dbPath];
+  const command = `cd ${shellQuote(config.dbDir)} || exit 1; for file in *; do [ -f "$file" ] || continue; case "$file" in *-wal|*-shm) continue ;; esac; printf "%s\\n" "$file"; done`;
+  const out = await adbSuShell(ctx, command, {
+    timeoutMs: 15e3,
+    maxBuffer: 2 * 1024 * 1024
+  }).catch((error) => {
     throw new CrawlerError({
-      message: "frida_unavailable: device serial is required",
-      code: Code.FridaUnavailable
+      message: `data_access_unavailable: sqlite dbDir unavailable ${error?.message || String(error)}`,
+      code: Code.DataAccessUnavailable,
+      context: { dbDir: config.dbDir }
     });
-  }
-  const pid = await resolveFridaPid(ctx, ctx.packageName);
-  return { ok: true, pid };
-}
-function sqliteScript(config) {
-  return `
-Java.perform(function () {
-  function emit(payload) { console.log('ANDROID_TOOLKIT_SCRIPT_JSON ' + JSON.stringify(payload)); }
-  var config = ${JSON.stringify(config)};
-  var JavaString = Java.use('java.lang.String');
-  function safeString(cursor, index) {
-    try { return cursor.isNull(index) ? '' : String(cursor.getString(index)); } catch (_) { return ''; }
-  }
-  function stringArray(values) {
-    if (!values || values.length === 0) return null;
-    var out = [];
-    for (var i = 0; i < values.length; i++) out.push(String(values[i]));
-    return Java.array('java.lang.String', out);
-  }
-  function matchesName(name) {
-    if (config.dbNamePrefix && name.indexOf(config.dbNamePrefix) !== 0) return false;
-    if (config.dbNameIncludes && name.indexOf(config.dbNameIncludes) < 0) return false;
-    for (var i = 0; i < config.dbNameExcludes.length; i++) {
-      if (String(name).indexOf(config.dbNameExcludes[i]) >= 0) return false;
-    }
-    return true;
-  }
-  function dbPaths() {
-    if (config.dbPath) return [config.dbPath];
-    var File = Java.use('java.io.File');
-    var dir = File.$new(config.dbDir);
-    var files = dir.listFiles();
-    var out = [];
-    if (!files) return out;
-    for (var i = 0; i < files.length; i++) {
-      var name = String(files[i].getName());
-      if (matchesName(name)) out.push(String(files[i].getAbsolutePath()));
-    }
-    return out;
-  }
-  function queryOne(dbPath) {
-    var SQLiteDatabase = Java.use('android.database.sqlite.SQLiteDatabase');
-    var db = SQLiteDatabase.openDatabase(JavaString.$new(dbPath), null, 1);
-    try {
-      var cursor = db.rawQuery(JavaString.$new(config.sql), stringArray(config.args));
-      var columns = [];
-      var columnCount = cursor.getColumnCount();
-      for (var c = 0; c < columnCount; c++) columns.push(String(cursor.getColumnName(c)));
-      var rows = [];
-      var truncated = false;
-      while (cursor.moveToNext()) {
-        if (rows.length >= config.maxRows) { truncated = true; break; }
-        var row = {};
-        for (var i = 0; i < columns.length; i++) row[columns[i]] = safeString(cursor, i);
-        rows.push(row);
-      }
-      cursor.close();
-      return { dbPath: dbPath, columns: columns, rows: rows, rowCount: rows.length, truncated: truncated };
-    } finally {
-      db.close();
-    }
-  }
+  });
+  return String(out || "").split("\n").map((line) => line.trim()).filter(Boolean).filter((name) => matchesName(name, config)).map((name) => `${config.dbDir.replace(/\/+$/, "")}/${name}`).sort();
+}
+async function pullDatabaseSnapshot(ctx, dbPath, localDir) {
+  const serial = requireNonEmpty2(ctx?.serial, "serial");
+  const adbPath = requireNonEmpty2(ctx?.adbPath, "adbPath");
+  const baseName = import_node_path.default.basename(dbPath);
+  const remoteDir = `/data/local/tmp/android-toolkit-sqlite-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const remoteDb = `${remoteDir}/${baseName}`;
+  const localDb = import_node_path.default.join(localDir, baseName);
+  const copyCommand = [
+    `rm -rf ${shellQuote(remoteDir)}`,
+    `mkdir -p ${shellQuote(remoteDir)}`,
+    `cp ${shellQuote(dbPath)} ${shellQuote(remoteDb)}`,
+    `[ -f ${shellQuote(`${dbPath}-wal`)} ] && cp ${shellQuote(`${dbPath}-wal`)} ${shellQuote(`${remoteDb}-wal`)} || true`,
+    `[ -f ${shellQuote(`${dbPath}-shm`)} ] && cp ${shellQuote(`${dbPath}-shm`)} ${shellQuote(`${remoteDb}-shm`)} || true`,
+    `chmod 644 ${shellQuote(remoteDir)}/*`
+  ].join(" && ");
   try {
-    var paths = dbPaths();
-    if (paths.length === 0) { emit({ ok: false, error: 'sqlite database not found', config: config }); return; }
-    var databases = [];
-    for (var d = 0; d < paths.length; d++) databases.push(queryOne(paths[d]));
-    emit({ ok: true, databases: databases, rows: databases.length === 1 ? databases[0].rows : [] });
-  } catch (error) {
-    emit({ ok: false, error: String(error), stack: String(error.stack || '') });
+    await adbSuShell(ctx, copyCommand, { timeoutMs: 3e4, maxBuffer: 4 * 1024 * 1024 });
+    await adbPull(adbPath, serial, remoteDb, localDb).catch((error) => {
+      throw new CrawlerError({
+        message: `data_access_unavailable: sqlite snapshot pull failed ${error?.message || String(error)}`,
+        code: Code.DataAccessUnavailable,
+        context: { dbPath }
+      });
+    });
+    await adbPullOptional(adbPath, serial, `${remoteDb}-wal`, `${localDb}-wal`);
+    await adbPullOptional(adbPath, serial, `${remoteDb}-shm`, `${localDb}-shm`);
+    return localDb;
+  } finally {
+    await adbSuShell(ctx, `rm -rf ${shellQuote(remoteDir)}`, { timeoutMs: 1e4 }).catch(() => {
+    });
   }
-});
+}
+async function adbSuShell(ctx, command, options = {}) {
+  return Device.adbShell(ctx, [`su -c ${shellQuote(command)}`], options);
+}
+async function queryLocalSQLite(dbPath, config) {
+  const payloadPath = `${dbPath}.query.json`;
+  const outputPath = `${dbPath}.rows.json`;
+  await (0, import_promises.writeFile)(payloadPath, JSON.stringify({
+    dbPath,
+    sql: config.sql,
+    args: config.args,
+    maxRows: config.maxRows,
+    outputPath
+  }), "utf8");
+  const code = `
+const fs = require('node:fs');
+const { DatabaseSync } = require('node:sqlite');
+const payload = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
+const db = new DatabaseSync(payload.dbPath, { open: true, readOnly: true });
+try {
+  const stmt = db.prepare(payload.sql);
+  const columns = stmt.columns().map((column) => String(column.name || ''));
+  const rows = [];
+  let truncated = false;
+  for (const row of stmt.iterate(...payload.args)) {
+    if (rows.length >= payload.maxRows) { truncated = true; break; }
+    const out = {};
+    for (const column of columns) out[column] = row[column] == null ? '' : String(row[column]);
+    rows.push(out);
+  }
+  fs.writeFileSync(payload.outputPath, JSON.stringify({ columns, rows, truncated }), 'utf8');
+} finally {
+  db.close();
+}
 `;
+  await execFileAsync2(process.execPath, ["-e", code, payloadPath], {
+    timeout: 3e4,
+    maxBuffer: 4 * 1024 * 1024,
+    encoding: "utf8"
+  });
+  return JSON.parse(await import("node:fs/promises").then((fs3) => fs3.readFile(outputPath, "utf8")));
+}
+async function adbPull(adbPath, serial, remotePath, localPath) {
+  await execFileAsync2(adbPath, ["-s", serial, "pull", remotePath, localPath], {
+    timeout: 3e4,
+    maxBuffer: 8 * 1024 * 1024,
+    encoding: "utf8"
+  });
+}
+async function adbPullOptional(adbPath, serial, remotePath, localPath) {
+  await adbPull(adbPath, serial, remotePath, localPath).catch(() => {
+  });
+}
+function matchesName(name, config) {
+  if (config.dbNamePrefix && !name.startsWith(config.dbNamePrefix)) return false;
+  if (config.dbNameIncludes && !name.includes(config.dbNameIncludes)) return false;
+  for (const item of config.dbNameExcludes || []) {
+    if (item && name.includes(item)) return false;
+  }
+  return true;
 }
 function normalizeStringArray(value) {
   if (Array.isArray(value)) return value.map((item) => String(item ?? ""));
   if (value == null) return [];
   return [String(value)];
 }
+function requireNonEmpty2(value, name) {
+  const clean = String(value ?? "").trim();
+  if (!clean) throw new CrawlerError({ message: `invalid_request: ${name} is required`, code: Code.InvalidRequest });
+  return clean;
+}
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
 
 // src/launch.js
-var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 
 // src/mutation.js
 var MUTATION_MONITOR_MODE = Object.freeze({
@@ -1567,12 +1608,8 @@ var compressImageBuffer = async (buffer, compression) => {
   let smallest = null;
   for (let attempt = 0; attempt < 12; attempt += 1) {
     const candidate = await encodeJpeg(sourceImage, compression, scale, quality);
-    if (!smallest || candidate.bytes < smallest.bytes) {
-      smallest = candidate;
-    }
-    if (candidate.bytes <= compression.maxBytes) {
-      return { ...candidate, withinLimit: true };
-    }
+    if (!smallest || candidate.bytes < smallest.bytes) smallest = candidate;
+    if (candidate.bytes <= compression.maxBytes) return { ...candidate, withinLimit: true };
     if (quality > minQuality) {
       quality = Math.max(minQuality, Math.floor(quality * 0.75));
       continue;
@@ -1582,9 +1619,7 @@ var compressImageBuffer = async (buffer, compression) => {
       compression.minScale,
       Math.min(scale * 0.85, scale * ratio * 0.94)
     );
-    if (nextScale >= scale * 0.99 || scale <= compression.minScale) {
-      break;
-    }
+    if (nextScale >= scale * 0.99 || scale <= compression.minScale) break;
     scale = nextScale;
   }
   const finalCandidate = await encodeJpeg(sourceImage, compression, compression.minScale, minQuality);
@@ -1600,9 +1635,7 @@ var compressImageBufferToBase64 = async (buffer, compression) => {
     Logger.warn("captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE", { message: error?.message || String(error) });
     return null;
   });
-  if (!result?.buffer) {
-    return buffer.toString("base64");
-  }
+  if (!result?.buffer) return buffer.toString("base64");
   if (result.withinLimit) {
     Logger.info("captureScreen \u5DF2\u538B\u7F29", {
       originalBytes,
@@ -1690,21 +1723,24 @@ async function captureLink(ctx, options = {}) {
   const deadline = Date.now() + timeoutMs;
   const prefix = String(share.prefix || "").trim();
   Logger.start("Share.captureLink", { actor: actorInfo.key, prefix, timeoutMs });
-  await clearClipboard(ctx).catch((error) => {
-    Logger.warn("Share.captureLink clearClipboard failed", { message: error?.message || String(error) });
-  });
+  const beforeEvent = await readClipboard2(ctx).catch(() => null);
+  const beforeLink = beforeEvent ? selectLink(beforeEvent, prefix) : "";
+  if (beforeLink) Logger.info("Share.captureLink baseline", { beforeLink });
   if (typeof options.performActions === "function") {
     await options.performActions();
   }
   let lastEvent = null;
   while (Date.now() < deadline) {
-    const event = await readClipboard(ctx).catch((error) => ({ ok: false, error: error?.message || String(error) }));
+    const event = await readClipboard2(ctx).catch((error) => ({ ok: false, error: error?.message || String(error) }));
     lastEvent = event;
     const link = selectLink(event, prefix);
-    if (link) {
+    if (link && link !== beforeLink) {
       Logger.success("Share.captureLink", { link });
       return { link, source: event.source || "clipboard", payloadSnapshot: event.payloadSnapshot || "" };
     }
+    if (link && link === beforeLink) {
+      lastEvent = { ...event, rejected: "same_as_baseline", beforeLink };
+    }
     await sleep(pollIntervalMs);
   }
   throw new CrawlerError({
@@ -1713,77 +1749,20 @@ async function captureLink(ctx, options = {}) {
     context: { prefix, lastEvent }
   });
 }
-async function clearClipboard(ctx) {
-  await runFridaScriptInternal(ctx, clipboardScript("clear"), {
-    label: "share-clear-clipboard",
-    timeoutMs: 8e3,
-    fridaTimeoutSeconds: 8
-  });
-}
-async function readClipboard(ctx) {
-  return runFridaScriptInternal(ctx, clipboardScript("read"), {
-    label: "share-read-clipboard",
-    timeoutMs: 9e3,
-    fridaTimeoutSeconds: 8,
-    maxLines: 1500
-  });
-}
-function clipboardScript(mode) {
-  return `
-Java.perform(function () {
-  function emit(payload) { console.log('ANDROID_TOOLKIT_SCRIPT_JSON ' + JSON.stringify(payload)); }
-  var mode = ${JSON.stringify(mode)};
-  var JavaObject = Java.use('java.lang.Object');
-  function text(value) {
-    if (value === null || value === undefined) return '';
-    try { return Java.cast(value, JavaObject).toString() + ''; } catch (_) {}
-    try { return value.toString.overload().call(value) + ''; } catch (_) {}
-    try { return value.toString() + ''; } catch (_) {}
-    return '';
-  }
-  function addCandidate(out, source, value) {
-    var s = text(value);
-    if (!s) return;
-    var matches = s.match(/https?:\\/\\/[^\\s"'<>\uFF0C\u3002]+/g) || [];
-    for (var i = 0; i < matches.length; i++) {
-      var link = matches[i].replace(/[)\\].,\uFF0C\u3002\uFF1B;!?\uFF01\uFF1F]+$/g, '');
-      out.push({ source: source, link: link, payload: s.slice(0, 1000) });
-    }
-  }
-  try {
-    var ActivityThread = Java.use('android.app.ActivityThread');
-    var ClipData = Java.use('android.content.ClipData');
-    var app = ActivityThread.currentApplication();
-    var manager = app ? app.getSystemService('clipboard') : null;
-    if (!manager) { emit({ ok: false, error: 'clipboard manager unavailable' }); return; }
-    if (mode === 'clear') {
-      manager.setPrimaryClip(ClipData.newPlainText('android-toolkit', ''));
-      emit({ ok: true, source: 'clipboard.clear' });
-      return;
-    }
-    var candidates = [];
-    var clip = manager.getPrimaryClip();
-    var count = clip ? clip.getItemCount() : 0;
-    for (var i = 0; i < count; i++) {
-      var item = clip.getItemAt(i);
-      try { addCandidate(candidates, 'clipboard.text', item.getText()); } catch (_) {}
-      try { addCandidate(candidates, 'clipboard.html', item.getHtmlText()); } catch (_) {}
-      try { addCandidate(candidates, 'clipboard.uri', item.getUri()); } catch (_) {}
-      try { addCandidate(candidates, 'clipboard.intent', item.getIntent()); } catch (_) {}
-      try { addCandidate(candidates, 'clipboard.coerceToText', item.coerceToText(app)); } catch (_) {}
-    }
-    emit({
-      ok: candidates.length > 0,
-      link: candidates.length > 0 ? candidates[0].link : '',
-      source: candidates.length > 0 ? candidates[0].source : 'clipboard',
-      candidates: candidates,
-      payloadSnapshot: candidates.length > 0 ? String(candidates[0].payload || '').slice(0, 500) : ''
-    });
-  } catch (error) {
-    emit({ ok: false, error: String(error), stack: String(error.stack || '') });
-  }
-});
-`;
+async function readClipboard2(ctx) {
+  const payload = await Device.readClipboard(ctx);
+  const candidates = extractLinks(payload).map((link) => ({
+    source: "adb.clipboard",
+    link,
+    payload: payload.slice(0, 1e3)
+  }));
+  return {
+    ok: candidates.length > 0,
+    link: candidates[0]?.link || "",
+    source: "adb.clipboard",
+    candidates,
+    payloadSnapshot: payload.slice(0, 500)
+  };
 }
 async function composeSprite(buffers, options = {}) {
   if (!buffers.length) {
@@ -1828,6 +1807,11 @@ function selectLink(event, prefix) {
   }
   return candidates.find((link) => !prefix || String(link).startsWith(prefix)) || "";
 }
+function extractLinks(value) {
+  const text2 = String(value || "");
+  const matches = text2.match(/https?:\/\/[^\s"'<>，。]+/g) || [];
+  return matches.map((link) => link.replace(/[)\].,，。；;!?！？]+$/g, ""));
+}
 
 // src/launch.js
 var DEFAULT_INPUT_PATH = "/apify_storage/input.json";
@@ -1839,7 +1823,7 @@ async function run(handler, options = {}) {
   const startedAt = Date.now();
   const inputPath = pathOption(options.inputPath, DEFAULT_INPUT_PATH);
   const outputPath = pathOption(options.outputPath, DEFAULT_OUTPUT_PATH);
-  const input = options.input || JSON.parse(import_node_fs3.default.readFileSync(inputPath, "utf8"));
+  const input = options.input || JSON.parse(import_node_fs2.default.readFileSync(inputPath, "utf8"));
   const ctx = options.ctx || Context.createAndroidContext(input, options.contextDefaults || {});
   ctx.runId = ctx.runId || input.run_id || input.runId || input.runtime?.run_id || input.runtime?.runId || "";
   ctx.actorKey = ctx.actorKey || options.actorKey || input.actorKey || input.actor_name || input.actorName || "";
@@ -1856,7 +1840,7 @@ async function run(handler, options = {}) {
     Device,
     DeviceInput,
     DeviceView,
-    Frida,
+    DeviceSQLite,
     Share,
     Mutation,
     Logger,
@@ -1894,20 +1878,26 @@ function pathOption(value, fallback) {
 }
 
 // entrys/node.js
-var useAndroidToolKit = () => ({
-  Launch,
-  ApifyKit,
-  DeviceInput,
-  DeviceView,
-  Device,
-  Mutation,
-  Share,
-  Frida,
-  Constants: constants_exports,
-  Errors: errors_exports,
-  Logger,
-  Context
+var ToolkitMode = Object.freeze({
+  default: "default"
 });
+var useAndroidToolKit = () => {
+  return {
+    Launch,
+    ApifyKit,
+    DeviceInput,
+    DeviceView,
+    DeviceSQLite,
+    Device,
+    Mutation,
+    Share,
+    Constants: constants_exports,
+    Errors: errors_exports,
+    Logger,
+    Context
+  };
+};
+useAndroidToolKit.Mode = ToolkitMode;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   useAndroidToolKit