@androperator/emulator 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Action Launcher Pty Ltd
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+androperator-emulator includes code extracted and adapted from Androperator
+https://github.com/androperator/androperator
+Source revision: 43210a51315ad9e0badd80311bf686596a46b154
+Licensed under the Apache License, Version 2.0. See LICENSE.
+Source paths, ported tests and modifications are recorded in docs/provenance.md.

package/README.md

@@ -0,0 +1,110 @@
+# @androperator/emulator
+
+Android SDK emulator lifecycle library and JSON CLI, extracted from Androperator.
+Requires Node.js 24+, Android SDK tools (`adb`, `emulator`, `sdkmanager`,
+`avdmanager`) and the Java runtime required by your SDK tools. macOS and Linux
+are the initial targets. No Node runtime or native ADBuddy UI is bundled.
+
+## Build and install locally
+
+```sh
+npm ci
+npm run build
+npm test
+npm pack
+npm install -g ./androperator-emulator-0.1.0.tgz
+androperator-emulator --version
+```
+
+The package is not yet published. Consumers can install the packed archive without
+this checkout or development dependencies. After publication, install with
+`npm install -g @androperator/emulator`.
+The executable remains `androperator-emulator`. See [provenance](docs/provenance.md)
+for source history and [plan](docs/plan.md) for follow-on work.
+
+## CLI
+
+```sh
+androperator-emulator list
+androperator-emulator inspect My_AVD
+androperator-emulator status
+androperator-emulator download 'system-images;android-35;google_apis;arm64-v8a'
+androperator-emulator create My_AVD \
+  --image 'system-images;android-35;google_apis;arm64-v8a' \
+  --profile pixel_7 --storage-size 12G
+androperator-emulator start My_AVD --headless
+androperator-emulator wait emulator-5554 --timeout-ms 180000
+androperator-emulator stop My_AVD
+androperator-emulator delete My_AVD
+```
+
+`--help` describes all commands. `--json` or `--output json` can appear before or
+after a command; JSON is always the default. Each invocation writes exactly one
+JSON document on stdout. SDK output is captured, not mixed into the response.
+Exit codes: 0 success, 1 operation failure, 2 invalid command arguments.
+
+```json
+{"protocolVersion":1,"ok":true,"data":{"devices":[]}}
+```
+
+Failures have `ok: false` and `error: {code, message, details?}` instead of `data`.
+The `--version` response identifies the package and machine protocol without SDK
+access. ADBuddy can probe this command after finding the separately installed
+executable; native discovery and installation UI are separate work.
+
+Create requires explicit image, hardware profile and storage capacity. Existing
+AVDs are refused unless `--replace` is supplied, which discards existing data.
+Replacement and deletion refuse running AVDs and fail closed if ADB discovery
+fails or an emulator is offline/unauthorized. These are point-in-time checks;
+callers must serialize concurrent lifecycle changes for the same AVD.
+
+Installed-image detection accepts both the legacy semicolon-and-pipe table and
+the Android CLI shim's slash-separated package IDs and whitespace columns.
+
+Downloads do not automatically accept SDK licenses. Add `--accept-licenses` to
+`download` or `create` only to authorize `sdkmanager --licenses` acceptance for
+all outstanding SDK licenses. Otherwise licenses must already be accepted.
+
+`start` waits for registration (60 seconds) and both Android boot properties
+(180 seconds). `stop` requests emulator shutdown; it does not wait for process
+exit. Launch disables snapshot loading, but does not disable snapshot saving.
+It does not change guest developer settings.
+
+`storage <name> --storage-size 24G` updates the configured `/data` capacity only.
+It does not resize existing userdata, guarantee free space, or impose a host disk
+quota. Use a fresh AVD when changing capacity. Dynamic qcow2 allocation and
+snapshot-free storage are follow-on capabilities.
+
+## Library
+
+```js
+import { getDefaultRuntimeConfig, createAvd, listConfiguredAvds } from '@androperator/emulator';
+const config = getDefaultRuntimeConfig();
+await createAvd(config, {
+  name: 'My_AVD',
+  systemImage: 'system-images;android-35;google_apis;arm64-v8a',
+  deviceProfile: 'pixel_7',
+  dataPartitionSize: '12G',
+});
+console.log(await listConfiguredAvds(config));
+```
+
+The root export includes inspection, running discovery, installation, creation,
+storage configuration, start/stop/delete, registration/boot waits, host-tool
+checks and process/runtime contracts. `startAvd` is asynchronous and confirms
+spawn only; use the wait functions to confirm readiness. SDK operation failures
+use `{code, message, details?}`; filesystem and process errors may be native
+Errors. Inject a `ProcessRunner` for tests or an `adb` callback for consumer
+logging. The library contains no Androperator compatibility or provisioning policy.
+
+Explicit runtime paths override defaults. CLI environment overrides are
+`ADB_PATH`, `EMULATOR_PATH`, `SDKMANAGER_PATH`, `AVDMANAGER_PATH`. Discovery checks
+`ANDROID_HOME`, `ANDROID_SDK_ROOT`, standard macOS/Linux SDK roots, then PATH.
+AVDs use `ANDROID_AVD_HOME` or `~/.android/avd`; locator `.ini` entries with
+`path` or `path.rel` can redirect each AVD's config. Other Android home conventions
+are not yet supported. Export `ANDROID_AVD_HOME` consistently for those setups.
+
+## Tests and releases
+
+GitHub Actions builds, tests and checks a packed installation on Linux and macOS.
+See [releasing](docs/releasing.md) for the first publication and subsequent releases.

package/dist/adbClient.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeConfig } from "./runtimeConfig.js";
+export declare function runAdb(config: RuntimeConfig, args: string[], options?: {
+    timeoutMs?: number;
+}): Promise<import("./processRunner.js").ProcessResult>;
+export interface DeviceInfo {
+    serial: string;
+    state: string;
+}
+export declare function listDevices(config: RuntimeConfig): Promise<DeviceInfo[]>;
+//# sourceMappingURL=adbClient.d.ts.map

package/dist/adbClient.js

@@ -0,0 +1,15 @@
+import { ERROR_CODES } from "./errors.js";
+export function runAdb(config, args, options) {
+    const deviceArgs = config.deviceId ? ["-s", config.deviceId, ...args] : args;
+    return config.adb ? config.adb(deviceArgs, options) : config.runner.run(config.adbPath, deviceArgs, options);
+}
+export async function listDevices(config) {
+    const result = await runAdb({ ...config, deviceId: undefined }, ["devices"]);
+    if (result.code !== 0 || !result.stdout.includes("List of devices attached")) {
+        throw { code: ERROR_CODES.ADB_QUERY_FAILED, message: result.stderr || "Failed to query adb devices; verify adb is available" };
+    }
+    return result.stdout.split("List of devices attached")[1].split("\n")
+        .map((line) => line.trim()).filter(Boolean)
+        .map((line) => { const [serial, state] = line.split(/\s+/); return { serial, state: state ?? "unknown" }; });
+}
+//# sourceMappingURL=adbClient.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { getDefaultRuntimeConfig, listRunningEmulators, listConfiguredAvds, inspectConfiguredAvd, createAvd, startAvd, stopAvd, deleteAvd, waitForBootCompletion, waitForEmulatorRegistration, ensureSystemImageInstalled, setAvdDataPartitionSize } from "./index.js";
+const commands = {
+    list: "list", inspect: "inspect <name>", status: "status",
+    download: "download <system-image> [--accept-licenses]",
+    create: "create <name> --image <system-image> --profile <hardware-profile> --storage-size <12G> [--replace] [--accept-licenses]",
+    start: "start <name> [--headless]", stop: "stop <name>", delete: "delete <name>",
+    wait: "wait <serial> [--timeout-ms <180000>]", storage: "storage <name> --storage-size <12G>",
+};
+function usage(message) {
+    throw { code: "USAGE", message, details: { commands, example: "androperator-emulator inspect My_AVD" } };
+}
+async function main() {
+    const { values, positionals } = parseArgs({ allowPositionals: true, strict: true, options: {
+            help: { type: "boolean", short: "h" }, version: { type: "boolean" }, json: { type: "boolean" },
+            output: { type: "string" }, image: { type: "string" }, profile: { type: "string" },
+            "storage-size": { type: "string" }, replace: { type: "boolean" },
+            "accept-licenses": { type: "boolean" }, headless: { type: "boolean" }, "timeout-ms": { type: "string" },
+        } });
+    if (values.output !== undefined && values.output !== "json")
+        usage("--output supports json; for example --output json list");
+    if (values.version) {
+        const { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return { name, version, protocolVersion: 1 };
+    }
+    if (values.help)
+        return { commands, output: "One JSON envelope on stdout; exit 0 success, 1 operation failure, 2 usage error" };
+    const [command, target, ...extra] = positionals;
+    if (!Object.hasOwn(commands, command ?? ""))
+        usage(`Unknown or missing command: ${command ?? ""}; use --help`);
+    const needsTarget = !["list", "status"].includes(command);
+    if (extra.length || (needsTarget ? target === undefined || target.trim() === "" : target !== undefined))
+        usage(`Use ${commands[command]}`);
+    const allowed = {
+        create: ["image", "profile", "storage-size", "replace", "accept-licenses"],
+        download: ["accept-licenses"], start: ["headless"], wait: ["timeout-ms"], storage: ["storage-size"],
+    };
+    for (const flag of Object.keys(values)) {
+        if (!["json", "output", ...(allowed[command] ?? [])].includes(flag))
+            usage(`--${flag} is not valid for ${command}; use ${commands[command]}`);
+    }
+    function required(flag) {
+        const value = values[flag];
+        if (value === undefined || !value.trim())
+            usage(`--${flag} requires a nonblank value; use ${commands[command]}`);
+        return value;
+    }
+    const config = getDefaultRuntimeConfig();
+    switch (command) {
+        case "status": return { devices: await listRunningEmulators(config) };
+        case "list": {
+            const running = await listRunningEmulators(config);
+            return { avds: await listConfiguredAvds(config, new Set(running.map((item) => item.avdName))) };
+        }
+        case "inspect": {
+            const running = await listRunningEmulators(config);
+            return inspectConfiguredAvd(target, new Set(running.map((item) => item.avdName)));
+        }
+        case "download":
+            await ensureSystemImageInstalled(config, target, { acceptLicenses: values["accept-licenses"] });
+            return { systemImage: target, installed: true };
+        case "create":
+            await createAvd(config, { name: target, systemImage: required("image"), deviceProfile: required("profile"),
+                dataPartitionSize: required("storage-size"), replace: values.replace, acceptLicenses: values["accept-licenses"] });
+            return inspectConfiguredAvd(target);
+        case "start": {
+            if (!(await inspectConfiguredAvd(target)).exists)
+                throw { code: "EMULATOR_NOT_FOUND", message: `AVD ${target} not found; use list` };
+            if ((await listRunningEmulators(config)).some((item) => item.avdName === target))
+                throw { code: "EMULATOR_ALREADY_RUNNING", message: `AVD ${target} is already running; use status` };
+            await startAvd(config, target, values.headless ? ["-no-window", "-no-audio"] : []);
+            const serial = await waitForEmulatorRegistration(config, target);
+            await waitForBootCompletion(config, serial);
+            return { avdName: target, serial, booted: true };
+        }
+        case "wait": {
+            const timeout = values["timeout-ms"];
+            if (timeout !== undefined && (!/^[1-9]\d*$/.test(timeout) || !Number.isSafeInteger(Number(timeout))))
+                usage("--timeout-ms must be a positive integer, for example 180000");
+            if (!/^emulator-\d+$/.test(target))
+                usage("wait requires an emulator serial, for example emulator-5554");
+            await waitForBootCompletion(config, target, timeout === undefined ? undefined : Number(timeout));
+            return { serial: target, booted: true };
+        }
+        case "stop":
+            await stopAvd(config, target);
+            return { avdName: target, stopped: true };
+        case "delete":
+            await deleteAvd(config, target);
+            return { avdName: target, deleted: true };
+        case "storage":
+            await setAvdDataPartitionSize(target, required("storage-size"));
+            return { avdName: target, configured: true, resized: false };
+        default: return usage("Use --help");
+    }
+}
+try {
+    const data = await main();
+    console.log(JSON.stringify({ protocolVersion: 1, ok: true, data }));
+}
+catch (error) {
+    const value = error;
+    const isUsage = value.code === "USAGE" || value.code?.startsWith("ERR_PARSE_ARGS");
+    console.log(JSON.stringify({ protocolVersion: 1, ok: false, error: {
+            code: isUsage ? "USAGE" : value.code ?? "EMULATOR_ERROR",
+            message: value.message ?? String(error), ...(value.details === undefined ? {} : { details: value.details }),
+        } }));
+    process.exitCode = isUsage ? 2 : 1;
+}
+//# sourceMappingURL=cli.js.map

package/dist/configuredAvds.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeConfig } from "./runtimeConfig.js";
+import type { ConfiguredAvd } from "./types.js";
+export declare function getAvdRoot(): string;
+export declare function inspectConfiguredAvd(name: string, runningNames?: Set<string>): Promise<ConfiguredAvd>;
+export declare function listConfiguredAvds(config: RuntimeConfig, runningNames?: Set<string>): Promise<ConfiguredAvd[]>;
+export declare function getAvdConfigPath(name: string): Promise<string>;
+//# sourceMappingURL=configuredAvds.d.ts.map

package/dist/configuredAvds.js

@@ -0,0 +1,135 @@
+// Ported from Androperator; adaptations recorded in docs/provenance.md.
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, isAbsolute, resolve, dirname } from "node:path";
+import { runAndroidSdkTool } from "./hostToolClient.js";
+import { validateAvdName } from "./validation.js";
+export function getAvdRoot() {
+    const androidAvdHome = process.env.ANDROID_AVD_HOME;
+    if (typeof androidAvdHome === "string" && androidAvdHome.trim().length > 0) {
+        return androidAvdHome.trim();
+    }
+    return join(homedir(), ".android", "avd");
+}
+function parseIni(contents) {
+    const map = {};
+    for (const rawLine of contents.split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const separatorIndex = line.indexOf("=");
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        map[key] = value;
+    }
+    return map;
+}
+function parseApiLevel(config, root) {
+    const target = config.target ?? root.target;
+    if (target) {
+        const match = target.match(/android-(\d+)/);
+        if (match) {
+            return Number(match[1]);
+        }
+    }
+    const systemImage = config["image.sysdir.1"];
+    if (!systemImage) {
+        return null;
+    }
+    const match = systemImage.match(/android-(\d+)/);
+    return match ? Number(match[1]) : null;
+}
+function parseSystemImage(config) {
+    const sysdir = config["image.sysdir.1"];
+    if (!sysdir) {
+        return null;
+    }
+    return sysdir.replace(/\/+$/, "").replaceAll("/", ";");
+}
+function parsePlayStore(config) {
+    const explicit = config["PlayStore.enabled"]?.toLowerCase();
+    if (explicit === "true" || explicit === "yes") {
+        return true;
+    }
+    const tagId = config["tag.id"]?.toLowerCase();
+    if (tagId === "google_apis_playstore") {
+        return true;
+    }
+    const systemImage = config["image.sysdir.1"]?.toLowerCase();
+    return systemImage?.includes("google_apis_playstore") ?? false;
+}
+function parseDeviceProfile(config) {
+    return config["hw.device.name"] ?? null;
+}
+async function readIniIfPresent(path) {
+    try {
+        const contents = await readFile(path, "utf8");
+        return parseIni(contents);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return {};
+    }
+}
+export async function inspectConfiguredAvd(name, runningNames = new Set()) {
+    const avdRoot = getAvdRoot();
+    validateAvdName(name);
+    const config = await readIniIfPresent(await getAvdConfigPath(name));
+    const root = await readIniIfPresent(join(avdRoot, `${name}.ini`));
+    const exists = await pathExists(join(avdRoot, `${name}.ini`)) || await pathExists(await getAvdConfigPath(name));
+    return {
+        name,
+        exists,
+        running: runningNames.has(name),
+        apiLevel: parseApiLevel(config, root),
+        abi: config["abi.type"] ?? null,
+        playStore: parsePlayStore(config),
+        deviceProfile: parseDeviceProfile(config),
+        systemImage: parseSystemImage(config),
+    };
+}
+export async function listConfiguredAvds(config, runningNames = new Set()) {
+    const result = await runAndroidSdkTool(config, "emulator", ["-list-avds"], { timeoutMs: 10_000 });
+    if (result.code !== 0) {
+        throw new Error(result.stderr || "Failed to list configured AVDs");
+    }
+    const names = result.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const avds = [];
+    for (const name of names) {
+        avds.push(await inspectConfiguredAvd(name, runningNames));
+    }
+    return avds;
+}
+export async function getAvdConfigPath(name) {
+    validateAvdName(name);
+    const avdRoot = getAvdRoot();
+    const root = await readIniIfPresent(join(avdRoot, `${name}.ini`));
+    if (root.path) {
+        if (!isAbsolute(root.path))
+            throw new Error(`AVD ${name} has a non-absolute path entry`);
+        return join(root.path, "config.ini");
+    }
+    if (root["path.rel"])
+        return join(resolve(dirname(avdRoot), root["path.rel"]), "config.ini");
+    return join(avdRoot, `${name}.avd`, "config.ini");
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+//# sourceMappingURL=configuredAvds.js.map

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EMULATOR_DATA_PARTITION_SIZE_PATTERN: RegExp;
+export declare const EMULATOR_BOOT_TIMEOUT_MS = 180000;
+export declare const ADB_REGISTRATION_TIMEOUT_MS = 60000;
+export declare const BOOT_POLL_INTERVAL_MS = 2000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,5 @@
+export const EMULATOR_DATA_PARTITION_SIZE_PATTERN = /^([1-9][0-9]*)(G|GB)$/;
+export const EMULATOR_BOOT_TIMEOUT_MS = 180_000;
+export const ADB_REGISTRATION_TIMEOUT_MS = 60_000;
+export const BOOT_POLL_INTERVAL_MS = 2_000;
+//# sourceMappingURL=constants.js.map

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+export declare const ERROR_CODES: {
+    readonly ADB_QUERY_FAILED: "ADB_QUERY_FAILED";
+    readonly ANDROID_AVD_CREATE_FAILED: "ANDROID_AVD_CREATE_FAILED";
+    readonly ANDROID_SDK_TOOL_MISSING: "ANDROID_SDK_TOOL_MISSING";
+    readonly ANDROID_SYSTEM_IMAGE_INSTALL_FAILED: "ANDROID_SYSTEM_IMAGE_INSTALL_FAILED";
+    readonly EMULATOR_ALREADY_RUNNING: "EMULATOR_ALREADY_RUNNING";
+    readonly EMULATOR_BOOT_TIMEOUT: "EMULATOR_BOOT_TIMEOUT";
+    readonly EMULATOR_DELETE_FAILED: "EMULATOR_DELETE_FAILED";
+    readonly EMULATOR_NOT_FOUND: "EMULATOR_NOT_FOUND";
+    readonly EMULATOR_NOT_RUNNING: "EMULATOR_NOT_RUNNING";
+    readonly EMULATOR_START_FAILED: "EMULATOR_START_FAILED";
+    readonly EMULATOR_STOP_FAILED: "EMULATOR_STOP_FAILED";
+    readonly INVALID_ARGUMENT: "INVALID_ARGUMENT";
+    readonly ANDROID_AVD_ALREADY_EXISTS: "ANDROID_AVD_ALREADY_EXISTS";
+};
+export interface EmulatorError {
+    code: (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+    message: string;
+    details?: Record<string, unknown>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,16 @@
+export const ERROR_CODES = {
+    ADB_QUERY_FAILED: "ADB_QUERY_FAILED",
+    ANDROID_AVD_CREATE_FAILED: "ANDROID_AVD_CREATE_FAILED",
+    ANDROID_SDK_TOOL_MISSING: "ANDROID_SDK_TOOL_MISSING",
+    ANDROID_SYSTEM_IMAGE_INSTALL_FAILED: "ANDROID_SYSTEM_IMAGE_INSTALL_FAILED",
+    EMULATOR_ALREADY_RUNNING: "EMULATOR_ALREADY_RUNNING",
+    EMULATOR_BOOT_TIMEOUT: "EMULATOR_BOOT_TIMEOUT",
+    EMULATOR_DELETE_FAILED: "EMULATOR_DELETE_FAILED",
+    EMULATOR_NOT_FOUND: "EMULATOR_NOT_FOUND",
+    EMULATOR_NOT_RUNNING: "EMULATOR_NOT_RUNNING",
+    EMULATOR_START_FAILED: "EMULATOR_START_FAILED",
+    EMULATOR_STOP_FAILED: "EMULATOR_STOP_FAILED",
+    INVALID_ARGUMENT: "INVALID_ARGUMENT",
+    ANDROID_AVD_ALREADY_EXISTS: "ANDROID_AVD_ALREADY_EXISTS",
+};
+//# sourceMappingURL=errors.js.map