@kaeawc/auto-mobile 0.0.87 → 0.0.89

package/node_modules/strtok3/lib/TokenizerView.js

@@ -0,0 +1,184 @@
+import { isRandomAccessTokenizer } from './isRandomAccessTokenizer.js';
+import { EndOfStreamError } from './stream/index.js';
+import { TokenizerBoundaryError } from './TokenizerBoundaryError.js';
+function validateOffset(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+export function createTokenizerView(source, length) {
+    return isRandomAccessTokenizer(source)
+        ? new RandomAccessTokenizerView(source, length)
+        : new TokenizerView(source, length);
+}
+class TokenizerView {
+    constructor(source, size) {
+        this.source = source;
+        this.size = size;
+        this.closed = false;
+        this.closedPosition = 0;
+        this.busy = false;
+        validateOffset(size, 'length');
+        validateOffset(source.position, 'source position');
+        validateOffset(source.position + size, 'end position');
+        if (source instanceof TokenizerView) {
+            source.assertAvailable();
+            source.translateRange(size, source.position);
+        }
+        this.start = source.position;
+        // A chunk has its own size; the outer file's MIME type/path need not describe it.
+        this.fileInfo = { size };
+    }
+    get position() {
+        return this.closed ? this.closedPosition : this.source.position - this.start;
+    }
+    get remaining() {
+        return this.size - this.position;
+    }
+    supportsRandomAccess() {
+        return false;
+    }
+    createView(length) {
+        this.assertAvailable();
+        return createTokenizerView(this, length);
+    }
+    async readBuffer(buffer, options) {
+        return this.bufferOperation('readBuffer', buffer, options);
+    }
+    async peekBuffer(buffer, options) {
+        return this.bufferOperation('peekBuffer', buffer, options);
+    }
+    async bufferOperation(method, buffer, options) {
+        this.assertAvailable();
+        const length = options?.length ?? buffer.length;
+        const position = options?.position ?? this.position;
+        const absolutePosition = this.translateRange(length, position);
+        if (length > buffer.length) {
+            throw new RangeError('length must not exceed the target buffer length');
+        }
+        return this.run(() => this.source[method](buffer, { ...options, length, position: absolutePosition }));
+    }
+    async readToken(token, position = this.position) {
+        this.assertAvailable();
+        const absolutePosition = this.translateRange(token.len, position);
+        return this.run(() => this.source.readToken(token, absolutePosition));
+    }
+    async peekToken(token, position = this.position) {
+        this.assertAvailable();
+        const absolutePosition = this.translateRange(token.len, position ?? this.position);
+        return this.run(() => this.source.peekToken(token, absolutePosition));
+    }
+    async readNumber(token) {
+        this.assertAvailable();
+        this.translateRange(token.len, this.position);
+        return this.run(() => this.source.readNumber(token));
+    }
+    async peekNumber(token) {
+        this.assertAvailable();
+        this.translateRange(token.len, this.position);
+        return this.run(() => this.source.peekNumber(token));
+    }
+    async ignore(length) {
+        this.assertAvailable();
+        this.translateRange(length, this.position);
+        return this.run(() => this.source.ignore(length));
+    }
+    async consumeRemainder() {
+        this.assertAvailable();
+        const length = this.remaining;
+        const end = this.translateRange(length, this.position) + length;
+        return this.run(async () => {
+            if (length === 0) {
+                return 0;
+            }
+            if (isRandomAccessTokenizer(this.source)) {
+                // Unlike ignore()/setPosition(), this verifies that the final byte exists,
+                // including a file that was truncated after its initial stat. No large read.
+                if ((await this.source.peekBuffer(new Uint8Array(1), { position: end - 1 })) !== 1) {
+                    throw new EndOfStreamError();
+                }
+                this.source.setPosition(end);
+            }
+            else {
+                const ignored = await this.source.ignore(length);
+                if (ignored !== length) {
+                    throw new EndOfStreamError();
+                }
+            }
+            return length;
+        });
+    }
+    /** Release this view only. Never drain, close or abort the borrowed source. */
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        if (this.busy) {
+            throw new Error('Cannot close a tokenizer view during an active operation');
+        }
+        this.closedPosition = this.position;
+        this.closed = true;
+    }
+    /** Explicit cancellation propagates to the shared source and affects its other users. */
+    async abort() {
+        if (this.closed) {
+            return;
+        }
+        try {
+            await this.source.abort();
+        }
+        finally {
+            this.closedPosition = this.position;
+            this.closed = true;
+        }
+    }
+    assertAvailable() {
+        if (this.closed) {
+            throw new Error('Tokenizer view is closed');
+        }
+        if (this.busy) {
+            throw new Error('Tokenizer views require sequential operations');
+        }
+        if (this.source instanceof TokenizerView) {
+            this.source.assertAvailable();
+        }
+    }
+    /** Validate the whole request before delegating or allowing a token allocation. */
+    translateRange(length, position) {
+        validateOffset(length, 'length');
+        validateOffset(position, 'position');
+        validateOffset(position + length, 'end position');
+        if (position > this.size || length > this.size - position) {
+            throw new TokenizerBoundaryError(position, length, this.size);
+        }
+        if (!this.supportsRandomAccess() && position < this.position) {
+            throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
+        }
+        return this.start + position;
+    }
+    async run(operation) {
+        this.busy = true;
+        try {
+            return await operation();
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+}
+class RandomAccessTokenizerView extends TokenizerView {
+    constructor(source, size) {
+        super(source, size);
+    }
+    supportsRandomAccess() {
+        return true;
+    }
+    setPosition(position) {
+        this.assertAvailable();
+        this.source.setPosition(this.translateRange(0, position));
+    }
+    createView(length) {
+        this.assertAvailable();
+        return createTokenizerView(this, length);
+    }
+}

package/node_modules/strtok3/lib/core.js

@@ -6,7 +6,10 @@ import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
 import { makeWebStreamReader, StreamReader } from './stream/index.js';
 export { AbstractTokenizer } from './AbstractTokenizer.js';
 export { BufferSizeError } from './BufferSizeError.js';
+export { isRandomAccessTokenizer } from './isRandomAccessTokenizer.js';
 export { AbortError, EndOfStreamError } from './stream/index.js';
+export { TokenizerBoundaryError } from './TokenizerBoundaryError.js';
+export { createTokenizerView } from './TokenizerView.js';
 /**
  * Construct ReadStreamTokenizer from given Stream.
  * Will set fileSize, if provided given Stream has set the .path property/
@@ -18,15 +21,7 @@ export function fromStream(stream, options) {
     getMaxBufferSize(options);
     throwIfAborted(options?.abortSignal);
     const streamReader = new StreamReader(stream);
-    const _options = options ?? {};
-    const chainedClose = _options.onClose;
-    _options.onClose = async () => {
-        await streamReader.close();
-        if (chainedClose) {
-            return chainedClose();
-        }
-    };
-    return new ReadStreamTokenizer(streamReader, _options);
+    return new ReadStreamTokenizer(streamReader, options);
 }
 /**
  * Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
@@ -39,15 +34,7 @@ export function fromWebStream(webStream, options) {
     getMaxBufferSize(options);
     throwIfAborted(options?.abortSignal);
     const webStreamReader = makeWebStreamReader(webStream);
-    const _options = options ?? {};
-    const chainedClose = _options.onClose;
-    _options.onClose = async () => {
-        await webStreamReader.close();
-        if (chainedClose) {
-            return chainedClose();
-        }
-    };
-    return new ReadStreamTokenizer(webStreamReader, _options);
+    return new ReadStreamTokenizer(webStreamReader, options);
 }
 /**
  * Construct ReadStreamTokenizer from given Buffer.

package/node_modules/strtok3/lib/index.js

@@ -3,6 +3,23 @@ import { fromStream as coreFromStream } from './core.js';
 import { FileTokenizer } from './FileTokenizer.js';
 export * from './core.js';
 export { FileTokenizer } from './FileTokenizer.js';
+export { NotRegularFileError } from './NotRegularFileError.js';
+async function waitForPendingOpen(stream) {
+    if (stream.pending !== true || stream.destroyed || stream.errored !== null) {
+        return;
+    }
+    await new Promise(resolve => {
+        const settle = () => {
+            stream.removeListener('open', settle);
+            stream.removeListener('error', settle);
+            stream.removeListener('close', settle);
+            resolve();
+        };
+        stream.once('open', settle);
+        stream.once('error', settle);
+        stream.once('close', settle);
+    });
+}
 /**
  * Construct ReadStreamTokenizer from given Stream.
  * Will set fileSize, if provided given Stream has set the .path property.
@@ -12,11 +29,18 @@ export { FileTokenizer } from './FileTokenizer.js';
  */
 export async function fromStream(stream, options) {
     const rst = coreFromStream(stream, options);
-    if (stream.path) {
-        const stat = await fsStat(stream.path);
-        rst.fileInfo.path = stream.path;
-        rst.fileInfo.size = stat.size;
+    try {
+        if (stream.path) {
+            const stat = await fsStat(stream.path);
+            rst.fileInfo.path = stream.path;
+            rst.fileInfo.size = stat.size;
+        }
+        return rst;
+    }
+    catch (error) {
+        await waitForPendingOpen(stream);
+        await rst.close();
+        throw error;
     }
-    return rst;
 }
 export const fromFile = FileTokenizer.fromFile;

package/node_modules/strtok3/lib/isRandomAccessTokenizer.js

@@ -0,0 +1,10 @@
+/**
+ * Check for random-access capability, position control and a known file size.
+ * A known size alone does not imply random access.
+ */
+export function isRandomAccessTokenizer(tokenizer) {
+    return (tokenizer.supportsRandomAccess() &&
+        'setPosition' in tokenizer &&
+        typeof tokenizer.setPosition === 'function' &&
+        typeof tokenizer.fileInfo.size === 'number');
+}

package/node_modules/strtok3/lib/stream/StreamReader.js

@@ -1,6 +1,12 @@
 import { AbstractStreamReader } from './AbstractStreamReader.js';
 import { Deferred } from './Deferred.js';
 import { AbortError } from './Errors.js';
+function handlePostEndError() {
+    this.removeListener('close', removePostEndErrorHandler);
+}
+function removePostEndErrorHandler() {
+    this.removeListener('error', handlePostEndError);
+}
 /**
  * Node.js Readable Stream Reader
  * Ref: https://nodejs.org/api/stream.html#readable-streams
@@ -13,23 +19,32 @@ export class StreamReader extends AbstractStreamReader {
          * Pending requests waiting for data, tracked until completion or cancellation
          */
         this.pendingRequests = new Set();
-        if (!s.read || !s.once) {
-            throw new Error('Expected an instance of stream.Readable');
-        }
-        this.s.once('end', () => {
+        this.onEnd = () => {
             this.endOfStream = true;
+            this.removeLifecycleListeners();
+            // Auto-destruction may emit an error after `end`. These shared handlers do
+            // not retain this reader when `emitClose` is disabled.
+            this.s.once('error', handlePostEndError);
+            this.s.once('close', removePostEndErrorHandler);
             for (const request of this.pendingRequests) {
                 this.removeRequest(request);
                 request.deferred.resolve(0);
             }
-        });
-        this.s.once('error', err => this.reject(err));
-        this.s.once('close', () => {
+        };
+        this.onError = (err) => this.reject(err);
+        this.onClose = () => {
+            this.removeLifecycleListeners();
             // Normal EOF may leave peeked bytes that the caller still needs to consume.
             if (!this.endOfStream) {
                 void this.abort();
             }
-        });
+        };
+        if (!s.read || !s.once) {
+            throw new Error('Expected an instance of stream.Readable');
+        }
+        this.s.once('end', this.onEnd);
+        this.s.once('error', this.onError);
+        this.s.once('close', this.onClose);
     }
     /**
      * Read chunk from stream
@@ -87,7 +102,13 @@ export class StreamReader extends AbstractStreamReader {
         this.s.removeListener('readable', request.onReadable);
         this.pendingRequests.delete(request);
     }
+    removeLifecycleListeners() {
+        this.s.removeListener('end', this.onEnd);
+        this.s.removeListener('error', this.onError);
+        this.s.removeListener('close', this.onClose);
+    }
     reject(err) {
+        this.removeLifecycleListeners();
         this.interrupted = true;
         this.peekQueue = [];
         for (const request of this.pendingRequests) {

package/node_modules/strtok3/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strtok3",
-  "version": "10.4.1",
+  "version": "10.6.3",
   "description": "A promise based streaming tokenizer",
   "author": {
     "name": "Borewit",
@@ -13,9 +13,11 @@
   "scripts": {
     "clean": "del-cli 'lib/**/*.js' 'lib/**/*.js.map' 'lib/**/*.d.ts' 'test/**/*.js' 'test/**/*.js.map'",
     "compile-src": "tsc -p lib  --sourceMap false",
+    "compile-src:dev": "tsc -p lib --sourceMap --inlineSources",
     "compile-test": "tsc -p test",
-    "compile": "yarn run compile-src && yarn run compile-test",
+    "compile": "yarn run compile-src && yarn run compile-test && yarn run test:types",
     "build": "yarn run clean && yarn run compile",
+    "build:dev": "yarn run clean && yarn run compile-test && yarn run compile-src:dev && yarn run test:types",
     "prepublishOnly": "yarn run build",
     "eslint": "eslint lib test",
     "lint:md": "remark -u preset-lint-recommended .",
@@ -23,9 +25,9 @@
     "lint": "yarn run lint:md && yarn run lint:ts",
     "fix": "yarn run lint:ts:fix",
     "test": "mocha",
+    "test:types": "tsc -p test/types && tsc -p test/types/tsconfig.browser.json",
     "bun:test": "bun run --bun test",
     "test-coverage": "c8 yarn run test",
-    "send-codacy": "c8 report --reporter=text-lcov | codacy-coverage",
     "start": "yarn run compile && yarn run lint && yarn run cover-test",
     "update-biome": "yarn add -D --exact @biomejs/biome && npx @biomejs/biome migrate --write",
     "lint:ts:fix": "biome check --write"
@@ -59,16 +61,16 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.15",
-    "@types/chai": "^5.2.2",
+    "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
-    "@types/debug": "^4.1.12",
+    "@types/debug": "^4.1.13",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.19.1",
+    "@types/node": "^26.6.5",
     "c8": "^12.0.0",
     "chai": "^6.3.0",
     "chai-as-promised": "^8.0.2",
-    "del-cli": "^7.0.0",
-    "mocha": "^11",
+    "del-cli": "^8.0.1",
+    "mocha": "^11.8.0",
     "node-readable-to-web-readable-stream": "^0.4.2",
     "remark-cli": "^12.0.1",
     "remark-preset-lint-recommended": "^7.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaeawc/auto-mobile",
-  "version": "0.0.87",
+  "version": "0.0.89",
   "description": "Mobile device interaction automation via MCP",
   "keywords": [
     "adb",
@@ -32,7 +32,8 @@
   "files": [
     "dist",
     "!dist/**/*.map",
-    "schemas"
+    "schemas",
+    "mcp-skills"
   ],
   "main": "dist/src/index.js",
   "publishConfig": {
@@ -53,17 +54,17 @@
     "test:memory-leaks": "bun --expose-gc scripts/detect-memory-leaks.ts",
     "test:integration:webrtc-mediamtx": "bash scripts/webrtc/run-mediamtx-publisher-integration.sh",
     "test:integration:webrtc-device": "bash scripts/webrtc/run-mediamtx-device-integration.sh",
+    "test:prototype-web-screenshots": "bash scripts/prototype/web-screenshots.sh",
     "gate:android-video-baseline": "bun scripts/webrtc/android-video-baseline-gate.ts",
     "lint": "bash scripts/lint.sh",
     "check:boundaries": "bash scripts/check-boundaries.sh",
     "lint:prune": "bash scripts/oxlint-baseline.sh --update",
     "lint:baseline": "bash scripts/oxlint-baseline.sh --update",
     "lint:file-size:baseline": "bash scripts/file-size-baseline.sh --update",
-    "test:as-any:baseline": "bash scripts/test-as-any-baseline.sh --update",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
     "typecheck": "bash scripts/typecheck-baseline.sh",
-    "typecheck:update": "bash scripts/typecheck-baseline.sh --update",
+    "typecheck:test": "bash scripts/typecheck-baseline.sh --project=test",
     "docs:assets": "bun scripts/docs/build-docs-assets.ts",
     "docs:assets:check": "bun scripts/docs/build-docs-assets.ts --check",
     "watch": "bun --watch src/index.ts",
@@ -78,6 +79,7 @@
     "benchmark-context": "bun scripts/benchmark-context-thresholds.ts",
     "benchmark-tools": "bun scripts/benchmark-mcp-tools.ts",
     "bench:settled-screenshot": "bun scripts/benchmark-settled-screenshot.ts",
+    "bench:agent": "bun run build 1>&2 && bun scripts/agent-benchmark/run.ts",
     "benchmark-startup": "bash scripts/benchmark-startup.sh",
     "benchmark-npm-unpacked-size": "bun scripts/benchmark-npm-unpacked-size.ts",
     "profile:memory": "bun --expose-gc --inspect scripts/detect-memory-leaks.ts --mode=profile",
@@ -125,7 +127,7 @@
     "loop": "bash scripts/validate-loop.sh"
   },
   "dependencies": {
-    "@borewit/text-codec": "0.2.2",
+    "@borewit/text-codec": "0.2.3",
     "@emnapi/runtime": "1.11.3",
     "@img/colour": "1.1.0",
     "@jimp/core": "1.6.1",
@@ -181,7 +183,7 @@
     "semver": "7.8.5",
     "sharp": "0.35.5",
     "simple-xml-to-json": "1.2.3",
-    "strtok3": "10.4.1",
+    "strtok3": "10.6.3",
     "tinycolor2": "1.6.0",
     "token-types": "6.1.2",
     "tslib": "2.8.1",
@@ -192,11 +194,12 @@
     "zod": "3.25.76"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.133.0",
+    "@anthropic-ai/sdk": "^1.1.0",
     "@faker-js/faker": "^10.2.0",
-    "@modelcontextprotocol/client": "^2.3.1",
+    "@modelcontextprotocol/client": "^2.4.0",
     "@modelcontextprotocol/node": "^2.1.1",
-    "@modelcontextprotocol/server": "^2.3.1",
+    "@modelcontextprotocol/server": "^2.4.0",
+    "@types/bun": "1.4.4",
     "@types/node": "^26.0.0",
     "@types/pngjs": "^6.0.5",
     "@types/ws": "^8.18.1",
@@ -210,17 +213,18 @@
     "js-tiktoken": "^1.0.21",
     "js-yaml": "^5.1.0",
     "knip": "^6.0.0",
-    "kysely": "0.29.6",
-    "oxc-parser": "0.153.0",
-    "oxfmt": "0.72.0",
-    "oxlint": "1.87.0",
-    "oxlint-tsgolint": "7.0.2004",
+    "kysely": "0.29.7",
+    "oxc-parser": "0.156.0",
+    "oxfmt": "0.75.0",
+    "oxlint": "1.90.0",
+    "oxlint-tsgolint": "7.0.2005",
     "pixelmatch": "^8.0.0",
+    "playwright-core": "1.63.0",
     "pngjs": "^7.0.0",
     "reflect-metadata": "^0.2.2",
     "turbo": "^2.8.10",
     "typescript": "6.0.3",
-    "werift": "^0.25.0",
+    "werift": "^0.26.0",
     "ws": "^8.19.0",
     "xml2js": "^0.6.2",
     "zod-to-json-schema": "^3.25.1"
@@ -269,9 +273,9 @@
     "tar": "^7.5.8"
   },
   "engines": {
-    "bun": ">=1.3.14"
+    "bun": ">=1.4.4"
   },
-  "packageManager": "bun@1.3.14",
+  "packageManager": "bun@1.4.4",
   "//overrides": {
     "lodash": "CVE-2025-13465: prototype pollution in _.unset and _.omit",
     "tar": "CVE-2026-26960 (GHSA-83g3-92jg-28cx): Arbitrary file read/write via hardlink target escape through symlink chain",