serve-emul 0.0.4

package/scripts/fetch-scrcpy.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+import { mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+export const SCRCPY_VERSION = "4.0";
+const URL = `https://github.com/Genymobile/scrcpy/releases/download/v${SCRCPY_VERSION}/scrcpy-server-v${SCRCPY_VERSION}`;
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VENDOR_DIR = join(__dirname, "..", "vendor");
+export const SCRCPY_SERVER_PATH = join(VENDOR_DIR, `scrcpy-server-v${SCRCPY_VERSION}`);
+
+export async function ensureScrcpyServer(): Promise<string> {
+  if (existsSync(SCRCPY_SERVER_PATH)) return SCRCPY_SERVER_PATH;
+  await mkdir(VENDOR_DIR, { recursive: true });
+  console.log(`Downloading scrcpy-server v${SCRCPY_VERSION}…`);
+  const res = await fetch(URL);
+  if (!res.ok) throw new Error(`Failed to download ${URL}: ${res.status} ${res.statusText}`);
+  const buf = new Uint8Array(await res.arrayBuffer());
+  await Bun.write(SCRCPY_SERVER_PATH, buf);
+  console.log(`Saved ${SCRCPY_SERVER_PATH} (${buf.byteLength} bytes)`);
+  return SCRCPY_SERVER_PATH;
+}
+
+if (import.meta.main) {
+  await ensureScrcpyServer();
+}

package/scripts/release.ts

@@ -0,0 +1,136 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+
+type Bump = "patch" | "minor" | "major";
+
+const packageDir = resolve(import.meta.dir, "..");
+const packageJsonPath = resolve(packageDir, "package.json");
+const changelogPath = resolve(packageDir, "CHANGELOG.md");
+
+const args = Bun.argv.slice(2);
+const bumpArg = args.find((arg) => !arg.startsWith("--"));
+const dryRun = args.includes("--dry-run");
+
+function usage(): never {
+  console.error("Usage: bun run release <patch|minor|major|x.y.z> [--dry-run]");
+  process.exit(1);
+}
+
+function readJson(path: string): { version?: unknown; [key: string]: unknown } {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function assertVersion(version: unknown): string {
+  if (typeof version !== "string" || !/^\d+\.\d+\.\d+$/.test(version)) {
+    throw new Error(`Expected a plain semver version, got ${String(version)}`);
+  }
+  return version;
+}
+
+function nextVersion(current: string, bump: string): string {
+  if (/^\d+\.\d+\.\d+$/.test(bump)) return bump;
+
+  if (!["patch", "minor", "major"].includes(bump)) usage();
+
+  const [major, minor, patch] = current.split(".").map((part) => Number(part));
+  switch (bump as Bump) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+function runGit(args: string[]): string | null {
+  const result = spawnSync("git", args, {
+    cwd: packageDir,
+    encoding: "utf8",
+  });
+
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+
+function latestTag(): string | null {
+  const tag = runGit(["describe", "--tags", "--abbrev=0", "--match", "v[0-9]*"]);
+  return tag && tag.length > 0 ? tag : null;
+}
+
+function commitSubjectsSince(tag: string | null): string[] {
+  const range = tag ? `${tag}..HEAD` : "HEAD";
+  const output = runGit(["log", "--format=%s", "--no-merges", range]);
+  if (!output) return [];
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function changelogEntry(version: string, subjects: string[]): string {
+  const date = new Date().toISOString().slice(0, 10);
+  const lines = subjects.length > 0 ? subjects : ["Release maintenance."];
+
+  return [
+    `## ${version} - ${date}`,
+    "",
+    "### Changed",
+    "",
+    ...lines.map((line) => `- ${line}`),
+    "",
+  ].join("\n");
+}
+
+function prependChangelog(version: string, entry: string): string {
+  const current = readFileSync(changelogPath, "utf8");
+
+  if (current.includes(`## ${version} - `)) {
+    throw new Error(`CHANGELOG.md already has an entry for ${version}`);
+  }
+
+  const firstRelease = current.match(/^## \d+\.\d+\.\d+ - /m);
+  if (!firstRelease?.index) {
+    return `${current.trimEnd()}\n\n${entry}`;
+  }
+
+  return `${current.slice(0, firstRelease.index)}${entry}\n${current.slice(firstRelease.index)}`;
+}
+
+if (!bumpArg) usage();
+
+const packageJson = readJson(packageJsonPath);
+const currentVersion = assertVersion(packageJson.version);
+const version = nextVersion(currentVersion, bumpArg);
+
+if (version === currentVersion) {
+  throw new Error(`Version is already ${version}`);
+}
+
+packageJson.version = version;
+const tag = latestTag();
+const subjects = commitSubjectsSince(tag);
+const nextChangelog = prependChangelog(version, changelogEntry(version, subjects));
+
+console.log(`${currentVersion} -> ${version}`);
+if (tag) console.log(`Changes since ${tag}`);
+if (subjects.length === 0) console.log("No commit subjects found; using a maintenance placeholder.");
+
+if (dryRun) {
+  console.log("\nDry run only. No files changed.");
+  process.exit(0);
+}
+
+writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+writeFileSync(changelogPath, nextChangelog);
+
+console.log("\nUpdated:");
+console.log(`- ${packageJsonPath}`);
+console.log(`- ${changelogPath}`);
+console.log("\nNext:");
+console.log("1. Review CHANGELOG.md and edit sections if needed.");
+console.log("2. Run: bun run check");
+console.log(`3. Commit: git commit -m "Release v${version}" -- packages/serve-emul/package.json packages/serve-emul/CHANGELOG.md`);
+console.log(`4. Tag: git tag v${version}`);
+console.log("5. Publish from a clean tree: npm publish packages/serve-emul");

package/src/accessibility.ts

@@ -0,0 +1,88 @@
+import { spawnSync } from "node:child_process";
+
+export type AccessibilityNode = {
+  id: string;
+  text: string;
+  contentDescription: string;
+  resourceId: string;
+  className: string;
+  packageName: string;
+  clickable: boolean;
+  enabled: boolean;
+  bounds: { left: number; top: number; right: number; bottom: number };
+};
+
+export type AccessibilitySnapshot = {
+  ok: true;
+  capturedAt: string;
+  nodes: AccessibilityNode[];
+};
+
+function decodeXml(value: string): string {
+  return value
+    .replace(/"/g, "\"")
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+function attrsFor(node: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  for (const match of node.matchAll(/\s([a-zA-Z0-9_-]+)="([^"]*)"/g)) {
+    attrs[match[1]!] = decodeXml(match[2] ?? "");
+  }
+  return attrs;
+}
+
+function parseBounds(value: string | undefined) {
+  const match = value?.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (!match) return null;
+  return {
+    left: Number(match[1]),
+    top: Number(match[2]),
+    right: Number(match[3]),
+    bottom: Number(match[4]),
+  };
+}
+
+function boolAttr(value: string | undefined): boolean {
+  return value === "true";
+}
+
+function dumpXml(serial: string): string {
+  const path = `/sdcard/window-${Date.now()}.xml`;
+  const command = `uiautomator dump ${path} >/dev/null && cat ${path} && rm ${path}`;
+  const result = spawnSync("adb", ["-s", serial, "shell", "sh", "-c", command], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 8_000,
+  });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || "uiautomator dump failed").trim());
+  }
+  return result.stdout;
+}
+
+export function getAccessibilitySnapshot(serial: string): AccessibilitySnapshot {
+  const xml = dumpXml(serial);
+  const nodes: AccessibilityNode[] = [];
+  let index = 0;
+  for (const match of xml.matchAll(/<node\b[^>]*>/g)) {
+    const attrs = attrsFor(match[0]);
+    const bounds = parseBounds(attrs.bounds);
+    if (!bounds || bounds.right <= bounds.left || bounds.bottom <= bounds.top) continue;
+    nodes.push({
+      id: `${index++}`,
+      text: attrs.text ?? "",
+      contentDescription: attrs["content-desc"] ?? "",
+      resourceId: attrs["resource-id"] ?? "",
+      className: attrs.class ?? "",
+      packageName: attrs.package ?? "",
+      clickable: boolAttr(attrs.clickable),
+      enabled: boolAttr(attrs.enabled),
+      bounds,
+    });
+  }
+  return { ok: true, capturedAt: new Date().toISOString(), nodes };
+}

package/src/adb.ts

@@ -0,0 +1,209 @@
+import { spawn, spawnSync } from "node:child_process";
+
+export type Device = { serial: string; state: string };
+export type OrientationMode = "auto" | "portrait" | "landscape";
+export type NightMode = "auto" | "dark" | "light";
+export type OrientationStatus = {
+  mode: "free" | "lock" | "unknown";
+  rotation: number | null;
+  orientation: OrientationMode | "unknown";
+  raw: string;
+};
+export type FontScaleStatus = {
+  scale: number;
+  raw: string;
+};
+export type NightModeStatus = {
+  mode: NightMode | "unknown";
+  raw: string;
+};
+export type NetworkRadioStatus = "enabled" | "disabled" | "unknown";
+export type NetworkStatus = {
+  enabled: boolean | null;
+  wifi: NetworkRadioStatus;
+  mobileData: NetworkRadioStatus;
+  raw: {
+    wifi: string;
+    mobileData: string;
+  };
+};
+
+export function listAllDevices(): Device[] {
+  const r = spawnSync("adb", ["devices"], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`adb devices failed: ${r.stderr}`);
+  return r.stdout
+    .split("\n")
+    .slice(1)
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .map((l) => {
+      const [serial, state] = l.split(/\s+/);
+      return { serial, state };
+    });
+}
+
+export function listDevices(): Device[] {
+  return listAllDevices().filter((d) => d.state === "device");
+}
+
+export function pickDevice(explicit?: string): string {
+  if (explicit) return explicit;
+  const devices = listDevices();
+  if (devices.length === 0) throw new Error("No booted Android device found. Start an emulator or attach a device.");
+  if (devices.length > 1)
+    throw new Error(
+      `Multiple devices online (${devices.map((d) => d.serial).join(", ")}). Pass -s <serial>.`,
+    );
+  return devices[0].serial;
+}
+
+export function screencapPng(serial: string): Buffer {
+  const r = spawnSync("adb", ["-s", serial, "exec-out", "screencap", "-p"], {
+    encoding: "buffer",
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (r.status !== 0) throw new Error(`screencap failed: ${r.stderr.toString()}`);
+  return r.stdout;
+}
+
+export function shell(serial: string, cmd: string[]): void {
+  const r = spawnSync("adb", ["-s", serial, "shell", ...cmd], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`adb shell ${cmd.join(" ")} failed: ${r.stderr}`);
+}
+
+export function shellSpawn(serial: string, cmd: string[]) {
+  return spawn("adb", ["-s", serial, "shell", ...cmd]);
+}
+
+export function getDeviceSize(serial: string): { width: number; height: number } {
+  const r = spawnSync("adb", ["-s", serial, "shell", "wm", "size"], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`wm size failed: ${r.stderr}`);
+  const m = r.stdout.match(/(\d+)x(\d+)/);
+  if (!m) throw new Error(`Could not parse wm size output: ${r.stdout}`);
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+
+function orientationFromRotation(mode: "free" | "lock" | "unknown", rotation: number | null): OrientationStatus["orientation"] {
+  if (mode === "free") return "auto";
+  if (rotation === 0 || rotation === 2) return "portrait";
+  if (rotation === 1 || rotation === 3) return "landscape";
+  return "unknown";
+}
+
+export function getUserRotation(serial: string): OrientationStatus {
+  const r = spawnSync("adb", ["-s", serial, "shell", "cmd", "window", "user-rotation"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) throw new Error(`cmd window user-rotation failed: ${r.stderr}`);
+  const raw = r.stdout.trim();
+  const match = raw.match(/^(free|lock)(?:\s+(\d+))?$/);
+  if (!match) {
+    return { mode: "unknown", rotation: null, orientation: "unknown", raw };
+  }
+  const mode = match[1] as "free" | "lock";
+  const rotation = match[2] === undefined ? null : Number(match[2]);
+  return { mode, rotation, orientation: orientationFromRotation(mode, rotation), raw };
+}
+
+export function setUserRotation(serial: string, orientation: OrientationMode): OrientationStatus {
+  const args =
+    orientation === "auto"
+      ? ["cmd", "window", "user-rotation", "free"]
+      : ["cmd", "window", "user-rotation", "lock", orientation === "portrait" ? "0" : "1"];
+  const r = spawnSync("adb", ["-s", serial, "shell", ...args], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`adb shell ${args.join(" ")} failed: ${r.stderr}`);
+  return getUserRotation(serial);
+}
+
+export function getFontScale(serial: string): FontScaleStatus {
+  const r = spawnSync("adb", ["-s", serial, "shell", "settings", "get", "system", "font_scale"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) throw new Error(`settings get system font_scale failed: ${r.stderr}`);
+  const raw = r.stdout.trim();
+  const scale = Number(raw);
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new Error(`Could not parse font_scale output: ${r.stdout}`);
+  }
+  return { scale, raw };
+}
+
+export function setFontScale(serial: string, scale: number): FontScaleStatus {
+  if (!Number.isFinite(scale) || scale < 0.7 || scale > 2) {
+    throw new Error("font scale must be between 0.7 and 2.0");
+  }
+  const normalized = scale.toFixed(2).replace(/0+$/, "").replace(/\.$/, "");
+  const args = ["settings", "put", "system", "font_scale", normalized];
+  const r = spawnSync("adb", ["-s", serial, "shell", ...args], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`adb shell ${args.join(" ")} failed: ${r.stderr}`);
+  return getFontScale(serial);
+}
+
+function nightModeFromRaw(raw: string): NightMode | "unknown" {
+  const match = raw.match(/Night mode:\s*(\S+)/i);
+  const value = (match?.[1] ?? raw).trim().toLowerCase();
+  if (value === "yes") return "dark";
+  if (value === "no") return "light";
+  if (value === "auto") return "auto";
+  return "unknown";
+}
+
+export function getNightMode(serial: string): NightModeStatus {
+  const r = spawnSync("adb", ["-s", serial, "shell", "cmd", "uimode", "night"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) throw new Error(`cmd uimode night failed: ${r.stderr}`);
+  const raw = r.stdout.trim();
+  return { mode: nightModeFromRaw(raw), raw };
+}
+
+export function setNightMode(serial: string, mode: NightMode): NightModeStatus {
+  const value = mode === "dark" ? "yes" : mode === "light" ? "no" : "auto";
+  const args = ["cmd", "uimode", "night", value];
+  const r = spawnSync("adb", ["-s", serial, "shell", ...args], { encoding: "utf8" });
+  if (r.status !== 0) throw new Error(`adb shell ${args.join(" ")} failed: ${r.stderr}`);
+  return getNightMode(serial);
+}
+
+function globalSetting(serial: string, name: string): string {
+  const r = spawnSync("adb", ["-s", serial, "shell", "settings", "get", "global", name], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) throw new Error(`settings get global ${name} failed: ${r.stderr}`);
+  return r.stdout.trim();
+}
+
+function radioStatusFromSetting(raw: string): NetworkRadioStatus {
+  if (raw === "1") return "enabled";
+  if (raw === "0") return "disabled";
+  return "unknown";
+}
+
+export function getNetworkStatus(serial: string): NetworkStatus {
+  const wifiRaw = globalSetting(serial, "wifi_on");
+  const mobileDataRaw = globalSetting(serial, "mobile_data");
+  const wifi = radioStatusFromSetting(wifiRaw);
+  const mobileData = radioStatusFromSetting(mobileDataRaw);
+  const radios = [wifi, mobileData];
+  const knownRadios = radios.filter((radio) => radio !== "unknown");
+  const enabled = knownRadios.length === 0 ? null : knownRadios.some((radio) => radio === "enabled");
+  return {
+    enabled,
+    wifi,
+    mobileData,
+    raw: {
+      wifi: wifiRaw,
+      mobileData: mobileDataRaw,
+    },
+  };
+}
+
+export function setNetworkEnabled(serial: string, enabled: boolean): NetworkStatus {
+  const action = enabled ? "enable" : "disable";
+  for (const service of ["wifi", "data"]) {
+    const args = ["svc", service, action];
+    const r = spawnSync("adb", ["-s", serial, "shell", ...args], { encoding: "utf8" });
+    if (r.status !== 0) throw new Error(`adb shell ${args.join(" ")} failed: ${r.stderr}`);
+  }
+  return getNetworkStatus(serial);
+}

package/src/app-info.ts

@@ -0,0 +1,114 @@
+import { spawnSync } from "node:child_process";
+
+export type ForegroundApp = {
+  packageName: string | null;
+  activity: string | null;
+  pid: number | null;
+  label: string | null;
+  versionName: string | null;
+  versionCode: string | null;
+  debuggable: boolean | null;
+};
+
+function adbShell(serial: string, args: string[], timeout = 4_000): string {
+  const result = spawnSync("adb", ["-s", serial, "shell", ...args], {
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+    timeout,
+  });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || `adb shell ${args.join(" ")} failed`).trim());
+  }
+  return result.stdout;
+}
+
+function firstMatch(text: string, patterns: RegExp[]): RegExpMatchArray | null {
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match) return match;
+  }
+  return null;
+}
+
+function parseComponent(value: string): { packageName: string; activity: string | null } | null {
+  const clean = value.trim().replace(/^\{|\}$/g, "");
+  const component = clean.split(/\s+/).find((part) => part.includes("/")) ?? clean;
+  const [packageName, activityRaw] = component.split("/", 2);
+  if (!packageName || !/^[A-Za-z0-9_.]+$/.test(packageName)) return null;
+  const activity = activityRaw
+    ? activityRaw.startsWith(".")
+      ? `${packageName}${activityRaw}`
+      : activityRaw
+    : null;
+  return { packageName, activity };
+}
+
+function foregroundComponent(serial: string): { packageName: string; activity: string | null } | null {
+  const windowDump = adbShell(serial, ["dumpsys", "window"], 5_000);
+  const windowMatch = firstMatch(windowDump, [
+    /mCurrentFocus=Window\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\}/,
+    /mFocusedApp=ActivityRecord\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\s/,
+    /mInputMethodTarget=Window\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\}/,
+  ]);
+  if (windowMatch?.[1]) {
+    const parsed = parseComponent(windowMatch[1]);
+    if (parsed) return parsed;
+  }
+
+  const activityDump = adbShell(serial, ["dumpsys", "activity", "activities"], 5_000);
+  const activityMatch = firstMatch(activityDump, [
+    /topResumedActivity=ActivityRecord\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\s/,
+    /mResumedActivity: ActivityRecord\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\s/,
+    /ResumedActivity: ActivityRecord\{[^}]*\s([A-Za-z0-9_.]+\/[A-Za-z0-9_.$]+)\s/,
+  ]);
+  return activityMatch?.[1] ? parseComponent(activityMatch[1]) : null;
+}
+
+function packagePid(serial: string, packageName: string): number | null {
+  try {
+    const out = adbShell(serial, ["pidof", packageName], 2_000).trim();
+    const first = out.split(/\s+/)[0];
+    const pid = first ? Number(first) : NaN;
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function packageDetails(serial: string, packageName: string) {
+  try {
+    const dump = adbShell(serial, ["dumpsys", "package", packageName], 5_000);
+    const versionName = dump.match(/versionName=([^\s]+)/)?.[1] ?? null;
+    const versionCode = dump.match(/versionCode=(\d+)/)?.[1] ?? null;
+    const label =
+      dump.match(/application-label(?:-[a-zA-Z]+)?:'([^']+)'/)?.[1] ??
+      dump.match(/labelRes=0x[0-9a-fA-F]+ nonLocalizedLabel=([^\n]+)/)?.[1]?.trim() ??
+      null;
+    const debuggable = /pkgFlags=\[[^\]]*\bDEBUGGABLE\b/.test(dump) || /\bDEBUGGABLE\b/.test(dump);
+    return { label, versionName, versionCode, debuggable };
+  } catch {
+    return { label: null, versionName: null, versionCode: null, debuggable: null };
+  }
+}
+
+export function getForegroundApp(serial: string): ForegroundApp {
+  const component = foregroundComponent(serial);
+  if (!component) {
+    return {
+      packageName: null,
+      activity: null,
+      pid: null,
+      label: null,
+      versionName: null,
+      versionCode: null,
+      debuggable: null,
+    };
+  }
+  const details = packageDetails(serial, component.packageName);
+  return {
+    packageName: component.packageName,
+    activity: component.activity,
+    pid: packagePid(serial, component.packageName),
+    ...details,
+  };
+}