@taqwright/taqwright 0.0.24

package/dist/network/android.d.ts

@@ -0,0 +1,5 @@
+export type AndroidDeviceType = 'userdebug-emulator' | 'play-emulator' | 'real-device' | 'unknown';
+export declare function detectAndroidDeviceType(udid: string): Promise<AndroidDeviceType>;
+export declare function installSystemCa(udid: string, certPemPath: string, hashName: string): Promise<boolean>;
+export declare function setHttpProxy(udid: string, host: string, port: number): Promise<void>;
+export declare function clearHttpProxy(udid: string): Promise<void>;

package/dist/network/android.js

@@ -0,0 +1,87 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execP = promisify(exec);
+export async function detectAndroidDeviceType(udid) {
+    const qemu = (await getProp(udid, 'ro.boot.qemu')) || (await getProp(udid, 'ro.kernel.qemu'));
+    const tags = await getProp(udid, 'ro.build.tags');
+    if (qemu !== '1') {
+        const chars = await getProp(udid, 'ro.build.characteristics');
+        if (!/emulator/i.test(chars))
+            return 'real-device';
+    }
+    if (tags === 'release-keys')
+        return 'play-emulator';
+    if (tags === 'dev-keys' || tags === 'test-keys')
+        return 'userdebug-emulator';
+    return 'unknown';
+}
+export async function installSystemCa(udid, certPemPath, hashName) {
+    try {
+        await adb(udid, 'root');
+        await sleep(500);
+        await waitForDevice(udid);
+        let remountOut = '';
+        try {
+            remountOut = (await adb(udid, 'remount')).stdout + (await adb(udid, 'remount')).stderr;
+        }
+        catch (e) {
+            remountOut = String(e.stderr ?? e);
+        }
+        if (/verity/i.test(remountOut)) {
+            await adb(udid, 'disable-verity').catch(() => undefined);
+            await adb(udid, 'reboot').catch(() => undefined);
+            await waitForDevice(udid, 60_000);
+            await adb(udid, 'root').catch(() => undefined);
+            await sleep(500);
+            await waitForDevice(udid);
+            await adb(udid, 'remount');
+        }
+        const dest = `/system/etc/security/cacerts/${hashName}.0`;
+        await adb(udid, 'push', certPemPath, dest);
+        await adb(udid, 'shell', `chmod 644 ${dest}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function setHttpProxy(udid, host, port) {
+    await adb(udid, 'shell', `settings put global http_proxy ${host}:${port}`);
+}
+export async function clearHttpProxy(udid) {
+    await adb(udid, 'shell', 'settings put global http_proxy :0');
+}
+async function getProp(udid, name) {
+    try {
+        const { stdout } = await adb(udid, 'shell', `getprop ${name}`);
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+}
+async function waitForDevice(udid, timeoutMs = 20_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const { stdout } = await execP(`adb -s ${shellQuote(udid)} get-state`, { timeout: 5_000 });
+            if (stdout.trim() === 'device')
+                return;
+        }
+        catch {
+        }
+        await sleep(500);
+    }
+}
+async function adb(udid, ...args) {
+    const cmd = ['adb', '-s', shellQuote(udid), ...args.map(shellQuote)].join(' ');
+    return execP(cmd, { maxBuffer: 16 * 1024 * 1024 });
+}
+function shellQuote(s) {
+    if (/^[A-Za-z0-9_\-./=:,@%+]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/network/ca.d.ts

@@ -0,0 +1,10 @@
+export interface CaBundle {
+    certPem: string;
+    certPemPath: string;
+    androidHashName: string;
+    signLeaf(host: string): {
+        keyPem: string;
+        certPem: string;
+    };
+}
+export declare function ensureCa(): Promise<CaBundle>;

package/dist/network/ca.js

@@ -0,0 +1,136 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import forge from 'node-forge';
+const CA_DIR = path.join(os.homedir(), '.taqwright', 'network-ca');
+const CA_CERT_PATH = path.join(CA_DIR, 'ca.pem');
+const CA_KEY_PATH = path.join(CA_DIR, 'ca.key');
+const LEAF_CACHE_MAX = 256;
+export async function ensureCa() {
+    await fs.mkdir(CA_DIR, { recursive: true });
+    let certPem;
+    let keyPem;
+    try {
+        certPem = await fs.readFile(CA_CERT_PATH, 'utf-8');
+        keyPem = await fs.readFile(CA_KEY_PATH, 'utf-8');
+    }
+    catch {
+    }
+    let caCert;
+    let caKey;
+    if (certPem && keyPem && isStillValid(certPem)) {
+        caCert = forge.pki.certificateFromPem(certPem);
+        caKey = forge.pki.privateKeyFromPem(keyPem);
+    }
+    else {
+        const generated = generateCa();
+        caCert = generated.cert;
+        caKey = generated.key;
+        certPem = forge.pki.certificateToPem(caCert);
+        keyPem = forge.pki.privateKeyToPem(caKey);
+        await fs.writeFile(CA_CERT_PATH, certPem, { mode: 0o644 });
+        await fs.writeFile(CA_KEY_PATH, keyPem, { mode: 0o600 });
+    }
+    const androidHashName = androidSubjectHashOld(caCert);
+    const leafCache = new Map();
+    return {
+        certPem,
+        certPemPath: CA_CERT_PATH,
+        androidHashName,
+        signLeaf(host) {
+            const cached = leafCache.get(host);
+            if (cached) {
+                leafCache.delete(host);
+                leafCache.set(host, cached);
+                return cached;
+            }
+            const { cert, key } = generateLeaf(host, caCert, caKey);
+            const pair = {
+                keyPem: forge.pki.privateKeyToPem(key),
+                certPem: forge.pki.certificateToPem(cert),
+            };
+            leafCache.set(host, pair);
+            if (leafCache.size > LEAF_CACHE_MAX) {
+                const oldest = leafCache.keys().next().value;
+                if (oldest)
+                    leafCache.delete(oldest);
+            }
+            return pair;
+        },
+    };
+}
+function isStillValid(pem) {
+    try {
+        const cert = forge.pki.certificateFromPem(pem);
+        const now = Date.now();
+        const thirtyDays = 30 * 24 * 3600 * 1000;
+        return cert.validity.notAfter.getTime() - now > thirtyDays;
+    }
+    catch {
+        return false;
+    }
+}
+function generateCa() {
+    const keys = forge.pki.rsa.generateKeyPair(2048);
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = randomSerial();
+    cert.validity.notBefore = new Date();
+    cert.validity.notAfter = new Date();
+    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 10);
+    const attrs = [
+        { name: 'commonName', value: 'taqwright network capture CA' },
+        { name: 'organizationName', value: 'taqwright' },
+        { name: 'organizationalUnitName', value: 'network' },
+    ];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([
+        { name: 'basicConstraints', cA: true, critical: true },
+        { name: 'keyUsage', keyCertSign: true, cRLSign: true, critical: true },
+        { name: 'subjectKeyIdentifier' },
+    ]);
+    cert.sign(keys.privateKey, forge.md.sha256.create());
+    return { cert, key: keys.privateKey };
+}
+function generateLeaf(host, caCert, caKey) {
+    const keys = forge.pki.rsa.generateKeyPair(2048);
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = randomSerial();
+    cert.validity.notBefore = new Date(Date.now() - 24 * 3600 * 1000);
+    cert.validity.notAfter = new Date();
+    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 2);
+    cert.setSubject([{ name: 'commonName', value: host }]);
+    cert.setIssuer(caCert.subject.attributes);
+    const altNames = isIp(host) ? [{ type: 7, ip: host }] : [{ type: 2, value: host }];
+    cert.setExtensions([
+        { name: 'basicConstraints', cA: false },
+        { name: 'keyUsage', digitalSignature: true, keyEncipherment: true, critical: true },
+        { name: 'extKeyUsage', serverAuth: true, clientAuth: true },
+        { name: 'subjectAltName', altNames },
+    ]);
+    cert.sign(caKey, forge.md.sha256.create());
+    return { cert, key: keys.privateKey };
+}
+function randomSerial() {
+    const bytes = forge.random.getBytesSync(16);
+    let hex = forge.util.bytesToHex(bytes);
+    if (parseInt(hex[0], 16) > 7)
+        hex = '0' + hex.slice(1);
+    return hex;
+}
+function isIp(host) {
+    return /^[\d.]+$/.test(host) || host.includes(':');
+}
+function androidSubjectHashOld(cert) {
+    const der = forge.asn1.toDer(forge.pki.distinguishedNameToAsn1(cert.subject)).getBytes();
+    const md = forge.md.md5.create();
+    md.update(der);
+    const digestHex = md.digest().toHex();
+    const b0 = digestHex.slice(0, 2);
+    const b1 = digestHex.slice(2, 4);
+    const b2 = digestHex.slice(4, 6);
+    const b3 = digestHex.slice(6, 8);
+    return `${b3}${b2}${b1}${b0}`;
+}

package/dist/network/har.d.ts

@@ -0,0 +1,90 @@
+export interface HarHeader {
+    name: string;
+    value: string;
+}
+export interface HarRequestInit {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    bodyBytes?: number;
+    bodyText?: string;
+    startedAt: Date;
+}
+export interface HarResponseInit {
+    status: number;
+    statusText: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    mimeType: string;
+    bodyBytes?: number;
+    bodyText?: string;
+    endedAt: Date;
+}
+export interface HarEntryHandle {
+    id: number;
+    onResponse(r: HarResponseInit): void;
+    onError(err: string): void;
+}
+export interface HarLog {
+    log: {
+        version: '1.2';
+        creator: {
+            name: string;
+            version: string;
+        };
+        comment?: string;
+        entries: HarEntry[];
+    };
+}
+interface HarEntry {
+    startedDateTime: string;
+    time: number;
+    request: {
+        method: string;
+        url: string;
+        httpVersion: string;
+        headers: HarHeader[];
+        queryString: HarHeader[];
+        cookies: HarHeader[];
+        headersSize: number;
+        bodySize: number;
+        postData?: {
+            mimeType: string;
+            text: string;
+        };
+    };
+    response: {
+        status: number;
+        statusText: string;
+        httpVersion: string;
+        headers: HarHeader[];
+        cookies: HarHeader[];
+        content: {
+            size: number;
+            mimeType: string;
+            text?: string;
+        };
+        redirectURL: string;
+        headersSize: number;
+        bodySize: number;
+    };
+    cache: Record<string, never>;
+    timings: {
+        send: number;
+        wait: number;
+        receive: number;
+    };
+    comment?: string;
+    _error?: string;
+}
+export interface HarBuilder {
+    startEntry(req: HarRequestInit): HarEntryHandle;
+    addComment(line: string): void;
+    toJson(): HarLog;
+}
+export declare function createHarBuilder(meta: {
+    creator: string;
+    version?: string;
+}): HarBuilder;
+export {};

package/dist/network/har.js

@@ -0,0 +1,101 @@
+import { URL } from 'node:url';
+export function createHarBuilder(meta) {
+    const entries = [];
+    const comments = [];
+    let nextId = 0;
+    return {
+        startEntry(req) {
+            const id = nextId++;
+            const entry = {
+                startedDateTime: req.startedAt.toISOString(),
+                time: 0,
+                request: {
+                    method: req.method,
+                    url: req.url,
+                    httpVersion: req.httpVersion,
+                    headers: req.headers,
+                    queryString: parseQuery(req.url),
+                    cookies: [],
+                    headersSize: -1,
+                    bodySize: req.bodyBytes ?? -1,
+                    ...(req.bodyText !== undefined
+                        ? {
+                            postData: {
+                                mimeType: headerValue(req.headers, 'content-type') ?? 'application/octet-stream',
+                                text: req.bodyText,
+                            },
+                        }
+                        : {}),
+                },
+                response: {
+                    status: 0,
+                    statusText: '',
+                    httpVersion: '',
+                    headers: [],
+                    cookies: [],
+                    content: { size: 0, mimeType: '' },
+                    redirectURL: '',
+                    headersSize: -1,
+                    bodySize: -1,
+                },
+                cache: {},
+                timings: { send: 0, wait: -1, receive: -1 },
+            };
+            entries.push(entry);
+            const startedAt = req.startedAt.getTime();
+            return {
+                id,
+                onResponse(r) {
+                    entry.time = Math.max(0, r.endedAt.getTime() - startedAt);
+                    entry.response.status = r.status;
+                    entry.response.statusText = r.statusText;
+                    entry.response.httpVersion = r.httpVersion;
+                    entry.response.headers = r.headers;
+                    entry.response.content.mimeType = r.mimeType;
+                    entry.response.content.size = r.bodyBytes ?? 0;
+                    if (r.bodyText !== undefined)
+                        entry.response.content.text = r.bodyText;
+                    entry.response.bodySize = r.bodyBytes ?? -1;
+                    entry.response.redirectURL = headerValue(r.headers, 'location') ?? '';
+                    entry.timings.wait = entry.time;
+                },
+                onError(err) {
+                    entry._error = err;
+                },
+            };
+        },
+        addComment(line) {
+            comments.push(line);
+        },
+        toJson() {
+            return {
+                log: {
+                    version: '1.2',
+                    creator: { name: meta.creator, version: meta.version ?? '0' },
+                    ...(comments.length ? { comment: comments.join('\n') } : {}),
+                    entries,
+                },
+            };
+        },
+    };
+}
+function parseQuery(url) {
+    try {
+        const u = new URL(url);
+        const out = [];
+        for (const [name, value] of u.searchParams)
+            out.push({ name, value });
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function headerValue(headers, name) {
+    const lower = name.toLowerCase();
+    for (const h of headers) {
+        if (h.name.toLowerCase() === lower)
+            return h.value;
+    }
+    return undefined;
+}

package/dist/network/host-proxy.d.ts

@@ -0,0 +1,16 @@
+export interface HostProxyState {
+    service: string;
+    web: {
+        enabled: boolean;
+        host: string;
+        port: string;
+    };
+    secure: {
+        enabled: boolean;
+        host: string;
+        port: string;
+    };
+}
+export declare function snapshotProxy(): Promise<HostProxyState | undefined>;
+export declare function applyProxy(state: HostProxyState, host: string, port: number): Promise<void>;
+export declare function restoreProxy(): Promise<void>;

package/dist/network/host-proxy.js

@@ -0,0 +1,134 @@
+import { exec, execSync } from 'node:child_process';
+import { promisify } from 'node:util';
+const execP = promisify(exec);
+let pending;
+let handlersRegistered = false;
+export async function snapshotProxy() {
+    const service = await activeNetworkService();
+    if (!service)
+        return undefined;
+    const web = await readProxy('-getwebproxy', service);
+    const secure = await readProxy('-getsecurewebproxy', service);
+    return { service, web, secure };
+}
+export async function applyProxy(state, host, port) {
+    ensureHandlersRegistered();
+    if (!pending) {
+        pending = { state, appliedWeb: false, appliedSecure: false };
+    }
+    try {
+        await execP(`networksetup -setwebproxy ${shellQuote(state.service)} ${host} ${port}`);
+        pending.appliedWeb = true;
+    }
+    catch {
+    }
+    try {
+        await execP(`networksetup -setsecurewebproxy ${shellQuote(state.service)} ${host} ${port}`);
+        pending.appliedSecure = true;
+    }
+    catch {
+    }
+}
+export async function restoreProxy() {
+    if (!pending)
+        return;
+    const { state, appliedWeb, appliedSecure } = pending;
+    pending = undefined;
+    if (appliedWeb) {
+        if (state.web.enabled && state.web.host && state.web.port) {
+            await execP(`networksetup -setwebproxy ${shellQuote(state.service)} ${state.web.host} ${state.web.port}`).catch(() => undefined);
+        }
+        else {
+            await execP(`networksetup -setwebproxystate ${shellQuote(state.service)} off`).catch(() => undefined);
+        }
+    }
+    if (appliedSecure) {
+        if (state.secure.enabled && state.secure.host && state.secure.port) {
+            await execP(`networksetup -setsecurewebproxy ${shellQuote(state.service)} ${state.secure.host} ${state.secure.port}`).catch(() => undefined);
+        }
+        else {
+            await execP(`networksetup -setsecurewebproxystate ${shellQuote(state.service)} off`).catch(() => undefined);
+        }
+    }
+}
+function restoreProxySync() {
+    if (!pending)
+        return;
+    const { state, appliedWeb, appliedSecure } = pending;
+    pending = undefined;
+    try {
+        if (appliedWeb) {
+            if (state.web.enabled && state.web.host && state.web.port) {
+                execSync(`networksetup -setwebproxy ${shellQuote(state.service)} ${state.web.host} ${state.web.port}`, { stdio: 'ignore' });
+            }
+            else {
+                execSync(`networksetup -setwebproxystate ${shellQuote(state.service)} off`, {
+                    stdio: 'ignore',
+                });
+            }
+        }
+        if (appliedSecure) {
+            if (state.secure.enabled && state.secure.host && state.secure.port) {
+                execSync(`networksetup -setsecurewebproxy ${shellQuote(state.service)} ${state.secure.host} ${state.secure.port}`, { stdio: 'ignore' });
+            }
+            else {
+                execSync(`networksetup -setsecurewebproxystate ${shellQuote(state.service)} off`, {
+                    stdio: 'ignore',
+                });
+            }
+        }
+    }
+    catch {
+    }
+}
+function ensureHandlersRegistered() {
+    if (handlersRegistered)
+        return;
+    handlersRegistered = true;
+    process.on('exit', restoreProxySync);
+    const onSignal = (signal) => {
+        restoreProxySync();
+        process.kill(process.pid, signal);
+    };
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
+    process.once('SIGHUP', onSignal);
+    process.on('uncaughtException', (err) => {
+        restoreProxySync();
+        setImmediate(() => {
+            throw err;
+        });
+    });
+}
+async function activeNetworkService() {
+    try {
+        const { stdout } = await execP('networksetup -listallnetworkservices');
+        const services = stdout
+            .split('\n')
+            .filter((l) => l && !/asterisk denotes/i.test(l) && !l.startsWith('*'));
+        const preferred = services.find((s) => /wi-?fi/i.test(s)) ??
+            services.find((s) => /ethernet|usb|thunderbolt/i.test(s)) ??
+            services[0];
+        return preferred?.trim();
+    }
+    catch {
+        return 'Wi-Fi';
+    }
+}
+async function readProxy(kind, service) {
+    try {
+        const { stdout } = await execP(`networksetup ${kind} ${shellQuote(service)}`);
+        const enabled = /^Enabled:\s*Yes/im.test(stdout);
+        const host = stdout.match(/^Server:\s*(.*)$/im)?.[1]?.trim() ?? '';
+        const port = stdout.match(/^Port:\s*(\d+)/im)?.[1]?.trim() ?? '';
+        return { enabled, host, port };
+    }
+    catch {
+        return { enabled: false, host: '', port: '' };
+    }
+}
+function shellQuote(s) {
+    if (/^[A-Za-z0-9_\-./=:,@%+]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/network/index.d.ts

@@ -0,0 +1,26 @@
+import type { ProxyHandle } from './proxy.js';
+import { type CaBundle } from './ca.js';
+import { type HostProxyState } from './host-proxy.js';
+import { Platform } from '../types/index.js';
+export interface NetworkProxyHandle {
+    port: number;
+    flush(): Promise<object>;
+    attemptLog: string[];
+    _proxy: ProxyHandle;
+    _ca: CaBundle;
+    _platform: Platform;
+    _hostProxyState?: HostProxyState;
+    _configuredUdid?: string;
+    _configuredAndroid?: boolean;
+}
+export declare function prepareNetworkProxy(opts: {
+    platform: Platform;
+    parallelIndex: number;
+}): Promise<NetworkProxyHandle>;
+export declare function configureDeviceForCapture(handle: NetworkProxyHandle, opts: {
+    udid: string | undefined;
+    platform: Platform;
+}): Promise<void>;
+export declare function teardownDeviceCapture(handle: NetworkProxyHandle): Promise<void>;
+export declare function teardownNetworkProxy(handle: NetworkProxyHandle): Promise<void>;
+export declare function extractUdid(driverCapabilities: unknown): string | undefined;