@taqwright/taqwright 0.0.24

package/dist/network/index.js

@@ -0,0 +1,105 @@
+import { startProxy } from './proxy.js';
+import { ensureCa } from './ca.js';
+import { detectAndroidDeviceType, installSystemCa, setHttpProxy, clearHttpProxy, } from './android.js';
+import { isSimulatorUdid, waitForBoot, installRootCert } from './ios-sim.js';
+import { snapshotProxy, applyProxy, restoreProxy } from './host-proxy.js';
+import { Platform } from '../types/index.js';
+const BASE_PROXY_PORT = 8090;
+const EMULATOR_HOST_IP = '10.0.2.2';
+export async function prepareNetworkProxy(opts) {
+    const port = BASE_PROXY_PORT + opts.parallelIndex;
+    const ca = await ensureCa();
+    const proxy = await startProxy({ port, ca });
+    const handle = {
+        port,
+        attemptLog: proxy.attemptLog,
+        flush: () => proxy.flush(),
+        _proxy: proxy,
+        _ca: ca,
+        _platform: opts.platform,
+    };
+    if (opts.platform === Platform.IOS) {
+        const state = await snapshotProxy();
+        if (state) {
+            handle._hostProxyState = state;
+            await applyProxy(state, '127.0.0.1', port);
+        }
+        else {
+            proxy.attemptLog.push('network: networksetup unavailable — host proxy not set');
+        }
+    }
+    return handle;
+}
+export async function configureDeviceForCapture(handle, opts) {
+    if (!opts.udid) {
+        handle.attemptLog.push('network: no device udid available — skipping device config');
+        return;
+    }
+    if (opts.platform === Platform.ANDROID) {
+        const type = await detectAndroidDeviceType(opts.udid);
+        if (type === 'real-device') {
+            handle.attemptLog.push('network: skipped (real device — not supported in v1)');
+            return;
+        }
+        if (type === 'play-emulator') {
+            handle.attemptLog.push('network: skipped (Play AVD, release-keys)');
+            return;
+        }
+        if (type !== 'userdebug-emulator') {
+            handle.attemptLog.push(`network: skipped (unknown Android device type "${type}")`);
+            return;
+        }
+        const installed = await installSystemCa(opts.udid, handle._ca.certPemPath, handle._ca.androidHashName);
+        if (!installed) {
+            handle.attemptLog.push('network: failed to install CA on AVD — HTTPS bodies will be missing');
+            return;
+        }
+        try {
+            await setHttpProxy(opts.udid, EMULATOR_HOST_IP, handle.port);
+            handle._configuredUdid = opts.udid;
+            handle._configuredAndroid = true;
+        }
+        catch (e) {
+            handle.attemptLog.push(`network: failed to set device proxy: ${e.message}`);
+        }
+        return;
+    }
+    if (!isSimulatorUdid(opts.udid)) {
+        handle.attemptLog.push('network: skipped (real device — not supported in v1)');
+        return;
+    }
+    const booted = await waitForBoot(opts.udid);
+    if (!booted) {
+        handle.attemptLog.push('network: simulator did not finish booting in time');
+        return;
+    }
+    const certInstalled = await installRootCert(opts.udid, handle._ca.certPemPath);
+    if (!certInstalled) {
+        handle.attemptLog.push('network: failed to add root cert to sim keychain');
+        return;
+    }
+    handle._configuredUdid = opts.udid;
+}
+export async function teardownDeviceCapture(handle) {
+    if (handle._configuredAndroid && handle._configuredUdid) {
+        await clearHttpProxy(handle._configuredUdid).catch(() => undefined);
+        handle._configuredAndroid = false;
+    }
+}
+export async function teardownNetworkProxy(handle) {
+    if (handle._platform === Platform.IOS) {
+        await restoreProxy().catch(() => undefined);
+    }
+    await handle._proxy.stop().catch(() => undefined);
+}
+export function extractUdid(driverCapabilities) {
+    const c = driverCapabilities;
+    if (!c)
+        return undefined;
+    for (const key of ['udid', 'deviceUDID', 'appium:udid', 'appium:deviceUDID']) {
+        const v = c[key];
+        if (typeof v === 'string' && v.length > 0)
+            return v;
+    }
+    return undefined;
+}

package/dist/network/ios-sim.d.ts

@@ -0,0 +1,3 @@
+export declare function isSimulatorUdid(udid: string): boolean;
+export declare function waitForBoot(udid: string, timeoutMs?: number): Promise<boolean>;
+export declare function installRootCert(udid: string, certPemPath: string): Promise<boolean>;

package/dist/network/ios-sim.js

@@ -0,0 +1,29 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execP = promisify(exec);
+export function isSimulatorUdid(udid) {
+    return /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/.test(udid);
+}
+export async function waitForBoot(udid, timeoutMs = 60_000) {
+    try {
+        await execP(`xcrun simctl bootstatus ${shellQuote(udid)} -b`, { timeout: timeoutMs });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installRootCert(udid, certPemPath) {
+    try {
+        await execP(`xcrun simctl keychain ${shellQuote(udid)} add-root-cert ${shellQuote(certPemPath)}`, { timeout: 15_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shellQuote(s) {
+    if (/^[A-Za-z0-9_\-./=:,@%+]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/network/proxy.d.ts

@@ -0,0 +1,13 @@
+import { type CaBundle } from './ca.js';
+import { type HarLog } from './har.js';
+export interface ProxyHandle {
+    port: number;
+    attemptLog: string[];
+    flush(): Promise<HarLog>;
+    stop(): Promise<void>;
+}
+export interface ProxyOptions {
+    port: number;
+    ca: CaBundle;
+}
+export declare function startProxy(opts: ProxyOptions): Promise<ProxyHandle>;

package/dist/network/proxy.js

@@ -0,0 +1,310 @@
+import http from 'node:http';
+import https from 'node:https';
+import net from 'node:net';
+import tls from 'node:tls';
+import { createHarBuilder } from './har.js';
+const MAX_BODY_CAPTURE = 1 * 1024 * 1024;
+const PINNING_THRESHOLD = 3;
+const TEXT_MIME = /^(text\/|application\/(json|xml|x-www-form-urlencoded|javascript)|application\/[\w.+-]*\+(json|xml))/i;
+export async function startProxy(opts) {
+    const har = createHarBuilder({ creator: 'taqwright', version: '0.0.1' });
+    const attemptLog = [];
+    const tlsFailCount = new Map();
+    const pinnedHosts = new Set();
+    const server = http.createServer((req, res) => {
+        handleHttp(req, res, har).catch((err) => {
+            attemptLog.push(`http ${req.url ?? '?'}: ${err.message}`);
+            safeEnd(res, 502);
+        });
+    });
+    server.on('connect', (req, clientSocket, head) => {
+        handleConnect({
+            req,
+            clientSocket: clientSocket,
+            head,
+            ca: opts.ca,
+            har,
+            tlsFailCount,
+            pinnedHosts,
+            attemptLog,
+        });
+    });
+    server.on('clientError', (_err, socket) => {
+        try {
+            socket.destroy();
+        }
+        catch {
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port, '127.0.0.1', () => resolve());
+    });
+    return {
+        port: opts.port,
+        attemptLog,
+        async flush() {
+            for (const line of attemptLog)
+                har.addComment(line);
+            return har.toJson();
+        },
+        async stop() {
+            await new Promise((resolve) => {
+                server.closeAllConnections?.();
+                server.close(() => resolve());
+            });
+        },
+    };
+}
+async function handleHttp(req, res, har) {
+    const url = req.url ?? '';
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        safeEnd(res, 400);
+        return;
+    }
+    const startedAt = new Date();
+    const upstream = http.request({
+        host: parsed.hostname,
+        port: parsed.port || 80,
+        method: req.method,
+        path: parsed.pathname + parsed.search,
+        headers: sanitizeRequestHeaders(req.headers, parsed.host),
+    });
+    await pipeRequestThrough(req, upstream, parsed.toString(), har, startedAt, res);
+}
+function handleConnect(a) {
+    const [host, portStr] = (a.req.url ?? '').split(':');
+    const port = Number.parseInt(portStr ?? '443', 10) || 443;
+    if (!host) {
+        a.clientSocket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+        return;
+    }
+    if (a.pinnedHosts.has(host)) {
+        blindTunnel(a.clientSocket, a.head, host, port);
+        return;
+    }
+    a.clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+    const leaf = a.ca.signLeaf(host);
+    const tlsSocket = new tls.TLSSocket(a.clientSocket, {
+        isServer: true,
+        key: leaf.keyPem,
+        cert: leaf.certPem,
+        ALPNProtocols: ['http/1.1'],
+    });
+    let sawHttpByte = false;
+    tlsSocket.on('data', () => {
+        sawHttpByte = true;
+    });
+    tlsSocket.on('error', (_err) => {
+        if (!sawHttpByte) {
+            const count = (a.tlsFailCount.get(host) ?? 0) + 1;
+            a.tlsFailCount.set(host, count);
+            if (count >= PINNING_THRESHOLD && !a.pinnedHosts.has(host)) {
+                a.pinnedHosts.add(host);
+                a.attemptLog.push(`pinned: ${host}`);
+            }
+        }
+        try {
+            tlsSocket.destroy();
+        }
+        catch {
+        }
+    });
+    const parser = http.createServer((req2, res2) => {
+        handleDecryptedRequest(req2, res2, host, port, a.har).catch((err) => {
+            a.attemptLog.push(`https ${host}${req2.url ?? ''}: ${err.message}`);
+            safeEnd(res2, 502);
+        });
+    });
+    parser.emit('connection', tlsSocket);
+}
+function blindTunnel(clientSocket, head, host, port) {
+    const upstream = net.connect(port, host, () => {
+        clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+        if (head.length > 0)
+            upstream.write(head);
+        clientSocket.pipe(upstream).pipe(clientSocket);
+    });
+    upstream.on('error', () => {
+        try {
+            clientSocket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n');
+        }
+        catch {
+        }
+    });
+    clientSocket.on('error', () => {
+        try {
+            upstream.destroy();
+        }
+        catch {
+        }
+    });
+}
+async function handleDecryptedRequest(req, res, host, port, har) {
+    const startedAt = new Date();
+    const url = `https://${host}${port === 443 ? '' : `:${port}`}${req.url ?? '/'}`;
+    const upstream = https.request({
+        host,
+        port,
+        method: req.method,
+        path: req.url,
+        headers: sanitizeRequestHeaders(req.headers, host + (port === 443 ? '' : `:${port}`)),
+        servername: host,
+    });
+    await pipeRequestThrough(req, upstream, url, har, startedAt, res);
+}
+async function pipeRequestThrough(req, upstream, url, har, startedAt, res) {
+    const reqChunks = [];
+    let reqBytes = 0;
+    let reqCapped = false;
+    req.on('data', (chunk) => {
+        reqBytes += chunk.length;
+        if (!reqCapped) {
+            if (reqBytes <= MAX_BODY_CAPTURE)
+                reqChunks.push(chunk);
+            else
+                reqCapped = true;
+        }
+        upstream.write(chunk);
+    });
+    req.on('end', () => upstream.end());
+    req.on('error', () => {
+        try {
+            upstream.destroy();
+        }
+        catch {
+        }
+    });
+    let upstreamRes;
+    try {
+        upstreamRes = await new Promise((resolve, reject) => {
+            upstream.once('response', resolve);
+            upstream.once('error', reject);
+        });
+    }
+    catch (err) {
+        const entry = har.startEntry({
+            method: req.method ?? 'GET',
+            url,
+            httpVersion: `HTTP/${req.httpVersion}`,
+            headers: headerObjectToArray(req.headers),
+            bodyBytes: reqBytes || -1,
+            startedAt,
+        });
+        entry.onError(err.message);
+        safeEnd(res, 502);
+        return;
+    }
+    const entry = har.startEntry({
+        method: req.method ?? 'GET',
+        url,
+        httpVersion: `HTTP/${req.httpVersion}`,
+        headers: headerObjectToArray(req.headers),
+        bodyBytes: reqBytes || -1,
+        bodyText: tryDecodeText(Buffer.concat(reqChunks), getHeader(req.headers, 'content-type')),
+        startedAt,
+    });
+    res.statusCode = upstreamRes.statusCode ?? 0;
+    res.statusMessage = upstreamRes.statusMessage ?? '';
+    for (const [k, v] of Object.entries(upstreamRes.headers)) {
+        if (v === undefined)
+            continue;
+        try {
+            res.setHeader(k, v);
+        }
+        catch {
+        }
+    }
+    const resChunks = [];
+    let resBytes = 0;
+    let resCapped = false;
+    upstreamRes.on('data', (chunk) => {
+        resBytes += chunk.length;
+        if (!resCapped) {
+            if (resBytes <= MAX_BODY_CAPTURE)
+                resChunks.push(chunk);
+            else
+                resCapped = true;
+        }
+        res.write(chunk);
+    });
+    await new Promise((resolve) => {
+        upstreamRes.on('end', () => {
+            res.end();
+            resolve();
+        });
+        upstreamRes.on('error', () => {
+            res.end();
+            resolve();
+        });
+    });
+    entry.onResponse({
+        status: upstreamRes.statusCode ?? 0,
+        statusText: upstreamRes.statusMessage ?? '',
+        httpVersion: `HTTP/${upstreamRes.httpVersion}`,
+        headers: headerObjectToArray(upstreamRes.headers),
+        mimeType: getHeader(upstreamRes.headers, 'content-type') ?? '',
+        bodyBytes: resBytes,
+        bodyText: tryDecodeText(Buffer.concat(resChunks), getHeader(upstreamRes.headers, 'content-type')),
+        endedAt: new Date(),
+    });
+}
+function headerObjectToArray(h) {
+    const out = [];
+    for (const [name, value] of Object.entries(h)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                out.push({ name, value: v });
+        }
+        else {
+            out.push({ name, value: String(value) });
+        }
+    }
+    return out;
+}
+function getHeader(h, name) {
+    const v = h[name.toLowerCase()];
+    if (v === undefined)
+        return undefined;
+    return Array.isArray(v) ? v[0] : v;
+}
+function sanitizeRequestHeaders(h, host) {
+    const out = {};
+    for (const [name, value] of Object.entries(h)) {
+        if (value === undefined)
+            continue;
+        const lower = name.toLowerCase();
+        if (lower === 'proxy-connection' || lower === 'proxy-authorization')
+            continue;
+        out[name] = value;
+    }
+    out.host = host;
+    return out;
+}
+function tryDecodeText(buf, contentType) {
+    if (buf.length === 0)
+        return undefined;
+    if (!contentType || !TEXT_MIME.test(contentType))
+        return undefined;
+    try {
+        return buf.toString('utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeEnd(res, status) {
+    try {
+        if (!res.headersSent)
+            res.statusCode = status;
+        res.end();
+    }
+    catch {
+    }
+}

package/dist/providers/appium.d.ts

@@ -0,0 +1,23 @@
+import { type ChildProcess } from 'node:child_process';
+import { Platform } from '../types/index.js';
+export declare function installDriver(driverName: string, opts?: {
+    appiumPath?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<void>;
+export interface AppiumServerSpawnOptions {
+    host?: string;
+    port?: number;
+    basePath?: string;
+}
+export declare function startAppiumServer(provider: string, opts?: AppiumServerSpawnOptions, avdName?: string): Promise<ChildProcess>;
+export declare function stopAppiumServer(): Promise<string>;
+export declare function killAppiumOnPort(port: number): Promise<boolean>;
+export declare function isEmulatorInstalled(platform: Platform): Promise<boolean>;
+export declare function startAndroidEmulator(avdName?: string, androidHome?: string | undefined): Promise<void>;
+export declare function getAppBundleId(buildPath: string): Promise<string>;
+export declare function getConnectedIOSDeviceUDID(): Promise<string>;
+export declare function getActiveAndroidDevices(): Promise<number>;
+export declare function getApkDetails(buildPath: string): Promise<{
+    packageName: string;
+    launchableActivity: string;
+}>;