novac 2.0.1 → 2.2.0

package/kits/kitadb/kitdef.js

@@ -0,0 +1,606 @@
+// kitadb — novac ADB & Fastboot kit
+// Full-featured wrapper around adb and fastboot CLIs.
+// Requires adb and/or fastboot to be installed and in PATH.
+
+'use strict';
+
+const { spawnSync, spawn, execSync } = require('child_process');
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ─── HELPERS ─────────────────────────────────────────────────────────────────
+
+function run(bin, args, opts = {}) {
+  const r = spawnSync(bin, args, {
+    encoding: 'utf8',
+    timeout:  opts.timeout ?? 30000,
+    env:      opts.env ?? process.env,
+    ...opts,
+  });
+  if (r.error) throw new Error(`[${bin}] ${r.error.message}`);
+  return {
+    stdout: (r.stdout ?? '').trim(),
+    stderr: (r.stderr ?? '').trim(),
+    status: r.status ?? -1,
+    ok:     r.status === 0,
+  };
+}
+
+function runAdb(args, opts = {}) {
+  const serial = opts.serial;
+  const prefix = serial ? ['-s', serial] : [];
+  return run('adb', [...prefix, ...args], opts);
+}
+
+function runFastboot(args, opts = {}) {
+  const serial = opts.serial;
+  const prefix = serial ? ['-s', serial] : [];
+  return run('fastboot', [...prefix, ...args], opts);
+}
+
+function lines(str) {
+  return str.split('\n').map(l => l.trim()).filter(Boolean);
+}
+
+function requireOk(result, msg) {
+  if (!result.ok) throw new Error(`${msg}: ${result.stderr || result.stdout}`);
+  return result;
+}
+
+// ─── ADB SERVER ───────────────────────────────────────────────────────────────
+
+const server = {
+  start() { return runAdb(['start-server']); },
+  kill()  { return runAdb(['kill-server']); },
+  restart() { server.kill(); return server.start(); },
+  version() {
+    const r = runAdb(['version']);
+    const m = r.stdout.match(/Android Debug Bridge version ([\d.]+)/);
+    return m ? m[1] : r.stdout;
+  },
+};
+
+// ─── DEVICE MANAGEMENT ───────────────────────────────────────────────────────
+
+function parseDevices(output) {
+  return lines(output)
+    .filter(l => l.includes('\t'))
+    .map(l => {
+      const [serial, ...rest] = l.split('\t');
+      const state = rest[0]?.trim();
+      const props = {};
+      const propStr = rest.slice(1).join(' ');
+      for (const m of propStr.matchAll(/(\w+):(\S+)/g)) props[m[1]] = m[2];
+      return { serial: serial.trim(), state, ...props };
+    });
+}
+
+const devices = {
+  list() {
+    const r = runAdb(['devices', '-l']);
+    return parseDevices(r.stdout);
+  },
+  listTransports() {
+    const r = runAdb(['devices', '-l']);
+    return parseDevices(r.stdout);
+  },
+  connect(host, port = 5555) {
+    return runAdb(['connect', `${host}:${port}`]);
+  },
+  disconnect(host, port) {
+    const target = host ? (port ? `${host}:${port}` : host) : '';
+    return runAdb(target ? ['disconnect', target] : ['disconnect']);
+  },
+  pair(host, port, code, opts) {
+    return runAdb(['pair', `${host}:${port}`, code], opts);
+  },
+  wait(state = 'device', opts = {}) {
+    // state: device | recovery | rescue | sideload | bootloader | disconnect
+    return runAdb([`wait-for-${state}`], { timeout: opts.timeout ?? 60000, ...opts });
+  },
+  serial(opts = {}) {
+    const r = runAdb(['get-serialno'], opts);
+    return r.stdout;
+  },
+  state(opts = {}) {
+    const r = runAdb(['get-state'], opts);
+    return r.stdout;
+  },
+};
+
+// ─── SHELL ────────────────────────────────────────────────────────────────────
+
+const shell = {
+  exec(cmd, opts = {}) {
+    const r = runAdb(['shell', cmd], opts);
+    return r.stdout;
+  },
+  execRaw(cmd, opts = {}) {
+    return runAdb(['shell', cmd], opts);
+  },
+  // Streaming shell — returns ChildProcess
+  stream(cmd, opts = {}) {
+    const serial = opts.serial;
+    const prefix = serial ? ['-s', serial] : [];
+    return spawn('adb', [...prefix, 'shell', cmd], { stdio: 'pipe' });
+  },
+  getprop(prop, opts = {}) {
+    const r = runAdb(['shell', `getprop ${prop}`], opts);
+    return r.stdout;
+  },
+  setprop(prop, value, opts = {}) {
+    return runAdb(['shell', `setprop ${prop} ${value}`], opts);
+  },
+  allprops(opts = {}) {
+    const r = runAdb(['shell', 'getprop'], opts);
+    const result = {};
+    for (const m of r.stdout.matchAll(/\[(.+?)\]:\s*\[(.+?)\]/g)) result[m[1]] = m[2];
+    return result;
+  },
+  whoami(opts = {}) { return shell.exec('whoami', opts); },
+  uname(opts = {})  { return shell.exec('uname -a', opts); },
+  id(opts = {})     { return shell.exec('id', opts); },
+};
+
+// ─── FILE SYSTEM ─────────────────────────────────────────────────────────────
+
+const fs_ = {
+  push(local, remote, opts = {}) {
+    const syncFlag = opts.sync ? ['--sync'] : [];
+    return runAdb(['push', ...syncFlag, local, remote], opts);
+  },
+  pull(remote, local, opts = {}) {
+    return runAdb(['pull', remote, local ?? '.'], opts);
+  },
+  sync(local, opts = {}) {
+    return runAdb(['sync', local], opts);
+  },
+  ls(path, opts = {}) {
+    const r = runAdb(['shell', `ls -la "${path}"`], opts);
+    return r.stdout;
+  },
+  rm(path, opts = {}) {
+    const flags = opts.recursive ? '-rf' : '-f';
+    return runAdb(['shell', `rm ${flags} "${path}"`], opts);
+  },
+  mkdir(path, opts = {}) {
+    return runAdb(['shell', `mkdir -p "${path}"`], opts);
+  },
+  cat(path, opts = {}) {
+    return runAdb(['shell', `cat "${path}"`], opts).stdout;
+  },
+  write(remote, content, opts = {}) {
+    // Write content to a temp file and push it
+    const tmp = path.join(os.tmpdir(), `adb_write_${Date.now()}`);
+    fs.writeFileSync(tmp, content);
+    const r = fs_.push(tmp, remote, opts);
+    fs.unlinkSync(tmp);
+    return r;
+  },
+  stat(path, opts = {}) {
+    const r = runAdb(['shell', `stat "${path}"`], opts);
+    return r.stdout;
+  },
+  exists(path, opts = {}) {
+    const r = runAdb(['shell', `[ -e "${path}" ] && echo 1 || echo 0`], opts);
+    return r.stdout.trim() === '1';
+  },
+  chmod(path, mode, opts = {}) {
+    return runAdb(['shell', `chmod ${mode} "${path}"`], opts);
+  },
+  md5(path, opts = {}) {
+    const r = runAdb(['shell', `md5sum "${path}"`], opts);
+    return r.stdout.split(' ')[0];
+  },
+};
+
+// ─── PACKAGE MANAGER ─────────────────────────────────────────────────────────
+
+const pkg = {
+  install(apkPath, opts = {}) {
+    const flags = [];
+    if (opts.replace)      flags.push('-r');
+    if (opts.test)         flags.push('-t');
+    if (opts.downgrade)    flags.push('-d');
+    if (opts.grant)        flags.push('-g');
+    if (opts.instant)      flags.push('--instant');
+    if (opts.user)         flags.push('--user', String(opts.user));
+    if (opts.abi)          flags.push('--abi', opts.abi);
+    return runAdb(['install', ...flags, apkPath], opts);
+  },
+  installMultiple(apks, opts = {}) {
+    const flags = opts.replace ? ['-r'] : [];
+    return runAdb(['install-multiple', ...flags, ...apks], opts);
+  },
+  uninstall(pkg, opts = {}) {
+    const flags = opts.keepData ? ['-k'] : [];
+    return runAdb(['uninstall', ...flags, pkg], opts);
+  },
+  list(opts = {}) {
+    const flags = [];
+    if (opts.third)    flags.push('-3');
+    if (opts.system)   flags.push('-s');
+    if (opts.disabled) flags.push('-d');
+    if (opts.enabled)  flags.push('-e');
+    if (opts.user)     flags.push('--user', String(opts.user));
+    const r = runAdb(['shell', 'pm list packages', ...flags], opts);
+    return lines(r.stdout).map(l => l.replace('package:', ''));
+  },
+  path(pkg, opts = {}) {
+    const r = runAdb(['shell', `pm path ${pkg}`], opts);
+    return r.stdout.replace('package:', '').trim();
+  },
+  clear(pkg, opts = {}) {
+    return runAdb(['shell', `pm clear ${pkg}`], opts);
+  },
+  enable(pkg, opts = {}) {
+    return runAdb(['shell', `pm enable ${pkg}`], opts);
+  },
+  disable(pkg, opts = {}) {
+    return runAdb(['shell', `pm disable-user ${pkg}`], opts);
+  },
+  grant(pkg, permission, opts = {}) {
+    return runAdb(['shell', `pm grant ${pkg} ${permission}`], opts);
+  },
+  revoke(pkg, permission, opts = {}) {
+    return runAdb(['shell', `pm revoke ${pkg} ${permission}`], opts);
+  },
+  dump(pkg, opts = {}) {
+    return runAdb(['shell', `dumpsys package ${pkg}`], opts).stdout;
+  },
+  start(pkg, activity, opts = {}) {
+    return runAdb(['shell', `am start -n ${pkg}/${activity}`], opts);
+  },
+  startAction(action, opts = {}) {
+    const uri = opts.uri ? [opts.uri] : [];
+    return runAdb(['shell', `am start -a ${action}`, ...uri], opts);
+  },
+  stop(pkg, opts = {}) {
+    return runAdb(['shell', `am force-stop ${pkg}`], opts);
+  },
+  broadcast(action, opts = {}) {
+    return runAdb(['shell', `am broadcast -a ${action}`], opts);
+  },
+};
+
+// ─── LOGCAT ───────────────────────────────────────────────────────────────────
+
+const logcat = {
+  // Returns ChildProcess for streaming
+  stream(opts = {}) {
+    const args = ['logcat'];
+    if (opts.tag)    args.push('-s', opts.tag);
+    if (opts.format) args.push('-v', opts.format);
+    if (opts.buffer) args.push('-b', opts.buffer);
+    if (opts.clear)  args.push('-c');
+    if (opts.filter) args.push(opts.filter);
+    const serial = opts.serial;
+    const prefix = serial ? ['-s', serial] : [];
+    return spawn('adb', [...prefix, ...args], { stdio: 'pipe' });
+  },
+  dump(opts = {}) {
+    const args = ['logcat', '-d'];
+    if (opts.tag)    args.push('-s', opts.tag);
+    if (opts.format) args.push('-v', opts.format);
+    if (opts.lines)  args.push('-t', String(opts.lines));
+    if (opts.buffer) args.push('-b', opts.buffer);
+    return runAdb(args, opts).stdout;
+  },
+  clear(opts = {}) {
+    return runAdb(['logcat', '-c'], opts);
+  },
+  buffers(opts = {}) {
+    return runAdb(['logcat', '-g'], opts).stdout;
+  },
+};
+
+// ─── INPUT ────────────────────────────────────────────────────────────────────
+
+const input = {
+  tap(x, y, opts = {}) {
+    return runAdb(['shell', `input tap ${x} ${y}`], opts);
+  },
+  swipe(x1, y1, x2, y2, duration = 300, opts = {}) {
+    return runAdb(['shell', `input swipe ${x1} ${y1} ${x2} ${y2} ${duration}`], opts);
+  },
+  text(str, opts = {}) {
+    // Escape special chars for shell
+    const escaped = str.replace(/[ &;|<>()]/g, '\\$&').replace(/'/g, "\\'");
+    return runAdb(['shell', `input text '${escaped}'`], opts);
+  },
+  keyevent(key, opts = {}) {
+    return runAdb(['shell', `input keyevent ${key}`], opts);
+  },
+  press: {
+    home:   (opts) => input.keyevent('KEYCODE_HOME', opts),
+    back:   (opts) => input.keyevent('KEYCODE_BACK', opts),
+    menu:   (opts) => input.keyevent('KEYCODE_MENU', opts),
+    power:  (opts) => input.keyevent('KEYCODE_POWER', opts),
+    volumeUp:   (opts) => input.keyevent('KEYCODE_VOLUME_UP', opts),
+    volumeDown: (opts) => input.keyevent('KEYCODE_VOLUME_DOWN', opts),
+    enter:  (opts) => input.keyevent('KEYCODE_ENTER', opts),
+    tab:    (opts) => input.keyevent('KEYCODE_TAB', opts),
+    del:    (opts) => input.keyevent('KEYCODE_DEL', opts),
+    recent: (opts) => input.keyevent('KEYCODE_APP_SWITCH', opts),
+  },
+  screenshot(localPath, opts = {}) {
+    const tmp = '/sdcard/screenshot_tmp.png';
+    runAdb(['shell', `screencap -p ${tmp}`], opts);
+    const dest = localPath ?? `screenshot_${Date.now()}.png`;
+    runAdb(['pull', tmp, dest], opts);
+    runAdb(['shell', `rm ${tmp}`], opts);
+    return dest;
+  },
+  screenrecord(remotePath, opts = {}) {
+    const args = ['shell', 'screenrecord'];
+    if (opts.size)    args.push('--size', opts.size);
+    if (opts.bitrate) args.push('--bit-rate', String(opts.bitrate));
+    if (opts.time)    args.push('--time-limit', String(opts.time));
+    args.push(remotePath);
+    const serial = opts.serial;
+    const prefix = serial ? ['-s', serial] : [];
+    return spawn('adb', [...prefix, ...args], { stdio: 'pipe' });
+  },
+};
+
+// ─── SYSTEM ───────────────────────────────────────────────────────────────────
+
+const system = {
+  reboot(mode, opts = {}) {
+    // mode: undefined | 'bootloader' | 'recovery' | 'sideload' | 'sideload-auto-reboot'
+    const args = mode ? ['reboot', mode] : ['reboot'];
+    return runAdb(args, opts);
+  },
+  remount(opts = {}) { return runAdb(['remount'], opts); },
+  root(opts = {})    { return runAdb(['root'], opts); },
+  unroot(opts = {})  { return runAdb(['unroot'], opts); },
+  sideload(zip, opts = {}) { return runAdb(['sideload', zip], { timeout: 300000, ...opts }); },
+  bugreport(dest, opts = {}) {
+    return runAdb(['bugreport', dest ?? `bugreport_${Date.now()}.zip`], { timeout: 120000, ...opts });
+  },
+  batterystats(opts = {}) {
+    return runAdb(['shell', 'dumpsys batterystats'], opts).stdout;
+  },
+  battery(opts = {}) {
+    const r = runAdb(['shell', 'dumpsys battery'], opts).stdout;
+    const result = {};
+    for (const m of r.matchAll(/\s+(\w[\w ]+):\s+(\S+)/g)) result[m[1].trim()] = m[2].trim();
+    return result;
+  },
+  wifi(opts = {}) {
+    return runAdb(['shell', 'dumpsys wifi'], opts).stdout;
+  },
+  cpuinfo(opts = {}) {
+    return runAdb(['shell', 'dumpsys cpuinfo'], opts).stdout;
+  },
+  meminfo(pkg, opts = {}) {
+    return runAdb(['shell', `dumpsys meminfo ${pkg ?? ''}`], opts).stdout;
+  },
+  diskstats(opts = {}) {
+    return runAdb(['shell', 'dumpsys diskstats'], opts).stdout;
+  },
+  netstat(opts = {}) {
+    return runAdb(['shell', 'cat /proc/net/tcp'], opts).stdout;
+  },
+  uptime(opts = {}) {
+    return runAdb(['shell', 'uptime'], opts).stdout;
+  },
+  date(opts = {}) {
+    return runAdb(['shell', 'date'], opts).stdout;
+  },
+  setDate(dateStr, opts = {}) {
+    // dateStr: MMDDhhmmYYYY.ss
+    return runAdb(['shell', `date ${dateStr}`], opts);
+  },
+  ps(opts = {}) {
+    return runAdb(['shell', 'ps -A'], opts).stdout;
+  },
+  kill(pid, opts = {}) {
+    return runAdb(['shell', `kill ${pid}`], opts);
+  },
+  tcpip(port = 5555, opts = {}) {
+    return runAdb(['tcpip', String(port)], opts);
+  },
+  usb(opts = {}) {
+    return runAdb(['usb'], opts);
+  },
+  forward(local, remote, opts = {}) {
+    return runAdb(['forward', local, remote], opts);
+  },
+  forwardList(opts = {}) {
+    return runAdb(['forward', '--list'], opts).stdout;
+  },
+  forwardRemove(local, opts = {}) {
+    return runAdb(['forward', '--remove', local], opts);
+  },
+  forwardRemoveAll(opts = {}) {
+    return runAdb(['forward', '--remove-all'], opts);
+  },
+  reverse(remote, local, opts = {}) {
+    return runAdb(['reverse', remote, local], opts);
+  },
+  reverseList(opts = {}) {
+    return runAdb(['reverse', '--list'], opts).stdout;
+  },
+  reverseRemoveAll(opts = {}) {
+    return runAdb(['reverse', '--remove-all'], opts);
+  },
+};
+
+// ─── FASTBOOT ─────────────────────────────────────────────────────────────────
+
+const fastboot = {
+  devices() {
+    const r = runFastboot(['devices']);
+    return lines(r.stdout).map(l => {
+      const [serial, state] = l.split('\t');
+      return { serial: serial.trim(), state: (state ?? 'fastboot').trim() };
+    });
+  },
+  flash(partition, image, opts = {}) {
+    const flags = opts.slot ? ['--slot', opts.slot] : [];
+    return runFastboot(['flash', ...flags, partition, image], { timeout: 120000, ...opts });
+  },
+  flashAll(opts = {}) {
+    const flags = opts.wipe ? ['-w'] : [];
+    return runFastboot(['flashall', ...flags], { timeout: 300000, ...opts });
+  },
+  erase(partition, opts = {}) {
+    return runFastboot(['erase', partition], opts);
+  },
+  format(partition, opts = {}) {
+    return runFastboot(['format', partition], opts);
+  },
+  reboot(target, opts = {}) {
+    // target: undefined | 'bootloader' | 'recovery' | 'fastboot'
+    const args = target ? ['reboot', target] : ['reboot'];
+    return runFastboot(args, opts);
+  },
+  boot(image, opts = {}) {
+    return runFastboot(['boot', image], { timeout: 60000, ...opts });
+  },
+  update(zip, opts = {}) {
+    const flags = opts.wipe ? ['-w'] : [];
+    return runFastboot(['update', ...flags, zip], { timeout: 300000, ...opts });
+  },
+  getvar(variable, opts = {}) {
+    const r = runFastboot(['getvar', variable], opts);
+    const m = r.stderr.match(new RegExp(`${variable}:\\s*(.+)`));
+    return m ? m[1].trim() : r.stderr;
+  },
+  getvars(opts = {}) {
+    const r = runFastboot(['getvar', 'all'], opts);
+    const result = {};
+    for (const m of r.stderr.matchAll(/(\w[\w-]*):\s*(.+)/g)) result[m[1]] = m[2].trim();
+    return result;
+  },
+  oem(cmd, opts = {}) {
+    return runFastboot(['oem', cmd], opts);
+  },
+  flashing(cmd, opts = {}) {
+    return runFastboot(['flashing', cmd], opts);
+  },
+  unlock(opts = {}) {
+    return fastboot.flashing('unlock', opts);
+  },
+  lock(opts = {}) {
+    return fastboot.flashing('lock', opts);
+  },
+  unlockCritical(opts = {}) {
+    return fastboot.flashing('unlock_critical', opts);
+  },
+  lockCritical(opts = {}) {
+    return fastboot.flashing('lock_critical', opts);
+  },
+  setActive(slot, opts = {}) {
+    return runFastboot(['set_active', slot], opts);
+  },
+  createPartition(partition, size, opts = {}) {
+    return runFastboot(['create-logical-partition', partition, String(size)], opts);
+  },
+  deletePartition(partition, opts = {}) {
+    return runFastboot(['delete-logical-partition', partition], opts);
+  },
+  resizePartition(partition, size, opts = {}) {
+    return runFastboot(['resize-logical-partition', partition, String(size)], opts);
+  },
+  wipeSuper(misc, opts = {}) {
+    return runFastboot(['wipe-super', misc ?? ''], opts);
+  },
+  stage(file, opts = {}) {
+    return runFastboot(['stage', file], opts);
+  },
+  getStaged(file, opts = {}) {
+    return runFastboot(['get_staged', file], opts);
+  },
+  version(opts = {}) {
+    const r = runFastboot(['--version'], opts);
+    return r.stdout || r.stderr;
+  },
+};
+
+// ─── ADB BACKUP / RESTORE ────────────────────────────────────────────────────
+
+const backup = {
+  create(dest, opts = {}) {
+    const args = ['backup'];
+    if (opts.apk)     args.push('-apk');
+    if (opts.shared)  args.push('-shared');
+    if (opts.system)  args.push('-system');
+    if (opts.all)     args.push('-all');
+    if (opts.packages) args.push(...opts.packages);
+    args.push('-f', dest ?? `backup_${Date.now()}.ab`);
+    return runAdb(args, { timeout: 300000, ...opts });
+  },
+  restore(src, opts = {}) {
+    return runAdb(['restore', src], { timeout: 300000, ...opts });
+  },
+};
+
+// ─── JDWP / PROFILING ────────────────────────────────────────────────────────
+
+const debug = {
+  jdwp(opts = {}) {
+    return runAdb(['jdwp'], opts).stdout;
+  },
+  trackJdwp(opts = {}) {
+    const serial = opts.serial;
+    const prefix = serial ? ['-s', serial] : [];
+    return spawn('adb', [...prefix, 'track-jdwp'], { stdio: 'pipe' });
+  },
+  startServer(opts = {}) { return server.start(); },
+  killServer(opts = {})  { return server.kill(); },
+};
+
+// ─── CONTENT PROVIDER ────────────────────────────────────────────────────────
+
+const content = {
+  query(uri, opts = {}) {
+    const where = opts.where ? `--where "${opts.where}"` : '';
+    return runAdb(['shell', `content query --uri ${uri} ${where}`], opts).stdout;
+  },
+  insert(uri, values, opts = {}) {
+    const vals = Object.entries(values).map(([k,v]) => `--bind ${k}:s:${v}`).join(' ');
+    return runAdb(['shell', `content insert --uri ${uri} ${vals}`], opts);
+  },
+  update(uri, values, opts = {}) {
+    const vals = Object.entries(values).map(([k,v]) => `--bind ${k}:s:${v}`).join(' ');
+    const where = opts.where ? `--where "${opts.where}"` : '';
+    return runAdb(['shell', `content update --uri ${uri} ${vals} ${where}`], opts);
+  },
+  delete(uri, opts = {}) {
+    const where = opts.where ? `--where "${opts.where}"` : '';
+    return runAdb(['shell', `content delete --uri ${uri} ${where}`], opts);
+  },
+};
+
+// ─── MDNS ─────────────────────────────────────────────────────────────────────
+
+const mdns = {
+  check(opts = {})  { return runAdb(['mdns', 'check'], opts); },
+  services(opts = {}){ return runAdb(['mdns', 'services'], opts).stdout; },
+};
+
+// ─── EXPORTS ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  kitdef: {
+    server,
+    devices,
+    shell,
+    fs: fs_,
+    pkg,
+    logcat,
+    input,
+    system,
+    fastboot,
+    backup,
+    debug,
+    content,
+    mdns,
+    // Low-level runner for anything not covered
+    runAdb,
+    runFastboot,
+  }
+};