@skrillex1224/android-toolkit 0.1.7 → 0.1.9

package/src/device.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import zlib from 'node:zlib';
 import {execFile} from 'node:child_process';
 import {promisify} from 'node:util';
 
@@ -95,6 +96,26 @@ export async function screenSize(ctx) {
     };
 }
 
+export async function screenDensity(ctx) {
+    const out = await adbShell(ctx, ['wm', 'density']).catch(() => '');
+    const match = /(\d+)/.exec(String(out || ''));
+    return match ? Number(match[1]) : 0;
+}
+
+export async function overrideScreenSize(ctx, width, height) {
+    const safeWidth = Math.max(1, Math.round(Number(width) || 0));
+    const safeHeight = Math.max(1, Math.round(Number(height) || 0));
+    await adbShell(ctx, ['wm', 'size', `${safeWidth}x${safeHeight}`], {timeoutMs: 15000});
+}
+
+export async function resetScreenSize(ctx) {
+    await adbShell(ctx, ['wm', 'size', 'reset'], {timeoutMs: 15000});
+}
+
+export async function resetScreenDensity(ctx) {
+    await adbShell(ctx, ['wm', 'density', 'reset'], {timeoutMs: 15000});
+}
+
 export async function tapAbsolute(ctx, x, y) {
     // 点击绝对像素坐标，适合已经从截图或 DOM rect 算出的精确点。
     await adbInput(ctx, ['tap', String(Math.round(Number(x))), String(Math.round(Number(y)))]);
@@ -218,25 +239,71 @@ export async function waitForActivity(ctx, predicate, timeoutMs = 15000, interva
 
 export async function screenshotBase64(ctx) {
     // 获取当前屏幕 PNG，并转成 base64 写入 dataset artifact。
-    const stdout = await adbExec(ctx, ['-s', ctx.serial, 'exec-out', 'screencap', '-p'], {
-        timeoutMs: 15000,
-        encoding: 'buffer',
-        maxBuffer: 8 * 1024 * 1024
-    });
+    const stdout = await screenshotPng(ctx);
     return Buffer.from(stdout).toString('base64');
 }
 
+export async function longScreenshotBase64(ctx, options = {}) {
+    const startedAt = Date.now();
+    const size = await screenSize(ctx).catch(() => ({width: 720, height: 1280}));
+    const captureCount = Math.max(1, Math.min(8, Number(options.captureCount || 4)));
+    const topCrop = clampInt(Number(options.topCrop ?? Math.floor(size.height * 0.12)), 0, size.height - 1);
+    const bottomCrop = clampInt(Number(options.bottomCrop ?? Math.floor(size.height * 0.18)), 0, size.height - topCrop - 1);
+    const swipeFromY = Number(options.swipeFromY || 0.78);
+    const swipeToY = Number(options.swipeToY || 0.28);
+    const swipeDurationMs = Number(options.swipeDurationMs || 650);
+    const settleMs = Number(options.settleMs || 900);
+    const scrollToTopFirst = Boolean(options.scrollToTopFirst);
+    const scrollToTopSwipes = Math.max(0, Math.min(8, Number(options.scrollToTopSwipes || 4)));
+    const pngs = [];
+
+    Logger.info('long screenshot start', {
+        serial: ctx.serial,
+        captureCount,
+        topCrop,
+        bottomCrop,
+        width: size.width,
+        height: size.height
+    });
+
+    if (scrollToTopFirst) {
+        for (let i = 0; i < scrollToTopSwipes; i += 1) {
+            await swipeScreenRatio(ctx, 0.50, swipeToY, 0.50, swipeFromY, swipeDurationMs).catch(() => { });
+            await sleep(Math.max(350, Math.floor(settleMs * 0.6)));
+        }
+    }
+
+    for (let i = 0; i < captureCount; i += 1) {
+        const png = await screenshotPng(ctx);
+        pngs.push(png);
+        if (i < captureCount - 1) {
+            await swipeScreenRatio(ctx, 0.50, swipeFromY, 0.50, swipeToY, swipeDurationMs).catch(() => { });
+            await sleep(settleMs);
+        }
+    }
+
+    const stitched = stitchVerticalPngs(pngs, {
+        topCrop,
+        bottomCrop,
+        maxOutputHeight: Math.max(size.height, Number(options.maxOutputHeight || size.height * captureCount)),
+        dedupeAdjacent: options.dedupeAdjacent !== false
+    });
+    Logger.info('long screenshot done', {
+        serial: ctx.serial,
+        duration: Logger.duration(startedAt),
+        bytes: stitched.length,
+        captureCount: pngs.length
+    });
+    return stitched.toString('base64');
+}
+
 export async function saveDebugScreenshot(ctx, name) {
     // 保存调试截图到 /tmp，主要用于本地定位点击点和页面状态。
     if (!ctx.serial) return '';
     const safeRunId = safeFilePart(ctx.runId || 'manual');
     const safeName = safeFilePart(name || 'screenshot');
     const out = `/tmp/android-toolkit-${safeRunId}-${safeName}.png`;
-    const stdout = await adbExec(ctx, ['-s', ctx.serial, 'exec-out', 'screencap', '-p'], {
-        timeoutMs: 15000,
-        encoding: 'buffer',
-        maxBuffer: 8 * 1024 * 1024
-    });
+    const stdout = await screenshotPng(ctx);
     fs.writeFileSync(out, stdout);
     Logger.info(`debug screenshot saved ${out}`);
     return out;
@@ -282,6 +349,308 @@ async function adbInput(ctx, args, options = {}) {
     await adbShell(ctx, ['input', ...args], options);
 }
 
+export async function screenshotPng(ctx) {
+    return adbExec(ctx, ['-s', ctx.serial, 'exec-out', 'screencap', '-p'], {
+        timeoutMs: 15000,
+        encoding: 'buffer',
+        maxBuffer: 24 * 1024 * 1024
+    });
+}
+
+function stitchVerticalPngs(buffers, options = {}) {
+    const frames = buffers.map((buffer) => decodePng(buffer));
+    if (frames.length === 0) throw new Error('longScreenshotBase64 requires at least one screenshot');
+    const width = frames[0].width;
+    const colorType = frames[0].colorType;
+    const bitDepth = frames[0].bitDepth;
+    const bytesPerPixel = pngBytesPerPixel(colorType, bitDepth);
+    if (bytesPerPixel !== 4) {
+        throw new Error(`longScreenshotBase64 only supports RGBA PNG screenshots, got colorType=${colorType} bitDepth=${bitDepth}`);
+    }
+    for (const frame of frames) {
+        if (frame.width !== width || frame.colorType !== colorType || frame.bitDepth !== bitDepth) {
+            throw new Error('longScreenshotBase64 screenshots have inconsistent PNG formats');
+        }
+    }
+
+    const uniqueFrames = [];
+    for (const frame of frames) {
+        const previous = uniqueFrames[uniqueFrames.length - 1];
+        if (previous && isNearDuplicateFrame(previous, frame, width, bytesPerPixel)) {
+            break;
+        }
+        uniqueFrames.push(frame);
+    }
+
+    const parts = [];
+    let totalHeight = 0;
+    const topCrop = Math.max(0, Number(options.topCrop || 0));
+    const bottomCrop = Math.max(0, Number(options.bottomCrop || 0));
+    const maxOutputHeight = Math.max(1, Number(options.maxOutputHeight || Number.MAX_SAFE_INTEGER));
+    for (let i = 0; i < uniqueFrames.length; i += 1) {
+        const frame = uniqueFrames[i];
+        const cropTop = i === 0 ? 0 : Math.min(topCrop, frame.height - 1);
+        const cropBottom = i === uniqueFrames.length - 1 ? 0 : Math.min(bottomCrop, frame.height - cropTop - 1);
+        let slice = cropFrame(frame, cropTop, cropBottom, bytesPerPixel);
+        if (options.dedupeAdjacent !== false && parts.length > 0) {
+            slice = removeDuplicateOverlap(parts[parts.length - 1], slice, width, bytesPerPixel);
+        }
+        if (slice.height <= 0) continue;
+        if (totalHeight + slice.height > maxOutputHeight) {
+            slice = cropSliceHeight(slice, maxOutputHeight - totalHeight, width, bytesPerPixel);
+        }
+        if (slice.height <= 0) break;
+        parts.push(slice);
+        totalHeight += slice.height;
+        if (totalHeight >= maxOutputHeight) break;
+    }
+
+    const rgba = Buffer.alloc(width * totalHeight * bytesPerPixel);
+    let y = 0;
+    for (const part of parts) {
+        part.rgba.copy(rgba, y * width * bytesPerPixel);
+        y += part.height;
+    }
+    return encodePng({width, height: totalHeight, rgba});
+}
+
+function isNearDuplicateFrame(previous, current, width, bytesPerPixel) {
+    if (previous.height !== current.height || previous.width !== current.width) return false;
+    const rowBytes = width * bytesPerPixel;
+    const top = Math.floor(current.height * 0.18);
+    const bottom = Math.floor(current.height * 0.82);
+    const start = top * rowBytes;
+    const end = Math.max(start, bottom * rowBytes);
+    const previousSlice = previous.rgba.subarray(start, end);
+    const currentSlice = current.rgba.subarray(start, end);
+    return meanAbsoluteRowDifference(previousSlice, currentSlice) < 1.5;
+}
+
+function cropFrame(frame, cropTop, cropBottom, bytesPerPixel) {
+    const widthBytes = frame.width * bytesPerPixel;
+    const height = Math.max(0, frame.height - cropTop - cropBottom);
+    const start = cropTop * widthBytes;
+    const end = start + height * widthBytes;
+    return {
+        width: frame.width,
+        height,
+        rgba: Buffer.from(frame.rgba.subarray(start, end))
+    };
+}
+
+function cropSliceHeight(slice, height, width, bytesPerPixel) {
+    const cleanHeight = Math.max(0, Math.min(slice.height, Number(height || 0)));
+    return {
+        width: slice.width,
+        height: cleanHeight,
+        rgba: Buffer.from(slice.rgba.subarray(0, cleanHeight * width * bytesPerPixel))
+    };
+}
+
+function removeDuplicateOverlap(previous, current, width, bytesPerPixel) {
+    if (!previous?.rgba?.length || !current?.rgba?.length) return current;
+    const rowBytes = width * bytesPerPixel;
+    const maxOverlap = Math.min(previous.height, current.height, Math.floor(current.height * 0.82));
+    let overlapRows = 0;
+    for (let rows = maxOverlap; rows >= 48; rows -= 8) {
+        if (sampledOverlapDifference(previous, current, rows, width, bytesPerPixel) < 5.0) {
+            overlapRows = rows;
+            break;
+        }
+    }
+    if (overlapRows <= 0) return current;
+    return {
+        width: current.width,
+        height: current.height - overlapRows,
+        rgba: Buffer.from(current.rgba.subarray(overlapRows * rowBytes))
+    };
+}
+
+function sampledOverlapDifference(previous, current, rows, width, bytesPerPixel) {
+    const rowBytes = width * bytesPerPixel;
+    const sampleRows = Math.min(28, rows);
+    const rowStep = Math.max(1, Math.floor(rows / sampleRows));
+    const xStart = Math.floor(width * 0.06);
+    const xEnd = Math.max(xStart + 1, Math.floor(width * 0.94));
+    const xStep = Math.max(1, Math.floor((xEnd - xStart) / 180));
+    let diff = 0;
+    let count = 0;
+    for (let y = 0; y < rows; y += rowStep) {
+        const previousRow = previous.height - rows + y;
+        const currentRow = y;
+        const previousBase = previousRow * rowBytes;
+        const currentBase = currentRow * rowBytes;
+        for (let x = xStart; x < xEnd; x += xStep) {
+            const offset = x * bytesPerPixel;
+            diff += Math.abs(previous.rgba[previousBase + offset] - current.rgba[currentBase + offset]);
+            diff += Math.abs(previous.rgba[previousBase + offset + 1] - current.rgba[currentBase + offset + 1]);
+            diff += Math.abs(previous.rgba[previousBase + offset + 2] - current.rgba[currentBase + offset + 2]);
+            count += 3;
+        }
+    }
+    return diff / Math.max(1, count);
+}
+
+function meanAbsoluteRowDifference(left, right) {
+    const len = Math.min(left.length, right.length);
+    if (len <= 0) return Number.POSITIVE_INFINITY;
+    let diff = 0;
+    const stride = Math.max(1, Math.floor(len / 20000));
+    let count = 0;
+    for (let i = 0; i < len; i += stride) {
+        diff += Math.abs(left[i] - right[i]);
+        count += 1;
+    }
+    return diff / Math.max(1, count);
+}
+
+function decodePng(buffer) {
+    const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    if (!Buffer.from(buffer).subarray(0, 8).equals(signature)) throw new Error('invalid PNG signature');
+    let offset = 8;
+    let width = 0;
+    let height = 0;
+    let bitDepth = 0;
+    let colorType = 0;
+    const idat = [];
+
+    while (offset + 12 <= buffer.length) {
+        const length = buffer.readUInt32BE(offset);
+        const type = buffer.subarray(offset + 4, offset + 8).toString('ascii');
+        const data = buffer.subarray(offset + 8, offset + 8 + length);
+        offset += 12 + length;
+        if (type === 'IHDR') {
+            width = data.readUInt32BE(0);
+            height = data.readUInt32BE(4);
+            bitDepth = data[8];
+            colorType = data[9];
+        } else if (type === 'IDAT') {
+            idat.push(data);
+        } else if (type === 'IEND') {
+            break;
+        }
+    }
+    if (!width || !height) throw new Error('invalid PNG IHDR');
+    const bytesPerPixel = pngBytesPerPixel(colorType, bitDepth);
+    const rowBytes = width * bytesPerPixel;
+    const inflated = zlib.inflateSync(Buffer.concat(idat));
+    const rgba = Buffer.alloc(rowBytes * height);
+    let src = 0;
+    let dst = 0;
+    let previous = Buffer.alloc(rowBytes);
+    for (let y = 0; y < height; y += 1) {
+        const filter = inflated[src++];
+        const row = Buffer.from(inflated.subarray(src, src + rowBytes));
+        src += rowBytes;
+        unfilterPngRow(row, previous, filter, bytesPerPixel);
+        row.copy(rgba, dst);
+        dst += rowBytes;
+        previous = row;
+    }
+    return {width, height, bitDepth, colorType, rgba};
+}
+
+function encodePng({width, height, rgba}) {
+    const rowBytes = width * 4;
+    const raw = Buffer.alloc((rowBytes + 1) * height);
+    for (let y = 0; y < height; y += 1) {
+        const rawOffset = y * (rowBytes + 1);
+        raw[rawOffset] = 0;
+        rgba.copy(raw, rawOffset + 1, y * rowBytes, (y + 1) * rowBytes);
+    }
+    const chunks = [
+        makePngChunk('IHDR', makeIhdr(width, height)),
+        makePngChunk('IDAT', zlib.deflateSync(raw, {level: 6})),
+        makePngChunk('IEND', Buffer.alloc(0))
+    ];
+    return Buffer.concat([
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        ...chunks
+    ]);
+}
+
+function makeIhdr(width, height) {
+    const data = Buffer.alloc(13);
+    data.writeUInt32BE(width, 0);
+    data.writeUInt32BE(height, 4);
+    data[8] = 8;
+    data[9] = 6;
+    data[10] = 0;
+    data[11] = 0;
+    data[12] = 0;
+    return data;
+}
+
+function makePngChunk(type, data) {
+    const typeBuffer = Buffer.from(type, 'ascii');
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const crcBuffer = Buffer.alloc(4);
+    crcBuffer.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+    return Buffer.concat([length, typeBuffer, data, crcBuffer]);
+}
+
+function unfilterPngRow(row, previous, filter, bytesPerPixel) {
+    if (filter === 0) return;
+    for (let i = 0; i < row.length; i += 1) {
+        const left = i >= bytesPerPixel ? row[i - bytesPerPixel] : 0;
+        const up = previous[i] || 0;
+        const upLeft = i >= bytesPerPixel ? previous[i - bytesPerPixel] || 0 : 0;
+        let value = row[i];
+        if (filter === 1) value += left;
+        else if (filter === 2) value += up;
+        else if (filter === 3) value += Math.floor((left + up) / 2);
+        else if (filter === 4) value += paethPredictor(left, up, upLeft);
+        else throw new Error(`unsupported PNG filter ${filter}`);
+        row[i] = value & 0xff;
+    }
+}
+
+function pngBytesPerPixel(colorType, bitDepth) {
+    if (bitDepth !== 8) throw new Error(`unsupported PNG bitDepth ${bitDepth}`);
+    if (colorType === 6) return 4;
+    if (colorType === 2) return 3;
+    if (colorType === 0) return 1;
+    throw new Error(`unsupported PNG colorType ${colorType}`);
+}
+
+function paethPredictor(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    if (pa <= pb && pa <= pc) return a;
+    if (pb <= pc) return b;
+    return c;
+}
+
+const CRC_TABLE = makeCrcTable();
+
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+
+function makeCrcTable() {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1) {
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+}
+
+function clampInt(value, min, max) {
+    const clean = Number.isFinite(value) ? Math.trunc(value) : min;
+    return Math.max(min, Math.min(max, clean));
+}
+
 function isAdbOfflineError(error) {
     const message = String(error?.message || error || '').toLowerCase();
     return message.includes('device offline') || message.includes('device unauthorized');
@@ -368,6 +737,10 @@ export const Device = {
     startLauncher,
     waitForForeground,
     screenSize,
+    screenDensity,
+    overrideScreenSize,
+    resetScreenSize,
+    resetScreenDensity,
     tapAbsolute,
     click,
     move,
@@ -377,7 +750,9 @@ export const Device = {
     focusedActivity,
     activityIncludes,
     waitForActivity,
+    screenshotPng,
     screenshotBase64,
+    longScreenshotBase64,
     saveDebugScreenshot,
     clearInputByDelete,
     typeText,

package/src/frida-client.js

@@ -93,7 +93,12 @@ export async function runScript(ctx, source, options = {}) {
         maxLines: Number(options.maxLines || 1200),
         outputPath: options.outputPath || ''
     });
-    await recorder.waitForExit(Number(options.timeoutMs || 10000));
+    let waitError = null;
+    try {
+        await recorder.waitForEvent((event) => event?.type !== 'parse_error', Number(options.timeoutMs || 10000));
+    } catch (error) {
+        waitError = error;
+    }
     const result = await recorder.stop();
     const scriptEvents = result.events.filter((event) => event?.type !== 'parse_error');
     if (scriptEvents.length === 0) {
@@ -102,6 +107,7 @@ export async function runScript(ctx, source, options = {}) {
             duration: Logger.duration(startedAt),
             lineCount: result.lines.length
         });
+        if (waitError) throw waitError;
         throw new CrawlerError({
             message: `frida_script_failed: ${label} did not emit ${marker.trim()}`,
             code: Code.FridaUnavailable,

package/src/internals/compression.js

@@ -0,0 +1,188 @@
+import {Jimp, JimpMime, ResizeStrategy} from 'jimp';
+
+import {Logger} from '../logger.js';
+
+const DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
+const DEFAULT_SCREENSHOT_OUTPUT_TYPE = 'jpeg';
+const DEFAULT_SCREENSHOT_QUALITY = 0.72;
+const DEFAULT_SCREENSHOT_MIN_QUALITY = 0.38;
+const DEFAULT_SCREENSHOT_MIN_SCALE = 0.25;
+const SUPPORTED_SCREENSHOT_OUTPUT_TYPES = new Set(['jpeg']);
+
+const toPositiveInteger = (value, fallback = 0) => {
+    const number = Math.floor(Number(value) || 0);
+    return number > 0 ? number : fallback;
+};
+
+const normalizeQuality = (value, fallback) => {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= 0) return fallback;
+    const normalized = number > 1 ? number / 100 : number;
+    return Math.min(1, Math.max(0.01, normalized));
+};
+
+const normalizeScale = (value, fallback) => {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= 0) return fallback;
+    return Math.min(1, Math.max(0.05, number));
+};
+
+const normalizeScreenshotOutputType = (value) => {
+    const raw = String(value || DEFAULT_SCREENSHOT_OUTPUT_TYPE).trim().toLowerCase();
+    const normalized = raw === 'jpg' ? 'jpeg' : raw;
+    return SUPPORTED_SCREENSHOT_OUTPUT_TYPES.has(normalized)
+        ? normalized
+        : DEFAULT_SCREENSHOT_OUTPUT_TYPE;
+};
+
+const getBase64BytesFromBuffer = (buffer) => Math.ceil(buffer.length / 3) * 4;
+
+const toJpegQuality = (value) => Math.round(normalizeQuality(value, DEFAULT_SCREENSHOT_QUALITY) * 100);
+
+export const resolveImageCompression = (options = {}) => {
+    const explicit = options.compression;
+    const source = explicit && typeof explicit === 'object' && !Array.isArray(explicit)
+        ? explicit
+        : {};
+
+    const enabled = explicit !== false
+        && source.enabled !== false
+        && options.compress !== false;
+
+    const quality = normalizeQuality(
+        source.quality ?? options.quality,
+        DEFAULT_SCREENSHOT_QUALITY
+    );
+    const minQuality = Math.min(
+        quality,
+        normalizeQuality(source.minQuality ?? options.minQuality, DEFAULT_SCREENSHOT_MIN_QUALITY)
+    );
+
+    return {
+        enabled,
+        maxBytes: toPositiveInteger(
+            source.maxBytes
+                ?? source.maxBase64Bytes
+                ?? options.maxBytes
+                ?? options.maxBase64Bytes,
+            DEFAULT_SCREENSHOT_MAX_BYTES
+        ),
+        outputType: normalizeScreenshotOutputType(
+            source.type
+                ?? source.outputType
+                ?? options.type
+                ?? options.outputType
+        ),
+        quality,
+        minQuality,
+        minScale: normalizeScale(
+            source.minScale ?? options.minScale,
+            DEFAULT_SCREENSHOT_MIN_SCALE
+        ),
+    };
+};
+
+const encodeJpeg = async (sourceImage, compression, scale, quality) => {
+    const width = Math.max(1, Math.round(sourceImage.bitmap.width * scale));
+    const height = Math.max(1, Math.round(sourceImage.bitmap.height * scale));
+    const image = sourceImage.clone();
+
+    if (scale < 0.999) {
+        image.resize({
+            w: width,
+            h: height,
+            mode: ResizeStrategy.BILINEAR,
+        });
+    }
+
+    const buffer = await image.getBuffer(JimpMime.jpeg, {quality});
+    return {
+        buffer,
+        bytes: getBase64BytesFromBuffer(buffer),
+        width,
+        height,
+        quality,
+        scale: Number(scale.toFixed(3)),
+        format: compression.outputType,
+    };
+};
+
+const compressImageBuffer = async (buffer, compression) => {
+    const sourceImage = await Jimp.read(buffer);
+    const maxQuality = toJpegQuality(compression.quality);
+    const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
+    let quality = maxQuality;
+    let scale = 1;
+    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 (quality > minQuality) {
+            quality = Math.max(minQuality, Math.floor(quality * 0.75));
+            continue;
+        }
+
+        const ratio = Math.sqrt(compression.maxBytes / Math.max(1, candidate.bytes));
+        const nextScale = Math.max(
+            compression.minScale,
+            Math.min(scale * 0.85, scale * ratio * 0.94)
+        );
+
+        if (nextScale >= scale * 0.99 || scale <= compression.minScale) {
+            break;
+        }
+
+        scale = nextScale;
+    }
+
+    const finalCandidate = await encodeJpeg(sourceImage, compression, compression.minScale, minQuality);
+    const fallback = !smallest || finalCandidate.bytes < smallest.bytes
+        ? finalCandidate
+        : smallest;
+    return {...fallback, withinLimit: fallback.bytes <= compression.maxBytes};
+};
+
+export const compressImageBufferToBase64 = async (buffer, compression) => {
+    const originalBytes = getBase64BytesFromBuffer(buffer);
+    if (!compression.enabled || originalBytes <= compression.maxBytes) {
+        return buffer.toString('base64');
+    }
+
+    const result = await compressImageBuffer(buffer, compression).catch((error) => {
+        Logger.warn('captureScreen 压缩失败，返回原图', {message: error?.message || String(error)});
+        return null;
+    });
+
+    if (!result?.buffer) {
+        return buffer.toString('base64');
+    }
+
+    if (result.withinLimit) {
+        Logger.info('captureScreen 已压缩', {
+            originalBytes,
+            outputBytes: result.bytes,
+            format: result.format,
+            quality: result.quality,
+            scale: result.scale,
+            size: `${result.width}x${result.height}`,
+        });
+    } else {
+        Logger.warn('captureScreen 压缩后仍超过目标', {
+            originalBytes,
+            outputBytes: result.bytes,
+            maxBytes: compression.maxBytes,
+            format: result.format,
+            quality: result.quality,
+            scale: result.scale,
+        });
+    }
+
+    return result.buffer.toString('base64');
+};

package/src/launch.js

@@ -5,6 +5,7 @@ import {createAndroidContext} from './context.js';
 import {Device} from './device.js';
 import {Frida} from './frida-client.js';
 import {Logger} from './logger.js';
+import {Share} from './share.js';
 
 const DEFAULT_INPUT_PATH = '/apify_storage/input.json';
 const DEFAULT_OUTPUT_PATH = '/apify_storage/output.json';
@@ -38,6 +39,7 @@ export const Launch = {
             ApifyKit: apifyKit,
             Device,
             Frida,
+            Share,
             Logger
         };