@houwert/conductor 0.11.0 → 0.12.0

package/dist/commands/memory.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.memory = memory;
+exports.HELP = `  memory [<appId>]                    Show device + app memory usage and object counts`;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+async function resolveAppId(explicit, sessionName) {
+    if (explicit)
+        return explicit;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    if (session.appId)
+        return session.appId;
+    // Fall back to whatever's in the foreground.
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        if (driver instanceof android_js_1.AndroidDriver)
+            return await driver.getForegroundApp();
+        if (driver instanceof web_js_1.WebDriver)
+            return await driver.runningApp();
+        if (driver instanceof ios_js_1.IOSDriver)
+            return await driver.runningApp([]);
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+// ── Android ───────────────────────────────────────────────────────────────────
+function parseAndroidMeminfo(out) {
+    const get = (key) => {
+        const m = out.match(new RegExp(`^${key}:\\s+(\\d+)\\s*kB`, 'm'));
+        return m ? Number(m[1]) * 1024 : undefined;
+    };
+    return {
+        totalBytes: get('MemTotal'),
+        availableBytes: get('MemAvailable'),
+        freeBytes: get('MemFree'),
+        cachedBytes: get('Cached'),
+        swapTotalBytes: get('SwapTotal'),
+        swapFreeBytes: get('SwapFree'),
+    };
+}
+function parseAndroidDumpsysMeminfo(out) {
+    const app = {};
+    const objects = {};
+    const pidMatch = out.match(/\*\* MEMINFO in pid (\d+)/);
+    const pid = pidMatch ? Number(pidMatch[1]) : undefined;
+    // App Summary block — most useful, single-line entries with KB values.
+    // e.g. "       Java Heap:    12345"
+    const summary = out.match(/App Summary[\s\S]*?(?:\n\s*\n|TOTAL:)/);
+    if (summary) {
+        const block = summary[0];
+        const grab = (label) => {
+            const m = block.match(new RegExp(`${label}:\\s+(\\d+)`));
+            return m ? Number(m[1]) * 1024 : undefined;
+        };
+        app.javaHeapBytes = grab('Java Heap');
+        app.nativeHeapBytes = grab('Native Heap');
+        app.codeBytes = grab('Code');
+        app.stackBytes = grab('Stack');
+        app.graphicsBytes = grab('Graphics');
+        app.privateOtherBytes = grab('Private Other');
+        app.systemBytes = grab('System');
+        const totalPss = block.match(/TOTAL PSS:\s+(\d+)/);
+        if (totalPss)
+            app.totalPssBytes = Number(totalPss[1]) * 1024;
+        const totalRss = block.match(/TOTAL RSS:\s+(\d+)/);
+        if (totalRss)
+            app.totalRssBytes = Number(totalRss[1]) * 1024;
+        const totalSwap = block.match(/TOTAL SWAP[^:]*:\s+(\d+)/);
+        if (totalSwap)
+            app['totalSwapBytes'] = Number(totalSwap[1]) * 1024;
+    }
+    // Fallback: TOTAL line in the main table — "TOTAL  12345  ..."
+    if (app.totalPssBytes === undefined) {
+        const total = out.match(/^\s*TOTAL\s+(\d+)/m);
+        if (total)
+            app.totalPssBytes = Number(total[1]) * 1024;
+    }
+    // Objects block:
+    //  Objects
+    //         Views:        3   ViewRootImpl:        1
+    //     AppContexts:        2     Activities:        1
+    //          Assets:        7  AssetManagers:        0
+    //   Local Binders:        5  Proxy Binders:       17
+    //   Parcel memory:        1     Parcel count:        4
+    //    Death Recipients:    0   OpenSSL Sockets:    0
+    //            WebViews:    0
+    const objSection = out.match(/Objects[\s\S]*?(?:\n\s*\n|SQL\s|DATABASES|$)/);
+    if (objSection) {
+        const text = objSection[0];
+        // Capture every "Label: number" pair (labels may have spaces).
+        const re = /([A-Za-z][A-Za-z _]*?):\s+(\d+)/g;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const key = m[1].trim();
+            if (key === 'Objects')
+                continue;
+            objects[key] = Number(m[2]);
+        }
+    }
+    return { app, objects, pid };
+}
+async function collectAndroid(deviceId, appId) {
+    const report = { platform: 'android', deviceId, appId, notes: [] };
+    const meminfo = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'cat', '/proc/meminfo']);
+    if (meminfo.success) {
+        const sys = parseAndroidMeminfo(meminfo.stdout);
+        report.system = {
+            ...sys,
+            usedBytes: sys.totalBytes !== undefined && sys.availableBytes !== undefined
+                ? sys.totalBytes - sys.availableBytes
+                : undefined,
+        };
+    }
+    else {
+        report.notes.push(`/proc/meminfo unavailable: ${meminfo.stderr.trim()}`);
+    }
+    if (appId) {
+        const dump = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'dumpsys', 'meminfo', appId]);
+        if (dump.success && !dump.stdout.includes('No process found')) {
+            const { app, objects, pid } = parseAndroidDumpsysMeminfo(dump.stdout);
+            report.app = app;
+            report.objects = objects;
+            report.pid = pid;
+        }
+        else {
+            report.notes.push(`dumpsys meminfo ${appId} returned no data — app may not be running`);
+        }
+    }
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── iOS / tvOS ────────────────────────────────────────────────────────────────
+function parseVmStat(out) {
+    // vm_stat output uses "page size of 16384 bytes" and counts in pages.
+    const pageMatch = out.match(/page size of (\d+)/);
+    const pageSize = pageMatch ? Number(pageMatch[1]) : 4096;
+    const grab = (label) => {
+        const m = out.match(new RegExp(`${label}:\\s+(\\d+)`));
+        return m ? Number(m[1]) * pageSize : undefined;
+    };
+    const free = grab('Pages free');
+    const inactive = grab('Pages inactive');
+    const speculative = grab('Pages speculative');
+    const wired = grab('Pages wired down');
+    const active = grab('Pages active');
+    const compressed = grab('Pages occupied by compressor');
+    const total = [free, inactive, speculative, wired, active, compressed]
+        .filter((v) => v !== undefined)
+        .reduce((a, b) => a + b, 0);
+    const available = free !== undefined && inactive !== undefined && speculative !== undefined
+        ? free + inactive + speculative
+        : undefined;
+    return {
+        totalBytes: total > 0 ? total : undefined,
+        freeBytes: free,
+        availableBytes: available,
+    };
+}
+async function findIOSPid(deviceId, appId) {
+    // Inside-simulator PIDs == host PIDs for app processes.
+    const list = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'spawn', deviceId, 'launchctl', 'list']);
+    if (!list.success)
+        return undefined;
+    for (const line of list.stdout.split('\n')) {
+        if (!line.includes(appId))
+            continue;
+        const parts = line.trim().split(/\s+/);
+        const pid = Number(parts[0]);
+        if (Number.isFinite(pid) && pid > 0)
+            return pid;
+    }
+    return undefined;
+}
+function parseVmmapSummary(out) {
+    const regions = {};
+    const app = {};
+    // Lines look like: "MALLOC                          1.2G       234.5M  ..."
+    // We want the "RESIDENT" column (2nd numeric). The columns are whitespace-delimited.
+    // Easier: parse the per-region rows under "REGION TYPE" header.
+    const headerIdx = out.indexOf('REGION TYPE');
+    if (headerIdx === -1)
+        return { app, regions };
+    const body = out.slice(headerIdx);
+    const lines = body.split('\n').slice(1);
+    for (const raw of lines) {
+        const line = raw.trimEnd();
+        if (!line.trim())
+            continue;
+        if (line.startsWith('='))
+            break;
+        if (line.startsWith('TOTAL')) {
+            // "TOTAL                          5.2G       1.4G       950M  ..."
+            const m = line.match(/TOTAL\s+\S+\s+(\S+)/);
+            if (m)
+                app.totalRssBytes = humanToBytes(m[1]);
+            break;
+        }
+        // Region rows: name (may have spaces), virtual, resident, dirty, swap, ...
+        const m = line.match(/^(.+?)\s{2,}(\S+)\s+(\S+)/);
+        if (!m)
+            continue;
+        const name = m[1].trim();
+        const resident = humanToBytes(m[3]);
+        if (resident !== undefined)
+            regions[name] = resident;
+    }
+    // Roll up a few well-known regions into the canonical fields.
+    app.nativeHeapBytes = regions['MALLOC'] ?? regions['MALLOC_NANO'];
+    app.stackBytes = regions['Stack'];
+    return { app, regions };
+}
+function humanToBytes(s) {
+    // Matches "1.2G", "234.5M", "950K", "1024", "1.2GB" etc.
+    const m = s.match(/^([\d.]+)\s*([KMGT]?)B?$/i);
+    if (!m)
+        return undefined;
+    const n = parseFloat(m[1]);
+    if (Number.isNaN(n))
+        return undefined;
+    const mult = {
+        '': 1,
+        K: 1024,
+        M: 1024 ** 2,
+        G: 1024 ** 3,
+        T: 1024 ** 4,
+    };
+    return Math.round(n * (mult[m[2].toUpperCase()] ?? 1));
+}
+async function collectIOS(deviceId, platform, appId) {
+    const report = { platform, deviceId, appId, notes: [] };
+    // System-wide memory: vm_stat from inside the simulator (== host RAM).
+    const vm = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'spawn', deviceId, 'vm_stat']);
+    if (vm.success) {
+        const sys = parseVmStat(vm.stdout);
+        report.system = {
+            ...sys,
+            usedBytes: sys.totalBytes !== undefined && sys.availableBytes !== undefined
+                ? sys.totalBytes - sys.availableBytes
+                : undefined,
+        };
+        report.notes.push('System memory reflects host Mac RAM — simulators share the host memory pool.');
+    }
+    else {
+        report.notes.push(`vm_stat unavailable: ${vm.stderr.trim()}`);
+    }
+    if (!appId) {
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    const pid = await findIOSPid(deviceId, appId);
+    if (!pid) {
+        report.notes.push(`No running process found for ${appId}.`);
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    report.pid = pid;
+    // ps for RSS/VSZ — fast, always available.
+    const ps = await (0, runner_js_1.spawnCommand)('ps', ['-o', 'rss=,vsz=', '-p', String(pid)]);
+    if (ps.success) {
+        const m = ps.stdout.trim().match(/(\d+)\s+(\d+)/);
+        if (m) {
+            report.app = {
+                ...(report.app ?? {}),
+                // ps reports rss/vsz in KB on macOS.
+                totalRssBytes: Number(m[1]) * 1024,
+                vszBytes: Number(m[2]) * 1024,
+            };
+        }
+    }
+    // vmmap -summary for region breakdown — slower but provides categories.
+    const vmmap = await (0, runner_js_1.spawnCommand)('vmmap', ['-summary', String(pid)]);
+    if (vmmap.success) {
+        const { app, regions } = parseVmmapSummary(vmmap.stdout);
+        report.app = {
+            ...(report.app ?? {}),
+            ...Object.fromEntries(Object.entries(app).filter(([, v]) => v !== undefined)),
+            regions,
+        };
+    }
+    else {
+        report.notes.push('vmmap unavailable — run `sudo DevToolsSecurity --enable` if it errors.');
+    }
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── Web (Playwright via CDP) ──────────────────────────────────────────────────
+async function collectWeb(deviceId, sessionName) {
+    const report = { platform: 'web', deviceId, notes: [] };
+    let driver;
+    try {
+        const d = await (0, runner_js_1.getDriver)(sessionName);
+        if (!(d instanceof web_js_1.WebDriver)) {
+            report.notes.push('Expected web driver, got something else.');
+            return report;
+        }
+        driver = d;
+    }
+    catch (err) {
+        report.notes.push(`Could not attach to web driver: ${err instanceof Error ? err.message : String(err)}`);
+        return report;
+    }
+    const data = await driver.memory().catch((err) => {
+        report.notes.push(`Performance.getMetrics failed: ${err.message}`);
+        return null;
+    });
+    if (!data) {
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    report.appId = data.url;
+    const m = data.metrics;
+    const pm = data.pageMemory;
+    report.app = {
+        // Heap totals — prefer page-context performance.memory (Chromium) over
+        // CDP's JSHeapUsedSize (which can lag). Both are JS heap only.
+        nativeHeapBytes: pm?.usedJSHeapSize ?? m['JSHeapUsedSize'],
+        codeBytes: m['JSHeapTotalSize'] ? m['JSHeapTotalSize'] - (m['JSHeapUsedSize'] ?? 0) : undefined,
+        // Roll the raw CDP metrics into `regions` so they're inspectable verbatim.
+        regions: { ...m },
+    };
+    if (pm) {
+        report.app.regions = {
+            ...report.app.regions,
+            'JS Heap Used': pm.usedJSHeapSize,
+            'JS Heap Total': pm.totalJSHeapSize,
+            'JS Heap Limit': pm.jsHeapSizeLimit,
+        };
+    }
+    // Object counts — direct CDP equivalents of Android's "Views/Activities/Binders".
+    const objectKeys = [
+        'Nodes',
+        'Documents',
+        'Frames',
+        'JSEventListeners',
+        'LayoutCount',
+        'RecalcStyleCount',
+    ];
+    const objects = {};
+    for (const k of objectKeys) {
+        if (m[k] !== undefined)
+            objects[k] = m[k];
+    }
+    if (Object.keys(objects).length > 0)
+        report.objects = objects;
+    report.notes.push('Web memory is per-page (Performance.getMetrics + performance.memory). Run-wide RSS for the browser process is not exposed via CDP.');
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── Formatting ────────────────────────────────────────────────────────────────
+function fmtBytes(n) {
+    if (n === undefined)
+        return '—';
+    if (n < 1024)
+        return `${n} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let v = n / 1024;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(v >= 100 ? 0 : v >= 10 ? 1 : 2)} ${units[i]}`;
+}
+function formatReport(r) {
+    const lines = [];
+    lines.push(`Device:    ${r.deviceId} (${r.platform})`);
+    if (r.appId)
+        lines.push(`App:       ${r.appId}${r.pid ? ` (pid ${r.pid})` : ''}`);
+    if (r.system) {
+        lines.push('');
+        lines.push('System memory:');
+        const s = r.system;
+        if (s.totalBytes !== undefined)
+            lines.push(`  Total:      ${fmtBytes(s.totalBytes)}`);
+        if (s.usedBytes !== undefined)
+            lines.push(`  Used:       ${fmtBytes(s.usedBytes)}`);
+        if (s.availableBytes !== undefined)
+            lines.push(`  Available:  ${fmtBytes(s.availableBytes)}`);
+        if (s.freeBytes !== undefined)
+            lines.push(`  Free:       ${fmtBytes(s.freeBytes)}`);
+        if (s.cachedBytes !== undefined)
+            lines.push(`  Cached:     ${fmtBytes(s.cachedBytes)}`);
+        if (s.swapTotalBytes !== undefined)
+            lines.push(`  Swap:       ${fmtBytes((s.swapTotalBytes ?? 0) - (s.swapFreeBytes ?? 0))} / ${fmtBytes(s.swapTotalBytes)}`);
+    }
+    if (r.app) {
+        lines.push('');
+        lines.push('App memory:');
+        const a = r.app;
+        if (a.totalPssBytes !== undefined)
+            lines.push(`  PSS total:  ${fmtBytes(a.totalPssBytes)}`);
+        if (a.totalRssBytes !== undefined)
+            lines.push(`  RSS total:  ${fmtBytes(a.totalRssBytes)}`);
+        if (a.totalUssBytes !== undefined)
+            lines.push(`  USS total:  ${fmtBytes(a.totalUssBytes)}`);
+        if (a.vszBytes !== undefined)
+            lines.push(`  VSZ:        ${fmtBytes(a.vszBytes)}`);
+        if (a.javaHeapBytes !== undefined)
+            lines.push(`  Java heap:  ${fmtBytes(a.javaHeapBytes)}`);
+        if (a.nativeHeapBytes !== undefined)
+            lines.push(`  Native:     ${fmtBytes(a.nativeHeapBytes)}`);
+        if (a.codeBytes !== undefined)
+            lines.push(`  Code:       ${fmtBytes(a.codeBytes)}`);
+        if (a.stackBytes !== undefined)
+            lines.push(`  Stack:      ${fmtBytes(a.stackBytes)}`);
+        if (a.graphicsBytes !== undefined)
+            lines.push(`  Graphics:   ${fmtBytes(a.graphicsBytes)}`);
+        if (a.privateOtherBytes !== undefined)
+            lines.push(`  Private:    ${fmtBytes(a.privateOtherBytes)}`);
+        if (a.systemBytes !== undefined)
+            lines.push(`  System:     ${fmtBytes(a.systemBytes)}`);
+        if (a.regions && Object.keys(a.regions).length > 0) {
+            lines.push('');
+            lines.push('Top memory regions (resident):');
+            const entries = Object.entries(a.regions)
+                .filter(([, v]) => v > 0)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 12);
+            for (const [name, bytes] of entries) {
+                lines.push(`  ${name.padEnd(28)} ${fmtBytes(bytes)}`);
+            }
+        }
+    }
+    if (r.objects && Object.keys(r.objects).length > 0) {
+        lines.push('');
+        lines.push('Object counts:');
+        const entries = Object.entries(r.objects).sort((a, b) => b[1] - a[1]);
+        for (const [name, count] of entries) {
+            lines.push(`  ${name.padEnd(20)} ${count}`);
+        }
+    }
+    if (r.notes && r.notes.length > 0) {
+        lines.push('');
+        for (const n of r.notes)
+            lines.push(`note: ${n}`);
+    }
+    return lines.join('\n');
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+async function memory(appIdArg, opts = {}, sessionName = 'default', _memOpts = {}) {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    let report;
+    if (platform === 'web') {
+        report = await collectWeb(deviceId, sessionName);
+    }
+    else {
+        const appId = await resolveAppId(appIdArg, sessionName);
+        if (platform === 'android') {
+            report = await collectAndroid(deviceId, appId);
+        }
+        else {
+            report = await collectIOS(deviceId, platform, appId);
+        }
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', ...report }, opts);
+    }
+    else {
+        console.log(formatReport(report));
+    }
+    return 0;
+}

package/dist/daemon/web-server.js

@@ -839,6 +839,35 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { isScreenStatic: snap1 === snap2 });
                 return;
             }
+            case '/memory': {
+                const p = await getPage(dlog);
+                const session = await p.context().newCDPSession(p);
+                try {
+                    await session.send('Performance.enable').catch(() => { });
+                    const perf = (await session.send('Performance.getMetrics'));
+                    const metricsMap = {};
+                    for (const m of perf.metrics)
+                        metricsMap[m.name] = m.value;
+                    // Chrome-only: performance.memory in the page context.
+                    const pageMemory = await p
+                        .evaluate(() => {
+                        const pm = performance.memory;
+                        return pm
+                            ? {
+                                usedJSHeapSize: pm.usedJSHeapSize,
+                                totalJSHeapSize: pm.totalJSHeapSize,
+                                jsHeapSizeLimit: pm.jsHeapSizeLimit,
+                            }
+                            : null;
+                    })
+                        .catch(() => null);
+                    jsonResponse(res, { metrics: metricsMap, pageMemory, url: p.url() });
+                }
+                finally {
+                    await session.detach().catch(() => { });
+                }
+                return;
+            }
             case '/consoleLogs': {
                 const since = parsedUrl.query['since'] ?? '';
                 const entries = since

package/dist/drivers/web.js

@@ -136,6 +136,9 @@ class WebDriver {
         const result = await this.get('runningApp');
         return result.runningAppBundleId;
     }
+    async memory() {
+        return this.get('memory');
+    }
     async eraseAllText(count = 50) {
         await this.post('eraseText', { count });
     }

package/dist/index.js

@@ -46,6 +46,7 @@ const start_device_js_1 = require("./commands/start-device.js");
 const stop_device_js_1 = require("./commands/stop-device.js");
 const delete_device_js_1 = require("./commands/delete-device.js");
 const logs_js_1 = require("./commands/logs.js");
+const memory_js_1 = require("./commands/memory.js");
 const device_picker_js_1 = require("./device-picker.js");
 const update_check_js_1 = require("./update-check.js");
 const pkg_root_js_1 = require("./pkg-root.js");
@@ -96,6 +97,7 @@ const COMMAND_HELP = {
     'device-pool': device_pool_js_1.HELP,
     'run-parallel': run_parallel_js_1.HELP,
     logs: logs_js_1.HELP,
+    memory: memory_js_1.HELP,
 };
 const OPTIONS_HELP = `Options:
   --device <id>     Target device ID (also keys the session and daemon)
@@ -482,6 +484,11 @@ async function main() {
                 duration: argv['duration'] !== undefined ? Number(argv['duration']) : undefined,
             });
             break;
+        case 'memory': {
+            const appId = rest[0];
+            exitCode = await (0, memory_js_1.memory)(appId, opts, sessionName);
+            break;
+        }
         case 'run-flow': {
             const file = rest[0] ?? '';
             const rawEnv = argv['env'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

package/skills/conductor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conductor
-version: 0.11.0
+version: 0.12.0
 description: "Token-efficient CLI for mobile UI testing (iOS simulator + Android emulator), designed for AI agents"
 metadata.openclaw:
   category: service

package/skills/skills.yaml

@@ -3,6 +3,6 @@ skills:
     path: conductor/SKILL.md
     description: "Token-efficient CLI for mobile UI testing, designed for AI agents"
     category: service
-    version: 0.11.0
+    version: 0.12.0
     requires:
       bins: [conductor]