adb-ready 0.0.1-alpha.0

package/dist/cli.js

@@ -0,0 +1,2632 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import process6 from "node:process";
+
+// src/cli/main.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import process5 from "node:process";
+// package.json
+var package_default = {
+  name: "adb-ready",
+  version: "0.0.1-alpha.0",
+  description: "Make an Android target ready, then keep the development session working.",
+  type: "module",
+  bin: {
+    "adb-ready": "dist/cli.js",
+    adbr: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "schema",
+    "README.md"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  packageManager: "bun@1.3.11",
+  scripts: {
+    dev: "bun run src/cli.ts",
+    build: "bun run scripts/build.mjs",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    format: "biome check --write .",
+    "ui:playground": "bun run scripts/ui-playground.ts",
+    "ui:check": "bun run scripts/ui-playground.ts --all --non-interactive",
+    test: "bun test",
+    "test:commands": "bun run build && bun run scripts/command-matrix.mjs",
+    "test:integration": "bun test tests/integration",
+    smoke: "bun run build && bun run scripts/runtime-smoke.mjs",
+    "pack:check": "bun run build && bun run scripts/package-check.mjs",
+    "privacy:check": "bun run scripts/privacy-check.mjs",
+    verify: "bun run scripts/verify.mjs",
+    "verify:real-adb": "bun run build && bun run scripts/real-adb-check.mjs",
+    check: "bun run verify",
+    prepack: "bun run build"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Adam014/adb-ready.git"
+  },
+  bugs: {
+    url: "https://github.com/Adam014/adb-ready/issues"
+  },
+  homepage: "https://github.com/Adam014/adb-ready#readme",
+  keywords: [
+    "adb",
+    "android",
+    "cli",
+    "developer-tools",
+    "expo",
+    "react-native",
+    "wireless-debugging"
+  ],
+  license: "UNLICENSED",
+  publishConfig: {
+    access: "public"
+  },
+  devDependencies: {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@biomejs/biome": "2.5.12",
+    "@types/bun": "1.4.2",
+    "@types/node": "22.20.2",
+    publint: "0.3.24",
+    typescript: "7.0.2"
+  }
+};
+
+// src/app/commands.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/adb/client.ts
+import { randomUUID } from "node:crypto";
+
+// src/platform/process-runner.ts
+import { spawn } from "node:child_process";
+import process from "node:process";
+var DEFAULT_MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+function createBoundedCapture(maxBytes) {
+  const chunks = [];
+  let size = 0;
+  let truncated = false;
+  return {
+    append(chunk) {
+      if (size >= maxBytes) {
+        truncated = true;
+        return;
+      }
+      const remaining = maxBytes - size;
+      const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, remaining);
+      chunks.push(accepted);
+      size += accepted.byteLength;
+      if (accepted.byteLength !== chunk.byteLength) {
+        truncated = true;
+      }
+    },
+    text() {
+      const merged = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      return new TextDecoder("utf-8", { fatal: false }).decode(merged);
+    },
+    get truncated() {
+      return truncated;
+    }
+  };
+}
+async function runProcess(request) {
+  const args = [...request.args ?? []];
+  const started = new Date;
+  const startedAt = started.toISOString();
+  const maxBufferBytes = request.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
+  if (!Number.isSafeInteger(maxBufferBytes) || maxBufferBytes < 0) {
+    throw new RangeError("maxBufferBytes must be a non-negative safe integer");
+  }
+  if (request.timeoutMs !== undefined && (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs < 0)) {
+    throw new RangeError("timeoutMs must be a non-negative safe integer");
+  }
+  const stdout = createBoundedCapture(maxBufferBytes);
+  const stderr = createBoundedCapture(maxBufferBytes);
+  const stdio = request.stdio ?? "capture";
+  let timedOut = false;
+  let aborted = request.signal?.aborted ?? false;
+  let spawnError;
+  return await new Promise((resolve) => {
+    const child = spawn(request.executable, args, {
+      cwd: request.cwd,
+      env: { ...process.env, ...request.env },
+      shell: false,
+      stdio: stdio === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    if (stdio === "capture") {
+      child.stdout?.on("data", (chunk) => stdout.append(chunk));
+      child.stderr?.on("data", (chunk) => stderr.append(chunk));
+    }
+    const killSignal = request.killSignal ?? "SIGTERM";
+    const abort = () => {
+      aborted = true;
+      if (child.exitCode === null && child.signalCode === null) {
+        child.kill(killSignal);
+      }
+    };
+    request.signal?.addEventListener("abort", abort, { once: true });
+    if (request.signal?.aborted) {
+      abort();
+    }
+    const timeout = request.timeoutMs === undefined ? undefined : setTimeout(() => {
+      timedOut = true;
+      if (child.exitCode === null && child.signalCode === null) {
+        child.kill(killSignal);
+      }
+    }, request.timeoutMs);
+    child.once("error", (error) => {
+      spawnError = {
+        ...error.code === undefined ? {} : { code: error.code },
+        message: error.message
+      };
+    });
+    child.once("close", (exitCode, signal) => {
+      if (timeout !== undefined) {
+        clearTimeout(timeout);
+      }
+      request.signal?.removeEventListener("abort", abort);
+      const finished = new Date;
+      resolve({
+        executable: request.executable,
+        args,
+        startedAt,
+        finishedAt: finished.toISOString(),
+        durationMs: Math.max(0, finished.getTime() - started.getTime()),
+        exitCode: spawnError === undefined ? exitCode : null,
+        signal: spawnError === undefined ? signal : null,
+        stdout: stdout.text(),
+        stderr: stderr.text(),
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated,
+        timedOut,
+        aborted,
+        ...spawnError === undefined ? {} : { spawnError }
+      });
+    });
+  });
+}
+
+// src/adb/parsers.ts
+var KNOWN_STATES = new Set([
+  "bootloader",
+  "device",
+  "offline",
+  "recovery",
+  "sideload",
+  "unauthorized"
+]);
+function normalizeState(tokens) {
+  if (tokens[0] === "no" && tokens[1] === "permissions") {
+    return { state: "no-permissions", consumed: 2 };
+  }
+  const candidate = tokens[0];
+  if (candidate !== undefined && KNOWN_STATES.has(candidate)) {
+    return { state: candidate, consumed: 1 };
+  }
+  return { state: "unknown", consumed: candidate === undefined ? 0 : 1 };
+}
+function parseAdbDevices(output) {
+  const devices = [];
+  let sawHeader = false;
+  for (const rawLine of output.replaceAll(`\r
+`, `
+`).split(`
+`)) {
+    const line = rawLine.trim();
+    if (line === "") {
+      continue;
+    }
+    if (line.startsWith("List of devices attached")) {
+      sawHeader = true;
+      continue;
+    }
+    if (!sawHeader || line.startsWith("* daemon") || line.startsWith("adb server")) {
+      continue;
+    }
+    const tokens = line.split(/\s+/u);
+    const serial = tokens.shift();
+    if (serial === undefined || serial === "") {
+      continue;
+    }
+    const { state, consumed } = normalizeState(tokens);
+    const details = tokens.slice(consumed);
+    const properties = {};
+    const unparsed = [];
+    for (const token of details) {
+      const separator = token.indexOf(":");
+      if (separator <= 0) {
+        unparsed.push(token);
+        continue;
+      }
+      properties[token.slice(0, separator)] = token.slice(separator + 1);
+    }
+    devices.push({
+      serial,
+      state,
+      ...properties.product === undefined ? {} : { product: properties.product },
+      ...properties.model === undefined ? {} : { model: properties.model.replaceAll("_", " ") },
+      ...properties.device === undefined ? {} : { device: properties.device },
+      ...properties.transport_id === undefined ? {} : { transportId: properties.transport_id },
+      ...properties.usb === undefined ? {} : { usb: properties.usb },
+      properties,
+      unparsed
+    });
+  }
+  return devices;
+}
+function parseAdbVersion(output) {
+  const normalized = output.replaceAll(`\r
+`, `
+`).trim();
+  const protocolVersion = normalized.match(/Android Debug Bridge version\s+([^\s]+)/iu)?.[1];
+  const platformToolsVersion = normalized.match(/^Version\s+([^\s]+)/imu)?.[1];
+  const installedAs = normalized.match(/^Installed as\s+(.+)$/imu)?.[1]?.trim();
+  return {
+    ...protocolVersion === undefined ? {} : { protocolVersion },
+    ...platformToolsVersion === undefined ? {} : { platformToolsVersion },
+    ...installedAs === undefined ? {} : { installedAs },
+    raw: normalized
+  };
+}
+function parseFeatureList(output) {
+  return [
+    ...new Set(output.trim().split(/[\s,]+/u).map((feature) => feature.trim()).filter(Boolean))
+  ].sort();
+}
+function parseKeyValueLines(output) {
+  const values = {};
+  for (const rawLine of output.replaceAll(`\r
+`, `
+`).split(`
+`)) {
+    const separator = rawLine.indexOf(":");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = rawLine.slice(0, separator).trim();
+    const value = rawLine.slice(separator + 1).trim();
+    if (key !== "") {
+      values[key] = value;
+    }
+  }
+  return values;
+}
+
+// src/adb/client.ts
+function processMetadata(result) {
+  return {
+    durationMs: result.durationMs,
+    exitCode: result.exitCode,
+    signal: result.signal,
+    timedOut: result.timedOut,
+    aborted: result.aborted,
+    stdoutTruncated: result.stdoutTruncated,
+    stderrTruncated: result.stderrTruncated,
+    ...result.spawnError === undefined ? {} : {
+      spawnError: {
+        ...result.spawnError.code === undefined ? {} : { code: result.spawnError.code },
+        message: result.spawnError.message
+      }
+    }
+  };
+}
+
+class AdbClient {
+  #options;
+  #runner;
+  #idFactory;
+  constructor(options) {
+    this.#options = options;
+    this.#runner = options.runner ?? runProcess;
+    this.#idFactory = options.idFactory ?? randomUUID;
+  }
+  async version(signal) {
+    return await this.#observe("version", "Checking ADB version", ["version"], parseAdbVersion, signal, false);
+  }
+  async hostFeatures(signal) {
+    return await this.#observe("host-features", "Checking ADB host features", ["host-features"], parseFeatureList, signal);
+  }
+  async serverStatus(signal) {
+    return await this.#observe("server-status", "Checking ADB server status", ["server-status"], parseKeyValueLines, signal);
+  }
+  async devices(signal) {
+    return await this.#observe("devices", "Discovering Android targets", ["devices", "-l"], parseAdbDevices, signal);
+  }
+  #serverArguments() {
+    return [
+      ...this.#options.host === undefined ? [] : ["-H", this.#options.host],
+      ...this.#options.port === undefined ? [] : ["-P", String(this.#options.port)]
+    ];
+  }
+  async#observe(operation, message, args, parse, signal, useServerArguments = true) {
+    const operationId = this.#idFactory();
+    const correlation = { commandId: this.#options.correlation.commandId, operationId };
+    const finalArgs = [...useServerArguments ? this.#serverArguments() : [], ...args];
+    this.#options.bus.emit({
+      type: "operation.started",
+      source: `adb.${operation}`,
+      severity: "info",
+      message,
+      correlation,
+      data: { executable: this.#options.executable, args: finalArgs }
+    });
+    const request = {
+      executable: this.#options.executable,
+      args: finalArgs,
+      ...this.#options.timeoutMs === undefined ? {} : { timeoutMs: this.#options.timeoutMs },
+      ...signal === undefined ? {} : { signal }
+    };
+    const result = await this.#runner(request);
+    const succeeded = result.spawnError === undefined && result.exitCode === 0 && !result.timedOut && !result.aborted;
+    this.#options.bus.emit({
+      type: succeeded ? "operation.completed" : "operation.failed",
+      source: `adb.${operation}`,
+      severity: succeeded ? "info" : "error",
+      message: succeeded ? `${message} completed` : `${message} failed`,
+      correlation,
+      data: processMetadata(result)
+    });
+    return {
+      operationId,
+      process: result,
+      value: parse(result.stdout)
+    };
+  }
+}
+
+// src/domain/contracts.ts
+var SCHEMA_VERSION = 1;
+
+// src/core/event-bus.ts
+class EventBus {
+  #clock;
+  #listeners = new Set;
+  #sequence = 0;
+  constructor(clock = () => new Date) {
+    this.#clock = clock;
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  emit(input) {
+    const event = {
+      schemaVersion: SCHEMA_VERSION,
+      sequence: ++this.#sequence,
+      timestamp: this.#clock().toISOString(),
+      type: input.type,
+      source: input.source,
+      severity: input.severity,
+      message: input.message,
+      correlation: input.correlation,
+      ...input.data === undefined ? {} : { data: input.data }
+    };
+    for (const listener of this.#listeners) {
+      listener(event);
+    }
+    return event;
+  }
+}
+
+// src/core/redaction.ts
+import { homedir } from "node:os";
+var REDACTED = "[REDACTED]";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function replaceAndCount(input, expression, replacement) {
+  let replacements = 0;
+  const value = input.replace(expression, (...args) => {
+    replacements += 1;
+    return typeof replacement === "string" ? replacement : replacement(...args);
+  });
+  return { value, replacements };
+}
+function redactText(input, options = {}) {
+  let value = input;
+  let replacements = 0;
+  const patterns = [
+    {
+      expression: /\b((?:authorization\s*[:=]\s*)?Bearer)\s+[^\s,;]+/giu,
+      replacement: (_match, prefix) => `${prefix} ${REDACTED}`
+    },
+    {
+      expression: /\b(api[_-]?key|access[_-]?token|auth|password|passwd|secret)\b(\s*[:=]\s*)(["']?)[^\s,"';]+\3/giu,
+      replacement: (_match, name, separator) => `${name}${separator}${REDACTED}`
+    },
+    {
+      expression: /\b(authorization)(\s*[:=]\s*)(?!Bearer\b)(["']?)[^\s,"';]+\3/giu,
+      replacement: (_match, name, separator) => `${name}${separator}${REDACTED}`
+    },
+    {
+      expression: /\b(pair(?:ing)?(?:\s+code)?)(\s*[:=]\s*)\d{6}\b/giu,
+      replacement: (_match, name, separator) => `${name}${separator}${REDACTED}`
+    },
+    {
+      expression: /([?&](?:access_token|api_key|apikey|auth|password|secret|token)=)[^&#\s]*/giu,
+      replacement: (_match, prefix) => `${prefix}${REDACTED}`
+    }
+  ];
+  for (const pattern of patterns) {
+    const result = replaceAndCount(value, pattern.expression, pattern.replacement);
+    value = result.value;
+    replacements += result.replacements;
+  }
+  const homeDirectory = options.homeDirectory ?? homedir();
+  if (homeDirectory.length > 1) {
+    const result = replaceAndCount(value, new RegExp(escapeRegExp(homeDirectory), "gu"), "~");
+    value = result.value;
+    replacements += result.replacements;
+  }
+  for (const literal of options.additionalLiterals ?? []) {
+    if (literal === "") {
+      continue;
+    }
+    const result = replaceAndCount(value, new RegExp(escapeRegExp(literal), "gu"), REDACTED);
+    value = result.value;
+    replacements += result.replacements;
+  }
+  return { value, replacements };
+}
+
+// src/domain/problems.ts
+var ProblemCode = {
+  AdbCommandFailed: "ADB_COMMAND_FAILED",
+  AdbNotFound: "ADB_NOT_FOUND",
+  AdbOptionalProbeFailed: "ADB_OPTIONAL_PROBE_FAILED",
+  AdbServerUnavailable: "ADB_SERVER_UNAVAILABLE",
+  AdbTimeout: "ADB_TIMEOUT",
+  InteractiveSelectionUnavailable: "INTERACTIVE_SELECTION_UNAVAILABLE",
+  MultipleTargets: "MULTIPLE_TARGETS",
+  NoSelectableTarget: "NO_SELECTABLE_TARGET",
+  NoTargets: "NO_TARGETS",
+  OperationInterrupted: "OPERATION_INTERRUPTED",
+  TargetSelectionCancelled: "TARGET_SELECTION_CANCELLED",
+  TargetNoPermissions: "TARGET_NO_PERMISSIONS",
+  TargetOffline: "TARGET_OFFLINE",
+  TargetUnauthorized: "TARGET_UNAUTHORIZED",
+  TargetUnknownState: "TARGET_UNKNOWN_STATE"
+};
+function retryDevicesAction() {
+  return {
+    id: "retry_device_probe",
+    title: "Check visible devices again",
+    kind: "command",
+    risk: "read-only",
+    automatic: true,
+    idempotent: true,
+    command: { executable: "adb", args: ["devices", "-l"] }
+  };
+}
+function adbNotFoundProblem(correlation, requestedPath) {
+  return {
+    code: ProblemCode.AdbNotFound,
+    category: "environment.executable",
+    severity: "error",
+    summary: "ADB was not found.",
+    detail: requestedPath === undefined ? "Install Android SDK Platform-Tools or provide an explicit ADB path." : `The configured ADB executable could not be used: ${requestedPath}`,
+    retryable: true,
+    evidence: requestedPath === undefined ? [] : [{ source: "configuration", field: "adb.path", value: requestedPath }],
+    actions: [
+      {
+        id: "configure_adb_path",
+        title: "Provide the ADB executable with --adb PATH",
+        kind: "user",
+        risk: "none",
+        automatic: false
+      }
+    ],
+    correlation
+  };
+}
+function processEvidence(result) {
+  const redacted = redactText(result.stderr.trim());
+  return [
+    { source: "process", field: "exitCode", value: result.exitCode },
+    { source: "process", field: "signal", value: result.signal },
+    { source: "process", field: "timedOut", value: result.timedOut },
+    ...redacted.value === "" ? [] : [
+      {
+        source: "process",
+        field: "stderr",
+        value: redacted.value.slice(0, 2000),
+        redacted: redacted.replacements > 0
+      }
+    ]
+  ];
+}
+function adbProcessProblem(operation, result, correlation) {
+  if (result.spawnError?.code === "ENOENT") {
+    return adbNotFoundProblem(correlation, result.executable);
+  }
+  if (result.aborted) {
+    return {
+      code: ProblemCode.OperationInterrupted,
+      category: "process.interrupted",
+      severity: "error",
+      summary: `ADB ${operation} was interrupted.`,
+      detail: "The operation stopped after receiving an interruption request.",
+      retryable: true,
+      evidence: processEvidence(result),
+      actions: [],
+      correlation
+    };
+  }
+  if (result.timedOut) {
+    return {
+      code: ProblemCode.AdbTimeout,
+      category: "adb.timeout",
+      severity: "error",
+      summary: `ADB ${operation} timed out.`,
+      detail: "The operation did not finish within the configured timeout.",
+      retryable: true,
+      evidence: processEvidence(result),
+      actions: [retryDevicesAction()],
+      correlation
+    };
+  }
+  const daemonUnavailable = /cannot connect to daemon|failed to start daemon|server.*failed/iu.test(result.stderr);
+  return {
+    code: daemonUnavailable ? ProblemCode.AdbServerUnavailable : ProblemCode.AdbCommandFailed,
+    category: daemonUnavailable ? "adb.server" : "adb.operation",
+    severity: "error",
+    summary: daemonUnavailable ? "The ADB server is unavailable." : `ADB ${operation} failed.`,
+    detail: daemonUnavailable ? "ADB Ready could not communicate with the configured ADB server." : "ADB returned an unsuccessful result for this operation.",
+    retryable: true,
+    evidence: processEvidence(result),
+    actions: [retryDevicesAction()],
+    correlation
+  };
+}
+function adbOptionalProbeProblem(operation, result, correlation) {
+  const failure = adbProcessProblem(operation, result, correlation);
+  return {
+    ...failure,
+    code: ProblemCode.AdbOptionalProbeFailed,
+    category: "adb.capability",
+    severity: "warning",
+    summary: `Optional ADB ${operation} probe failed.`,
+    detail: "Core diagnostics can continue, but this ADB capability could not be inspected reliably."
+  };
+}
+function targetEvidence(device) {
+  return [
+    { source: "adb.devices", field: "serial", value: device.serial },
+    { source: "adb.devices", field: "state", value: device.state }
+  ];
+}
+function problemsForDevices(devices, correlation, severity = "error") {
+  const problems = [];
+  for (const device of devices) {
+    if (device.state === "unauthorized") {
+      problems.push({
+        code: ProblemCode.TargetUnauthorized,
+        category: "target.authorization",
+        severity,
+        summary: "An Android target has not authorized this computer.",
+        detail: "Accept the RSA authorization prompt on the target, then retry the probe.",
+        retryable: true,
+        evidence: targetEvidence(device),
+        actions: [
+          {
+            id: "accept_device_prompt",
+            title: "Accept the RSA prompt on the Android target",
+            kind: "user",
+            risk: "none",
+            automatic: false
+          },
+          retryDevicesAction()
+        ],
+        correlation
+      });
+    } else if (device.state === "offline") {
+      problems.push({
+        code: ProblemCode.TargetOffline,
+        category: "target.transport",
+        severity,
+        summary: "An Android target is offline.",
+        detail: "ADB knows this transport, but it cannot currently communicate with the target.",
+        retryable: true,
+        evidence: targetEvidence(device),
+        actions: [retryDevicesAction()],
+        correlation
+      });
+    } else if (device.state === "no-permissions") {
+      problems.push({
+        code: ProblemCode.TargetNoPermissions,
+        category: "target.permissions",
+        severity,
+        summary: "The host does not have permission to use an Android target.",
+        detail: "Check the host USB permissions and Android developer authorization setup.",
+        retryable: true,
+        evidence: targetEvidence(device),
+        actions: [
+          {
+            id: "review_usb_permissions",
+            title: "Review host USB permission setup",
+            kind: "documentation",
+            risk: "none",
+            automatic: false
+          }
+        ],
+        correlation
+      });
+    } else if (device.state === "unknown") {
+      problems.push({
+        code: ProblemCode.TargetUnknownState,
+        category: "target.state",
+        severity: "warning",
+        summary: "ADB reported an unknown target state.",
+        detail: "The target remains visible, but ADB Ready will not assume it is usable.",
+        retryable: true,
+        evidence: targetEvidence(device),
+        actions: [retryDevicesAction()],
+        correlation
+      });
+    }
+  }
+  return problems;
+}
+function noTargetsProblem(correlation) {
+  return {
+    code: ProblemCode.NoTargets,
+    category: "target.selection",
+    severity: "warning",
+    summary: "No Android targets are visible.",
+    detail: "Connect a target over USB, start an emulator, or enable Wireless debugging.",
+    retryable: true,
+    evidence: [{ source: "adb.devices", field: "count", value: 0 }],
+    actions: [retryDevicesAction()],
+    correlation
+  };
+}
+
+// src/platform/executable.ts
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path from "node:path";
+import process2 from "node:process";
+async function isExecutable(candidate, platform) {
+  try {
+    await access(candidate, platform === "win32" ? constants.F_OK : constants.X_OK);
+    return (await stat(candidate)).isFile();
+  } catch {
+    return false;
+  }
+}
+function windowsExtensions(env) {
+  const value = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+  return value.split(";").map((extension) => extension.trim().toLowerCase()).filter(Boolean);
+}
+function candidateNames(name, platform, env) {
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  if (platform !== "win32" || pathApi.extname(name) !== "") {
+    return [name];
+  }
+  return [name, ...windowsExtensions(env).map((extension) => `${name}${extension}`)];
+}
+async function resolveFromPath(name, env, platform) {
+  const pathValue = env.PATH ?? env.Path ?? env.path;
+  if (pathValue === undefined) {
+    return;
+  }
+  const delimiter = platform === "win32" ? ";" : ":";
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  for (const directory of pathValue.split(delimiter)) {
+    if (directory.trim() === "") {
+      continue;
+    }
+    for (const candidateName of candidateNames(name, platform, env)) {
+      const candidate = pathApi.resolve(directory.replace(/^"|"$/g, ""), candidateName);
+      if (await isExecutable(candidate, platform)) {
+        return candidate;
+      }
+    }
+  }
+  return;
+}
+function sdkCandidates(env, platform, homeDirectory) {
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  const executable = platform === "win32" ? "adb.exe" : "adb";
+  const roots = [env.ANDROID_SDK_ROOT, env.ANDROID_HOME].filter((value) => value !== undefined && value.trim() !== "");
+  if (platform === "darwin") {
+    roots.push(pathApi.join(homeDirectory, "Library", "Android", "sdk"));
+  } else if (platform === "win32") {
+    if (env.LOCALAPPDATA !== undefined) {
+      roots.push(pathApi.join(env.LOCALAPPDATA, "Android", "Sdk"));
+    }
+  } else {
+    roots.push(pathApi.join(homeDirectory, "Android", "Sdk"));
+  }
+  return [...new Set(roots.map((root) => pathApi.join(root, "platform-tools", executable)))];
+}
+async function locateAdb(options = {}) {
+  const env = options.env ?? process2.env;
+  const platform = options.platform ?? process2.platform;
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  if (options.explicitPath !== undefined) {
+    const explicit = options.explicitPath.trim();
+    if (explicit === "") {
+      return;
+    }
+    if (pathApi.isAbsolute(explicit) || explicit.includes("/") || explicit.includes("\\")) {
+      const candidate = pathApi.resolve(explicit);
+      return await isExecutable(candidate, platform) ? candidate : undefined;
+    }
+    return await resolveFromPath(explicit, env, platform);
+  }
+  const fromPath = await resolveFromPath("adb", env, platform);
+  if (fromPath !== undefined) {
+    return fromPath;
+  }
+  for (const candidate of sdkCandidates(env, platform, options.homeDirectory ?? homedir2())) {
+    if (await isExecutable(candidate, platform)) {
+      return candidate;
+    }
+  }
+  return;
+}
+
+// src/platform/runtime.ts
+import process3 from "node:process";
+function detectRuntime() {
+  const versions = process3.versions;
+  if (versions.bun !== undefined) {
+    return {
+      name: "bun",
+      version: versions.bun,
+      ...versions.node === undefined ? {} : { nodeCompatibilityVersion: versions.node },
+      platform: process3.platform,
+      architecture: process3.arch
+    };
+  }
+  if (versions.deno !== undefined) {
+    return {
+      name: "deno",
+      version: versions.deno,
+      ...versions.node === undefined ? {} : { nodeCompatibilityVersion: versions.node },
+      platform: process3.platform,
+      architecture: process3.arch
+    };
+  }
+  if (versions.node !== undefined) {
+    return {
+      name: "node",
+      version: versions.node,
+      platform: process3.platform,
+      architecture: process3.arch
+    };
+  }
+  return {
+    name: "unknown",
+    version: "unknown",
+    platform: process3.platform,
+    architecture: process3.arch
+  };
+}
+
+// src/app/commands.ts
+function processSucceeded(result) {
+  return result.spawnError === undefined && result.exitCode === 0 && !result.timedOut && !result.aborted;
+}
+function exitCodeForProblems(problems) {
+  const errors = problems.filter(({ severity }) => severity === "error");
+  if (errors.length === 0) {
+    return 0 /* Success */;
+  }
+  if (errors.some(({ code }) => code === ProblemCode.OperationInterrupted)) {
+    return 130 /* Interrupted */;
+  }
+  if (errors.some(({ category }) => category.startsWith("environment."))) {
+    return 10 /* Environment */;
+  }
+  if (errors.some(({ category }) => category.startsWith("target."))) {
+    return 20 /* Target */;
+  }
+  return 30 /* AdbOperation */;
+}
+function createContext(command, dependencies) {
+  const clock = dependencies.clock ?? (() => new Date);
+  const commandId = (dependencies.idFactory ?? randomUUID2)();
+  const bus = dependencies.bus ?? new EventBus(clock);
+  const started = clock();
+  bus.emit({
+    type: "command.started",
+    source: `command.${command}`,
+    severity: "info",
+    message: `Running ${command}`,
+    correlation: { commandId }
+  });
+  return { bus, clock, command, commandId, started };
+}
+function finish(context, data, problems) {
+  const finished = context.clock();
+  const exitCode = exitCodeForProblems(problems);
+  const ok = exitCode === 0 /* Success */;
+  const result = {
+    schemaVersion: SCHEMA_VERSION,
+    command: context.command,
+    commandId: context.commandId,
+    ok,
+    startedAt: context.started.toISOString(),
+    finishedAt: finished.toISOString(),
+    durationMs: Math.max(0, finished.getTime() - context.started.getTime()),
+    data,
+    problems
+  };
+  context.bus.emit({
+    type: ok ? "command.completed" : "command.failed",
+    source: `command.${context.command}`,
+    severity: ok ? "info" : "error",
+    message: ok ? `${context.command} completed` : `${context.command} failed`,
+    correlation: { commandId: context.commandId },
+    data: { exitCode, problemCount: problems.length }
+  });
+  return { result, exitCode };
+}
+function redactedPath(value) {
+  return redactText(value).value;
+}
+function redactedRecord(values) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, redactText(value).value]));
+}
+async function resolveAdb(context, config, dependencies) {
+  const operationId = (dependencies.idFactory ?? randomUUID2)();
+  const correlation = { commandId: context.commandId, operationId };
+  context.bus.emit({
+    type: "operation.started",
+    source: "host.adb-path",
+    severity: "info",
+    message: "Locating ADB",
+    correlation
+  });
+  const executable = await (dependencies.locateAdb ?? locateAdb)({
+    ...config.adbPath === undefined ? {} : { explicitPath: config.adbPath }
+  });
+  context.bus.emit({
+    type: executable === undefined ? "operation.failed" : "operation.completed",
+    source: "host.adb-path",
+    severity: executable === undefined ? "error" : "info",
+    message: executable === undefined ? "ADB was not found" : "ADB was found",
+    correlation,
+    ...executable === undefined ? {} : { data: { path: redactedPath(executable) } }
+  });
+  return executable;
+}
+function createClient(executable, context, config, dependencies) {
+  return new AdbClient({
+    executable,
+    bus: context.bus,
+    correlation: { commandId: context.commandId },
+    ...config.adbHost === undefined ? {} : { host: config.adbHost },
+    ...config.adbPort === undefined ? {} : { port: config.adbPort },
+    ...config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs },
+    ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+    ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory }
+  });
+}
+function operationProblem(operation, observation, commandId) {
+  return adbProcessProblem(operation, observation.process, {
+    commandId,
+    operationId: observation.operationId
+  });
+}
+async function runDoctor(config = {}, dependencies = {}, signal) {
+  const context = createContext("doctor", dependencies);
+  const problems = [];
+  const executable = await resolveAdb(context, config, dependencies);
+  if (executable === undefined) {
+    problems.push(adbNotFoundProblem({ commandId: context.commandId }, config.adbPath));
+    return finish(context, null, problems);
+  }
+  const client = createClient(executable, context, config, dependencies);
+  const version = await client.version(signal);
+  if (!processSucceeded(version.process)) {
+    problems.push(operationProblem("version", version, context.commandId));
+    return finish(context, null, problems);
+  }
+  const hostFeatures = await client.hostFeatures(signal);
+  if (!processSucceeded(hostFeatures.process)) {
+    const problem = operationProblem("host-features", hostFeatures, context.commandId);
+    if (problem.code === ProblemCode.OperationInterrupted) {
+      problems.push(problem);
+      return finish(context, null, problems);
+    }
+    problems.push(adbOptionalProbeProblem("host-features", hostFeatures.process, problem.correlation));
+  }
+  let serverStatus = null;
+  if (processSucceeded(hostFeatures.process) && hostFeatures.value.includes("server_status")) {
+    const status = await client.serverStatus(signal);
+    if (processSucceeded(status.process)) {
+      serverStatus = redactedRecord(status.value);
+    } else {
+      const problem = operationProblem("server-status", status, context.commandId);
+      if (problem.code === ProblemCode.OperationInterrupted) {
+        problems.push(problem);
+        return finish(context, null, problems);
+      }
+      problems.push(adbOptionalProbeProblem("server-status", status.process, problem.correlation));
+    }
+  }
+  const devices = await client.devices(signal);
+  if (!processSucceeded(devices.process)) {
+    problems.push(operationProblem("devices", devices, context.commandId));
+    return finish(context, null, problems);
+  }
+  problems.push(...problemsForDevices(devices.value, { commandId: context.commandId }, "warning"));
+  if (devices.value.length === 0) {
+    problems.push(noTargetsProblem({ commandId: context.commandId }));
+  }
+  const versionData = {
+    ...version.value.protocolVersion === undefined ? {} : { protocolVersion: version.value.protocolVersion },
+    ...version.value.platformToolsVersion === undefined ? {} : { platformToolsVersion: version.value.platformToolsVersion },
+    ...version.value.installedAs === undefined ? {} : { installedAs: redactedPath(version.value.installedAs) }
+  };
+  return finish(context, {
+    runtime: (dependencies.runtime ?? detectRuntime)(),
+    adb: {
+      path: redactedPath(executable),
+      version: versionData,
+      hostFeatures: processSucceeded(hostFeatures.process) ? hostFeatures.value : [],
+      serverStatus
+    },
+    devices: devices.value
+  }, problems);
+}
+async function runDevices(config = {}, dependencies = {}, signal) {
+  const context = createContext("devices", dependencies);
+  const problems = [];
+  const executable = await resolveAdb(context, config, dependencies);
+  if (executable === undefined) {
+    problems.push(adbNotFoundProblem({ commandId: context.commandId }, config.adbPath));
+    return finish(context, null, problems);
+  }
+  const client = createClient(executable, context, config, dependencies);
+  const devices = await client.devices(signal);
+  if (!processSucceeded(devices.process)) {
+    problems.push(operationProblem("devices", devices, context.commandId));
+    return finish(context, null, problems);
+  }
+  problems.push(...problemsForDevices(devices.value, { commandId: context.commandId }, "warning"));
+  if (devices.value.length === 0) {
+    problems.push(noTargetsProblem({ commandId: context.commandId }));
+  }
+  return finish(context, { adbPath: redactedPath(executable), devices: devices.value }, problems);
+}
+
+// src/config/loader.ts
+import { readFile, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path2 from "node:path";
+import process4 from "node:process";
+var DEFAULTS = { timeoutMs: 5000 };
+var ROOT_KEYS = new Set(["$schema", "version", "adb", "timeoutMs", "output"]);
+var ADB_KEYS = new Set(["path", "host", "port"]);
+var OUTPUT_KEYS = new Set(["color", "unicode", "animation", "interactive"]);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function error(source, location, pathValue, message, code = "CONFIG_INVALID_VALUE") {
+  return {
+    code,
+    path: pathValue,
+    message,
+    source,
+    ...location === undefined ? {} : { location }
+  };
+}
+function validateUnknownKeys(value, allowed, prefix, source, location, errors) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      errors.push(error(source, location, `${prefix}${key}`, `Unknown configuration key: ${prefix}${key}`));
+    }
+  }
+}
+function validateDocument(document, source, location) {
+  const errors = [];
+  const values = {};
+  if (!isObject(document)) {
+    return {
+      values,
+      errors: [error(source, location, "$", "Configuration must be a JSON object.")]
+    };
+  }
+  validateUnknownKeys(document, ROOT_KEYS, "", source, location, errors);
+  if (document.$schema !== undefined && typeof document.$schema !== "string") {
+    errors.push(error(source, location, "$schema", "$schema must be a string."));
+  }
+  if (document.version !== 1) {
+    errors.push(error(source, location, "version", "version must be exactly 1."));
+  }
+  if (document.timeoutMs !== undefined) {
+    if (!Number.isSafeInteger(document.timeoutMs) || document.timeoutMs < 1 || document.timeoutMs > 2147483647) {
+      errors.push(error(source, location, "timeoutMs", "timeoutMs must be an integer from 1 to 2147483647."));
+    } else {
+      values.timeoutMs = document.timeoutMs;
+    }
+  }
+  if (document.adb !== undefined) {
+    if (!isObject(document.adb)) {
+      errors.push(error(source, location, "adb", "adb must be an object."));
+    } else {
+      validateUnknownKeys(document.adb, ADB_KEYS, "adb.", source, location, errors);
+      for (const [key, configKey] of [
+        ["path", "adbPath"],
+        ["host", "adbHost"]
+      ]) {
+        const candidate = document.adb[key];
+        if (candidate !== undefined) {
+          if (typeof candidate !== "string" || candidate.trim() === "") {
+            errors.push(error(source, location, `adb.${key}`, `adb.${key} must be a non-empty string.`));
+          } else {
+            values[configKey] = candidate;
+          }
+        }
+      }
+      if (document.adb.port !== undefined) {
+        if (!Number.isSafeInteger(document.adb.port) || document.adb.port < 1 || document.adb.port > 65535) {
+          errors.push(error(source, location, "adb.port", "adb.port must be an integer from 1 to 65535."));
+        } else {
+          values.adbPort = document.adb.port;
+        }
+      }
+    }
+  }
+  if (document.output !== undefined) {
+    if (!isObject(document.output)) {
+      errors.push(error(source, location, "output", "output must be an object."));
+    } else {
+      validateUnknownKeys(document.output, OUTPUT_KEYS, "output.", source, location, errors);
+      for (const [key, configKey] of [
+        ["color", "color"],
+        ["unicode", "unicode"],
+        ["animation", "animation"],
+        ["interactive", "interactive"]
+      ]) {
+        const candidate = document.output[key];
+        if (candidate !== undefined) {
+          if (typeof candidate !== "boolean") {
+            errors.push(error(source, location, `output.${key}`, `output.${key} must be a boolean.`));
+          } else {
+            values[configKey] = candidate;
+          }
+        }
+      }
+    }
+  }
+  return { values, errors };
+}
+async function fileExists(file) {
+  try {
+    return (await stat2(file)).isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultUserConfigPath(platform, env, homeDirectory) {
+  const platformPath = platform === "win32" ? path2.win32 : path2.posix;
+  if (env.XDG_CONFIG_HOME !== undefined && env.XDG_CONFIG_HOME.trim() !== "") {
+    return platformPath.join(env.XDG_CONFIG_HOME, "adb-ready", "config.json");
+  }
+  if (platform === "win32" && env.APPDATA !== undefined && env.APPDATA.trim() !== "") {
+    return platformPath.join(env.APPDATA, "adb-ready", "config.json");
+  }
+  if (platform === "darwin") {
+    return platformPath.join(homeDirectory, "Library", "Application Support", "adb-ready", "config.json");
+  }
+  return platformPath.join(homeDirectory, ".config", "adb-ready", "config.json");
+}
+async function findProjectConfig(startDirectory) {
+  let current = path2.resolve(startDirectory);
+  while (true) {
+    const candidate = path2.join(current, "adb-ready.config.json");
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+async function readConfigDocument(file, source, required) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch (caught) {
+    const code = caught.code;
+    if (!required && code === "ENOENT") {
+      return { values: {}, errors: [], loaded: false };
+    }
+    return {
+      values: {},
+      errors: [
+        error(source, file, "$", `Configuration file could not be read: ${file}`, "CONFIG_NOT_FOUND")
+      ],
+      loaded: false
+    };
+  }
+  let document;
+  try {
+    document = JSON.parse(raw);
+  } catch (caught) {
+    return {
+      values: {},
+      errors: [
+        error(source, file, "$", `Invalid JSON: ${caught instanceof Error ? caught.message : "unknown parse error"}`, "CONFIG_INVALID_JSON")
+      ],
+      loaded: true
+    };
+  }
+  const validated = validateDocument(document, source, file);
+  return { ...validated, loaded: true };
+}
+function parseEnvironment(env) {
+  const values = {};
+  const errors = [];
+  const strings = [
+    ["ADB_READY_ADB_PATH", "adbPath"],
+    ["ADB_READY_ADB_HOST", "adbHost"]
+  ];
+  for (const [name, key] of strings) {
+    const candidate = env[name];
+    if (candidate !== undefined) {
+      if (candidate.trim() === "") {
+        errors.push(error("environment", name, name, `${name} cannot be empty.`));
+      } else {
+        values[key] = candidate;
+      }
+    }
+  }
+  const integers = [
+    ["ADB_READY_ADB_PORT", "adbPort", 65535],
+    ["ADB_READY_TIMEOUT_MS", "timeoutMs", 2147483647]
+  ];
+  for (const [name, key, maximum] of integers) {
+    const candidate = env[name];
+    if (candidate !== undefined) {
+      const parsed = Number(candidate);
+      if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > maximum) {
+        errors.push(error("environment", name, name, `${name} must be an integer from 1 to ${maximum}.`));
+      } else {
+        values[key] = parsed;
+      }
+    }
+  }
+  const booleans = [
+    ["ADB_READY_COLOR", "color"],
+    ["ADB_READY_UNICODE", "unicode"],
+    ["ADB_READY_ANIMATION", "animation"],
+    ["ADB_READY_INTERACTIVE", "interactive"]
+  ];
+  for (const [name, key] of booleans) {
+    const candidate = env[name];
+    if (candidate !== undefined) {
+      const normalized = candidate.trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) {
+        values[key] = true;
+      } else if (["0", "false", "no", "off"].includes(normalized)) {
+        values[key] = false;
+      } else {
+        errors.push(error("environment", name, name, `${name} must be true/false, 1/0, yes/no, or on/off.`));
+      }
+    }
+  }
+  return { values, errors };
+}
+function applyValues(target, provenance, values, source, location) {
+  for (const key of Object.keys(values)) {
+    const value = values[key];
+    if (value !== undefined) {
+      Object.assign(target, { [key]: value });
+      provenance[key] = { source, ...location === undefined ? {} : { location } };
+    }
+  }
+}
+async function loadConfig(options = {}) {
+  const cwd = options.cwd ?? process4.cwd();
+  const env = options.env ?? process4.env;
+  const platform = options.platform ?? process4.platform;
+  const homeDirectory = options.homeDirectory ?? homedir3();
+  const userFile = options.userConfigPath ?? defaultUserConfigPath(platform, env, homeDirectory);
+  const environmentProjectFile = env.ADB_READY_CONFIG?.trim();
+  const projectFile = options.projectConfigPath ?? (environmentProjectFile === undefined || environmentProjectFile === "" ? options.explicitProjectConfig ? undefined : await findProjectConfig(cwd) : path2.resolve(cwd, environmentProjectFile));
+  const projectRequired = (options.explicitProjectConfig ?? false) || environmentProjectFile !== undefined && environmentProjectFile !== "";
+  const errors = [];
+  const values = {};
+  const provenance = {};
+  const files = {};
+  applyValues(values, provenance, DEFAULTS, "default");
+  const user = await readConfigDocument(userFile, "user", false);
+  errors.push(...user.errors);
+  if (user.loaded) {
+    files.user = userFile;
+    applyValues(values, provenance, user.values, "user", userFile);
+  }
+  if (projectFile !== undefined) {
+    const project = await readConfigDocument(projectFile, "project", projectRequired);
+    errors.push(...project.errors);
+    if (project.loaded) {
+      files.project = projectFile;
+      applyValues(values, provenance, project.values, "project", projectFile);
+    }
+  } else if (projectRequired) {
+    errors.push(error("project", undefined, "$", "An explicit project configuration path is required.", "CONFIG_NOT_FOUND"));
+  }
+  const environment = parseEnvironment(env);
+  errors.push(...environment.errors);
+  applyValues(values, provenance, environment.values, "environment");
+  applyValues(values, provenance, options.cli ?? {}, "cli");
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    config: {
+      values,
+      provenance,
+      files
+    }
+  };
+}
+
+// src/ui/ascii-scene.ts
+var FACE_SHADES = ".,:;=+*#%@";
+var LINK_PATH = [
+  { x: 1.34, y: -0.42, z: 0 },
+  { x: 0.72, y: -1.02, z: 0 },
+  { x: -0.7, y: -1.02, z: 0 },
+  { x: -1.34, y: -0.42, z: 0 },
+  { x: -1.34, y: 0.42, z: 0 },
+  { x: -0.7, y: 1.02, z: 0 },
+  { x: 0.72, y: 1.02, z: 0 },
+  { x: 1.34, y: 0.42, z: 0 }
+];
+function rotate(point, angleX, angleY) {
+  const sinX = Math.sin(angleX);
+  const cosX = Math.cos(angleX);
+  const sinY = Math.sin(angleY);
+  const cosY = Math.cos(angleY);
+  const afterX = {
+    x: point.x,
+    y: point.y * cosX - point.z * sinX,
+    z: point.y * sinX + point.z * cosX
+  };
+  return {
+    x: afterX.x * cosY + afterX.z * sinY,
+    y: afterX.y,
+    z: -afterX.x * sinY + afterX.z * cosY
+  };
+}
+function orientForLink(point, link, offset = true) {
+  if (link === 0) {
+    return point;
+  }
+  return {
+    x: point.z + (offset ? 0.2 : 0),
+    y: point.y,
+    z: -point.x
+  };
+}
+function normalize(point) {
+  const length = Math.hypot(point.x, point.y, point.z) || 1;
+  return { x: point.x / length, y: point.y / length, z: point.z / length };
+}
+function mix(origin, along, alongAmount, across, acrossAmount, depthAmount) {
+  return {
+    x: origin.x + along.x * alongAmount + across.x * acrossAmount,
+    y: origin.y + along.y * alongAmount + across.y * acrossAmount,
+    z: origin.z + depthAmount
+  };
+}
+function renderLinkCoreFrame(options) {
+  const width = Math.max(10, Math.floor(options.width ?? 36));
+  const height = Math.max(5, Math.floor(options.height ?? 14));
+  const pixels = Array.from({ length: width * height }, () => " ");
+  const depth = new Float64Array(width * height);
+  const camera = 4.8;
+  const focalX = width * 1.18;
+  const focalY = focalX * 0.48;
+  const light = normalize({ x: -0.45, y: 0.7, z: 1 });
+  const plot = (localPoint, localNormal, link, edge = false) => {
+    const point = rotate(orientForLink(localPoint, link), options.angleX, options.angleY);
+    const normal = normalize(rotate(orientForLink(localNormal, link, false), options.angleX, options.angleY));
+    const inverseDepth = 1 / (camera - point.z);
+    const x = Math.round(width / 2 + point.x * focalX * inverseDepth);
+    const y = Math.round(height / 2 - point.y * focalY * inverseDepth);
+    if (x < 0 || x >= width || y < 0 || y >= height) {
+      return;
+    }
+    const index = x + y * width;
+    const biasedDepth = inverseDepth + (edge ? 0.0008 : 0);
+    if (biasedDepth <= (depth[index] ?? 0)) {
+      return;
+    }
+    depth[index] = biasedDepth;
+    const diffuse = Math.max(0, normal.x * light.x + normal.y * light.y + normal.z * light.z);
+    const rim = (1 - Math.abs(normal.z)) ** 2 * 0.22;
+    const luminance = Math.min(1, 0.16 + diffuse * 0.72 + rim + link * 0.04);
+    const shadeIndex = Math.min(FACE_SHADES.length - 1, Math.floor(luminance * FACE_SHADES.length));
+    pixels[index] = edge ? luminance > 0.58 ? "@" : "#" : FACE_SHADES[shadeIndex] ?? ".";
+  };
+  const halfBand = 0.19;
+  const halfDepth = 0.16;
+  const step = 0.045;
+  for (const link of [0, 1]) {
+    for (let segment = 0;segment < LINK_PATH.length - 1; segment += 1) {
+      const from = LINK_PATH[segment];
+      const to = LINK_PATH[segment + 1];
+      if (from === undefined || to === undefined) {
+        continue;
+      }
+      const delta = { x: to.x - from.x, y: to.y - from.y, z: 0 };
+      const length = Math.hypot(delta.x, delta.y);
+      const along = { x: delta.x / length, y: delta.y / length, z: 0 };
+      const across = { x: -along.y, y: along.x, z: 0 };
+      for (let distance = 0;distance <= length; distance += step) {
+        for (let lateral = -halfBand;lateral <= halfBand; lateral += step) {
+          plot(mix(from, along, distance, across, lateral, halfDepth), { x: 0, y: 0, z: 1 }, link);
+          plot(mix(from, along, distance, across, lateral, -halfDepth), { x: 0, y: 0, z: -1 }, link);
+        }
+        for (let extrusion = -halfDepth;extrusion <= halfDepth; extrusion += step) {
+          plot(mix(from, along, distance, across, halfBand, extrusion), across, link);
+          plot(mix(from, along, distance, across, -halfBand, extrusion), { x: -across.x, y: -across.y, z: 0 }, link);
+        }
+        for (const lateral of [-halfBand, halfBand]) {
+          for (const extrusion of [-halfDepth, halfDepth]) {
+            plot(mix(from, along, distance, across, lateral, extrusion), { x: 0, y: 0, z: extrusion > 0 ? 1 : -1 }, link, true);
+          }
+        }
+      }
+    }
+  }
+  return Array.from({ length: height }, (_, row) => pixels.slice(row * width, (row + 1) * width).join("").trimEnd());
+}
+
+// src/ui/style.ts
+var ANSI_PATTERN = /[\x1B\x9B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\\/#&.:=?%@~_]+)*)?\x07)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/gu;
+var CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/gu;
+function sanitizeTerminalText(value) {
+  return value.replace(ANSI_PATTERN, "").replaceAll("\r", " ").replaceAll(`
+`, " ").replaceAll("\t", " ").replace(CONTROL_PATTERN, "").replace(/\s{2,}/gu, " ").trim();
+}
+function symbols(capabilities) {
+  return capabilities.unicode ? {
+    active: "◆",
+    failure: "✕",
+    pending: "○",
+    recovered: "↻",
+    skipped: "–",
+    success: "✓",
+    warning: "!",
+    branch: "├─",
+    end: "└─"
+  } : {
+    active: ">",
+    failure: "x",
+    pending: "o",
+    recovered: "~",
+    skipped: "-",
+    success: "+",
+    warning: "!",
+    branch: "|-",
+    end: "`-"
+  };
+}
+function color(code, value, capabilities) {
+  return capabilities.color ? `\x1B[${String(code)}m${value}\x1B[0m` : value;
+}
+var style = {
+  accent: (value, capabilities) => color(36, value, capabilities),
+  dim: (value, capabilities) => color(2, value, capabilities),
+  failure: (value, capabilities) => color(31, value, capabilities),
+  strong: (value, capabilities) => color(1, value, capabilities),
+  success: (value, capabilities) => color(32, value, capabilities),
+  warning: (value, capabilities) => color(33, value, capabilities)
+};
+
+// src/ui/select.ts
+function truncate(value, width) {
+  if (value.length <= width) {
+    return value;
+  }
+  return width <= 3 ? value.slice(0, width) : `${value.slice(0, width - 3)}...`;
+}
+function wrap(value, width) {
+  const clean = sanitizeTerminalText(value);
+  if (clean.length <= width) {
+    return [clean];
+  }
+  const lines = [];
+  let line = "";
+  for (const word of clean.split(" ")) {
+    if (word.length > width) {
+      if (line !== "") {
+        lines.push(line);
+        line = "";
+      }
+      for (let start = 0;start < word.length; start += width) {
+        lines.push(word.slice(start, start + width));
+      }
+      continue;
+    }
+    const candidate = line === "" ? word : `${line} ${word}`;
+    if (candidate.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = candidate;
+    }
+  }
+  if (line !== "") {
+    lines.push(line);
+  }
+  return lines;
+}
+function nextEnabled(options, current, direction) {
+  for (let offset = 1;offset <= options.length; offset += 1) {
+    const candidate = (current + direction * offset + options.length) % options.length;
+    if (options[candidate]?.disabled !== true) {
+      return candidate;
+    }
+  }
+  return current;
+}
+function initialIndex(options) {
+  const recommended = options.findIndex((option) => option.recommended === true && option.disabled !== true);
+  if (recommended !== -1) {
+    return recommended;
+  }
+  return options.findIndex((option) => option.disabled !== true);
+}
+function renderMenu(options, selected, previousLineCount, frame) {
+  const { capabilities, sink } = options;
+  const glyphs = symbols(capabilities);
+  if (previousLineCount > 0) {
+    sink.write(`\x1B[${String(previousLineCount)}F`);
+  }
+  const top = capabilities.unicode ? "╭─" : "+-";
+  const bottom = capabilities.unicode ? "╰─" : "+-";
+  const rail = capabilities.unicode ? "│" : "|";
+  const compact = capabilities.columns < 60;
+  const help = capabilities.unicode ? "↑↓ move · 1-9 jump · enter open" : "up/down · 1-9 jump · enter open";
+  const lines = [...options.preamble?.(frame) ?? []];
+  lines.push(`${style.dim(top, capabilities)} ${style.strong(truncate(sanitizeTerminalText(options.title), Math.max(8, capabilities.columns - 4)), capabilities)}`);
+  options.options.forEach((option, index) => {
+    const isSelected = index === selected;
+    const pointer = isSelected ? style.accent(glyphs.active, capabilities) : style.dim(option.disabled === true ? glyphs.skipped : glyphs.pending, capabilities);
+    const number = style.dim(`[${String(index + 1)}]`, capabilities);
+    const disabled = option.disabled === true ? "  · unavailable" : "";
+    const recommended = option.recommended === true ? "  · recommended" : "";
+    const label = truncate(`${sanitizeTerminalText(option.label)}${disabled}${recommended}`, Math.max(8, capabilities.columns - 10));
+    const styledLabel = option.disabled === true ? style.dim(label, capabilities) : isSelected ? style.strong(label, capabilities) : label;
+    lines.push(`  ${pointer} ${number}  ${styledLabel}`);
+    if (option.description !== undefined) {
+      for (const description of wrap(option.description, Math.max(10, capabilities.columns - 9))) {
+        const descriptionRail = isSelected ? style.accent(rail, capabilities) : " ";
+        lines.push(`  ${descriptionRail}      ${style.dim(description, capabilities)}`);
+      }
+    }
+  });
+  lines.push(`${style.dim(bottom, capabilities)} ${style.dim(help, capabilities)}`);
+  if (compact) {
+    lines.push(`   ${style.dim("esc close", capabilities)}`);
+  } else {
+    lines[lines.length - 1] += style.dim(" · esc close", capabilities);
+  }
+  for (const line of lines) {
+    sink.write(`\x1B[2K${line}
+`);
+  }
+  return lines.length;
+}
+async function selectOne(options) {
+  if (!options.capabilities.interactive || options.input.setRawMode === undefined) {
+    return { kind: "unavailable" };
+  }
+  let selected = initialIndex(options.options);
+  if (selected === -1) {
+    return { kind: "unavailable" };
+  }
+  return await new Promise((resolve) => {
+    const wasRaw = options.input.isRaw === true;
+    let lineCount = 0;
+    let frame = 0;
+    let settled = false;
+    let refreshTimer;
+    const attempt = (operation) => {
+      try {
+        operation();
+      } catch {}
+    };
+    const cleanup = () => {
+      attempt(() => options.input.off("data", onData));
+      attempt(() => options.signal?.removeEventListener("abort", onAbort));
+      if (refreshTimer !== undefined) {
+        clearInterval(refreshTimer);
+      }
+      if (!wasRaw) {
+        attempt(() => options.input.setRawMode?.(false));
+      }
+      attempt(() => options.input.pause());
+      attempt(() => options.sink.write("\x1B[?25h"));
+    };
+    const settle = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    const draw = () => {
+      lineCount = renderMenu(options, selected, lineCount, frame);
+    };
+    const onAbort = () => settle({ kind: "cancelled", reason: "signal" });
+    const onData = (chunk) => {
+      const input = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+      if (input.includes("\x03")) {
+        settle({ kind: "cancelled", reason: "interrupt" });
+        return;
+      }
+      if (input === "\x1B") {
+        settle({ kind: "cancelled", reason: "escape" });
+        return;
+      }
+      if (input.includes("\x1B[A")) {
+        selected = nextEnabled(options.options, selected, -1);
+        draw();
+        return;
+      }
+      if (input.includes("\x1B[B")) {
+        selected = nextEnabled(options.options, selected, 1);
+        draw();
+        return;
+      }
+      const shortcut = input.match(/^[1-9]$/u);
+      if (shortcut !== null) {
+        const index = Number(shortcut[0]) - 1;
+        if (options.options[index] !== undefined && options.options[index]?.disabled !== true) {
+          selected = index;
+          draw();
+        }
+        return;
+      }
+      if (input.includes("\r") || input.includes(`
+`)) {
+        const selectedOption = options.options[selected];
+        if (selectedOption !== undefined && selectedOption.disabled !== true) {
+          settle({ kind: "selected", value: selectedOption.value });
+        }
+      }
+    };
+    try {
+      options.sink.write("\x1B[?25l");
+      options.input.setRawMode?.(true);
+      options.input.resume();
+      options.input.on("data", onData);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      draw();
+      if (options.preamble !== undefined && options.capabilities.animation) {
+        refreshTimer = setInterval(() => {
+          frame += 1;
+          draw();
+        }, Math.max(32, options.refreshIntervalMs ?? 90));
+      }
+    } catch {
+      settle({ kind: "unavailable" });
+      return;
+    }
+    if (options.signal?.aborted) {
+      onAbort();
+    }
+  });
+}
+
+// src/ui/home.ts
+function fit(value, width) {
+  if (value.length <= width) {
+    return value.padEnd(width);
+  }
+  return width <= 3 ? value.slice(0, width) : `${value.slice(0, width - 3)}...`;
+}
+function productPanel(version, capabilities) {
+  const unicode = capabilities.unicode;
+  const width = 36;
+  const inner = width - 4;
+  const top = unicode ? `╭─${"─".repeat(width - 4)}╮` : `+-${"-".repeat(width - 4)}+`;
+  const bottom = unicode ? `╰${"─".repeat(width - 2)}╯` : `+${"-".repeat(width - 2)}+`;
+  const side = unicode ? "│" : "|";
+  const rows = [
+    "ADB READY",
+    "Android setup. No guesswork.",
+    "",
+    "CHECK  ADB and your local setup",
+    "SEE    every visible target",
+    "USE    human or JSON output",
+    "",
+    `adb-ready  v${version}`
+  ];
+  return [
+    style.dim(top, capabilities),
+    ...rows.map((row, index) => {
+      const content = fit(row, inner);
+      const styled = index === 0 ? style.strong(content, capabilities) : index === 1 ? style.accent(content, capabilities) : style.dim(content, capabilities);
+      return `${style.dim(side, capabilities)} ${styled} ${style.dim(side, capabilities)}`;
+    }),
+    style.dim(bottom, capabilities)
+  ];
+}
+function center(value, width) {
+  const padding = Math.max(0, Math.floor((width - value.length) / 2));
+  return `${" ".repeat(padding)}${value}`;
+}
+function homePreamble(frame, version, capabilities) {
+  const angleX = 0.38 + Math.sin(frame * 0.035) * 0.12;
+  const angleY = frame * 0.045;
+  if (capabilities.columns < 76) {
+    const width = Math.max(20, Math.min(34, capabilities.columns - 4));
+    const core2 = renderLinkCoreFrame({ angleX, angleY, width, height: 12 });
+    return [
+      ...core2.map((line) => style.accent(center(line, capabilities.columns), capabilities)),
+      "",
+      style.strong(center("ADB READY", capabilities.columns), capabilities),
+      style.dim(center("Android setup. No guesswork.", capabilities.columns), capabilities),
+      style.dim(center(`v${version}`, capabilities.columns), capabilities),
+      ""
+    ];
+  }
+  const coreWidth = 36;
+  const core = renderLinkCoreFrame({ angleX, angleY, width: coreWidth, height: 14 });
+  const panel = productPanel(version, capabilities);
+  const panelOffset = 2;
+  return core.map((line, index) => {
+    const left = style.accent(line.padEnd(coreWidth), capabilities);
+    const right = index >= panelOffset ? panel[index - panelOffset] ?? "" : "";
+    return `${left}    ${right}`.trimEnd();
+  }).concat("");
+}
+var COMPACT_WORDMARK = [
+  " ##  ###  ###    ###  ####  ##  ###  #  #",
+  "#  # #  # #  #   #  # #    #  # #  # #  #",
+  "#### #  # ###    ###  ###  #### #  #  ## ",
+  "#  # #  # #  #   # #  #    #  # #  #  #  ",
+  "#  # ###  ###    #  # #### #  # ###   #  "
+];
+function compactSessionPreamble(capabilities) {
+  const unicode = capabilities.unicode;
+  const width = Math.max(20, Math.min(45, capabilities.columns));
+  const inner = width - 4;
+  const top = unicode ? `╭${"─".repeat(width - 2)}╮` : `+${"-".repeat(width - 2)}+`;
+  const bottom = unicode ? `╰${"─".repeat(width - 2)}╯` : `+${"-".repeat(width - 2)}+`;
+  const side = unicode ? "│" : "|";
+  const wordmark = width >= 45 ? COMPACT_WORDMARK : ["ADB READY"];
+  const rows = wordmark.map((line) => {
+    const content = fit(center(line, inner), inner);
+    return `${style.dim(side, capabilities)} ${style.accent(content, capabilities)} ${style.dim(side, capabilities)}`;
+  });
+  return ["", style.dim(top, capabilities), ...rows, style.dim(bottom, capabilities), ""];
+}
+function clearInteractiveScreen(sink, capabilities) {
+  if (capabilities.interactive) {
+    sink.write("\x1B[2J\x1B[H");
+  }
+}
+async function showHomeScreen(options) {
+  if (!options.capabilities.interactive) {
+    return { kind: "unavailable" };
+  }
+  const presentation = options.presentation ?? "full";
+  if (presentation === "full") {
+    clearInteractiveScreen(options.sink, options.capabilities);
+  }
+  const selection = await selectOne({
+    title: presentation === "full" ? "WHAT DO YOU WANT TO DO?" : "ACTIONS",
+    options: [
+      {
+        value: "doctor",
+        label: "Check my setup",
+        description: "Validate runtime, ADB, server, and target access",
+        recommended: true
+      },
+      {
+        value: "devices",
+        label: "Show Android targets",
+        description: "See connected devices and running emulators"
+      },
+      {
+        value: "version",
+        label: "Show version",
+        description: `ADB Ready ${options.version}`
+      },
+      {
+        value: "help",
+        label: "View command reference",
+        description: "Explore commands, flags, and automation output"
+      },
+      { value: "exit", label: "Exit", description: "Close ADB Ready" }
+    ],
+    input: options.input,
+    sink: options.sink,
+    capabilities: presentation === "full" ? options.capabilities : { ...options.capabilities, animation: false },
+    preamble: (frame) => presentation === "full" ? homePreamble(frame, options.version, options.capabilities) : compactSessionPreamble(options.capabilities),
+    ...options.refreshIntervalMs === undefined ? {} : { refreshIntervalMs: options.refreshIntervalMs },
+    ...options.signal === undefined ? {} : { signal: options.signal }
+  });
+  if (selection.kind === "unavailable") {
+    return selection;
+  }
+  if (selection.kind === "cancelled") {
+    return selection.reason === "escape" ? { kind: "action", action: "exit" } : { kind: "cancelled", reason: selection.reason };
+  }
+  return { kind: "action", action: selection.value };
+}
+
+// src/ui/spinner.ts
+var scheduler = {
+  setInterval: (callback, milliseconds) => setInterval(callback, milliseconds),
+  clearInterval: (handle) => clearInterval(handle)
+};
+
+class Spinner {
+  #sink;
+  #capabilities;
+  #scheduler;
+  #timer;
+  #frame = 0;
+  #message = "";
+  #cursorHidden = false;
+  constructor(sink, capabilities, timerScheduler = scheduler) {
+    this.#sink = sink;
+    this.#capabilities = capabilities;
+    this.#scheduler = timerScheduler;
+  }
+  start(message) {
+    this.stopAnimation();
+    this.#message = sanitizeTerminalText(message);
+    if (!this.#capabilities.animation) {
+      return;
+    }
+    this.hideCursor();
+    this.drawFrame();
+    this.#timer = this.#scheduler.setInterval(() => this.drawFrame(), 80);
+  }
+  succeed(message = this.#message) {
+    this.finish("success", message);
+  }
+  fail(message = this.#message) {
+    this.finish("failure", message);
+  }
+  warn(message = this.#message) {
+    this.finish("warning", message);
+  }
+  dispose() {
+    this.stopAnimation();
+    this.showCursor();
+  }
+  finish(status, message) {
+    this.stopAnimation();
+    if (this.#capabilities.animation) {
+      this.#sink.write("\r\x1B[2K");
+    }
+    const glyphs = symbols(this.#capabilities);
+    const symbol = status === "success" ? style.success(glyphs.success, this.#capabilities) : status === "warning" ? style.warning(glyphs.warning, this.#capabilities) : style.failure(glyphs.failure, this.#capabilities);
+    this.#sink.write(`${symbol} ${sanitizeTerminalText(message)}
+`);
+    this.showCursor();
+  }
+  drawFrame() {
+    const frames = this.#capabilities.unicode ? ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] : ["-", "\\", "|", "/"];
+    const frame = frames[this.#frame % frames.length] ?? frames[0] ?? ">";
+    this.#frame += 1;
+    this.#sink.write(`\r\x1B[2K${style.accent(frame, this.#capabilities)} ${this.#message}`);
+  }
+  stopAnimation() {
+    if (this.#timer !== undefined) {
+      this.#scheduler.clearInterval(this.#timer);
+      this.#timer = undefined;
+    }
+  }
+  hideCursor() {
+    if (!this.#cursorHidden) {
+      this.#sink.write("\x1B[?25l");
+      this.#cursorHidden = true;
+    }
+  }
+  showCursor() {
+    if (this.#cursorHidden) {
+      this.#sink.write("\x1B[?25h");
+      this.#cursorHidden = false;
+    }
+  }
+}
+
+// src/ui/progress-renderer.ts
+class ProgressRenderer {
+  #spinner;
+  #unsubscribe;
+  #verbose;
+  #sink;
+  constructor(options) {
+    this.#sink = options.sink;
+    this.#verbose = options.verbose ?? false;
+    this.#spinner = new Spinner(options.sink, options.capabilities, options.scheduler);
+    this.#unsubscribe = options.bus.subscribe((event) => this.onEvent(event));
+  }
+  dispose() {
+    this.#unsubscribe();
+    this.#spinner.dispose();
+  }
+  onEvent(event) {
+    if (event.type === "operation.started") {
+      this.#spinner.start(event.message);
+    } else if (event.type === "operation.completed") {
+      this.#spinner.succeed(event.message.replace(/ completed$/u, ""));
+    } else if (event.type === "operation.failed") {
+      this.#spinner.fail(event.message.replace(/ failed$/u, ""));
+    } else if (this.#verbose) {
+      this.#sink.write(`› ${event.message}
+`);
+    }
+  }
+}
+
+// src/ui/result-renderer.ts
+function clean(value) {
+  return sanitizeTerminalText(String(value));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDoctorData(value) {
+  return isRecord(value) && isRecord(value.runtime) && isRecord(value.adb) && Array.isArray(value.devices);
+}
+function hasDevices(value) {
+  return isRecord(value) && Array.isArray(value.devices);
+}
+function deviceLabel(device) {
+  const identity = device.model ?? device.product ?? device.device;
+  return identity === undefined ? `${clean(device.serial)} · ${clean(device.state)}` : `${clean(identity)} · ${clean(device.serial)} · ${clean(device.state)}`;
+}
+function problemLines(problem, capabilities, verbose) {
+  const glyphs = symbols(capabilities);
+  const marker = problem.severity === "error" ? style.failure(glyphs.failure, capabilities) : style.warning(glyphs.warning, capabilities);
+  const lines = [
+    `${marker} ${style.strong(clean(problem.summary), capabilities)}`,
+    `  ${clean(problem.detail)}`
+  ];
+  const action = problem.actions[0];
+  if (action !== undefined) {
+    lines.push(`  ${style.accent("Next:", capabilities)} ${clean(action.title)}`);
+  }
+  if (verbose) {
+    for (const evidence of problem.evidence) {
+      const field = evidence.field === undefined ? evidence.source : `${evidence.source}.${evidence.field}`;
+      lines.push(`  ${style.dim(`${clean(field)}: ${clean(JSON.stringify(evidence.value))}`, capabilities)}`);
+    }
+  }
+  return lines;
+}
+function renderHuman(result, options) {
+  const { capabilities, sink } = options;
+  const glyphs = symbols(capabilities);
+  const lines = [];
+  lines.push(`${style.strong("ADB Ready", capabilities)} ${style.dim(`· ${clean(result.command)}`, capabilities)}`, "");
+  if (result.command === "doctor" && isDoctorData(result.data)) {
+    const data = result.data;
+    const runtime = `${data.runtime.name} ${data.runtime.version}`;
+    const adbVersion = data.adb.version.platformToolsVersion ?? "unknown version";
+    lines.push(`${style.success(glyphs.success, capabilities)} Runtime  ${clean(runtime)} · ${clean(data.runtime.platform)}/${clean(data.runtime.architecture)}`, `${style.success(glyphs.success, capabilities)} ADB      Platform-Tools ${clean(adbVersion)}`, `${style.success(glyphs.success, capabilities)} Path     ${clean(data.adb.path)}`, `${style.success(glyphs.success, capabilities)} Features ${String(data.adb.hostFeatures.length)} detected`, "");
+  }
+  if (hasDevices(result.data)) {
+    const devices = result.data.devices;
+    lines.push(style.strong(`Targets (${String(devices.length)})`, capabilities));
+    if (devices.length === 0) {
+      lines.push(`${style.dim(glyphs.end, capabilities)} None visible`);
+    } else {
+      devices.forEach((device, index) => {
+        const branch = index === devices.length - 1 ? glyphs.end : glyphs.branch;
+        lines.push(`${style.dim(branch, capabilities)} ${deviceLabel(device)}`);
+      });
+    }
+    if ("selected" in result.data && result.data.selected !== undefined) {
+      lines.push(`${style.accent(glyphs.active, capabilities)} Selected ${deviceLabel(result.data.selected)}`);
+    }
+  }
+  if (result.problems.length > 0) {
+    lines.push("", style.strong("Diagnostics", capabilities));
+    for (const problem of result.problems) {
+      lines.push(...problemLines(problem, capabilities, options.verbose ?? false));
+    }
+  }
+  const status = result.ok ? `${style.success(glyphs.success, capabilities)} Completed in ${String(result.durationMs)}ms` : `${style.failure(glyphs.failure, capabilities)} Failed in ${String(result.durationMs)}ms`;
+  lines.push("", status);
+  sink.write(`${lines.join(`
+`)}
+`);
+}
+function renderPlain(result, sink) {
+  sink.write(`command=${clean(result.command)}
+`);
+  sink.write(`ok=${String(result.ok)}
+`);
+  sink.write(`duration_ms=${String(result.durationMs)}
+`);
+  if (isDoctorData(result.data)) {
+    const data = result.data;
+    sink.write(`runtime=${clean(data.runtime.name)}
+`);
+    sink.write(`runtime_version=${clean(data.runtime.version)}
+`);
+    sink.write(`adb_version=${clean(data.adb.version.platformToolsVersion ?? "unknown")}
+`);
+  }
+  if (hasDevices(result.data)) {
+    sink.write(`device_count=${String(result.data.devices.length)}
+`);
+    result.data.devices.forEach((device, index) => {
+      sink.write(`device_${String(index)}=${deviceLabel(device)}
+`);
+    });
+    if ("selected" in result.data && result.data.selected !== undefined) {
+      sink.write(`selected=${deviceLabel(result.data.selected)}
+`);
+    }
+  }
+  for (const problem of result.problems) {
+    sink.write(`problem=${clean(problem.code)}:${clean(problem.summary)}
+`);
+  }
+}
+function renderResult(result, options) {
+  if (options.format === "json") {
+    options.sink.write(`${JSON.stringify(result)}
+`);
+  } else if (options.format === "ndjson") {
+    options.sink.write(`${JSON.stringify({ kind: "result", ...result })}
+`);
+  } else if (options.format === "plain") {
+    renderPlain(result, options.sink);
+  } else {
+    renderHuman(result, options);
+  }
+}
+
+class NdjsonEventRenderer {
+  #unsubscribe;
+  constructor(bus, sink) {
+    this.#unsubscribe = bus.subscribe((event) => this.write(event, sink));
+  }
+  dispose() {
+    this.#unsubscribe();
+  }
+  write(event, sink) {
+    sink.write(`${JSON.stringify({ kind: "event", ...event })}
+`);
+  }
+}
+
+// src/ui/terminal.ts
+function environmentFlag(value) {
+  if (value === undefined) {
+    return false;
+  }
+  return !["", "0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+function resolveTerminalCapabilities(preferences) {
+  const env = preferences.env ?? {};
+  const human = preferences.format === "human";
+  const dumb = env.TERM?.toLowerCase() === "dumb";
+  const ci = environmentFlag(env.CI);
+  const reducedMotion = environmentFlag(env.ADB_READY_REDUCED_MOTION);
+  const noColorEnvironment = Object.hasOwn(env, "NO_COLOR");
+  const locale = `${env.LC_ALL ?? ""} ${env.LC_CTYPE ?? ""} ${env.LANG ?? ""}`;
+  const localeSupportsUnicode = /UTF-?8/iu.test(locale);
+  const interactive = human && preferences.nonInteractive === false && preferences.interactive !== false && preferences.inputIsTTY && preferences.outputIsTTY && !ci && !dumb;
+  const colorPreference = preferences.color ?? !noColorEnvironment;
+  const unicodePreference = preferences.unicode ?? localeSupportsUnicode;
+  return {
+    interactive,
+    color: human && preferences.outputIsTTY && !dumb && colorPreference,
+    unicode: human && unicodePreference,
+    animation: interactive && preferences.animation !== false && !reducedMotion && !environmentFlag(env.CI),
+    columns: Math.max(20, preferences.columns ?? 80)
+  };
+}
+
+// src/cli/arguments.ts
+var COMMANDS = new Set(["devices", "doctor", "help", "version"]);
+var BOOLEAN_OPTIONS = new Set([
+  "-h",
+  "--help",
+  "-V",
+  "--version",
+  "--json",
+  "--quiet",
+  "--verbose",
+  "--non-interactive",
+  "--color",
+  "--no-color",
+  "--unicode",
+  "--no-unicode",
+  "--animation",
+  "--no-animation",
+  "--select"
+]);
+function failure(code, message, option) {
+  return { ok: false, code, message, ...option === undefined ? {} : { option } };
+}
+function parseDuration(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)(ms|s|m)?$/u);
+  if (match === null) {
+    return;
+  }
+  const amount = Number(match[1]);
+  const unit = match[2] ?? "ms";
+  const multiplier = unit === "m" ? 60000 : unit === "s" ? 1000 : 1;
+  const milliseconds = amount * multiplier;
+  return Number.isSafeInteger(milliseconds) && milliseconds > 0 ? milliseconds : undefined;
+}
+function splitLongOption(argument) {
+  const separator = argument.indexOf("=");
+  if (separator === -1) {
+    return { option: argument };
+  }
+  return { option: argument.slice(0, separator), inlineValue: argument.slice(separator + 1) };
+}
+function parseArguments(argv) {
+  let command;
+  let helpTarget;
+  let format = "human";
+  let quiet = false;
+  let verbose = false;
+  let nonInteractive = false;
+  let color2;
+  let unicode;
+  let animation;
+  let timeoutMs;
+  let adbPath;
+  let adbHost;
+  let adbPort;
+  let configPath;
+  let select = false;
+  for (let index = 0;index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === undefined) {
+      continue;
+    }
+    if (!argument.startsWith("-")) {
+      if (!COMMANDS.has(argument)) {
+        return failure("CLI_USAGE", `Unknown command: ${argument}`);
+      }
+      const candidate = argument;
+      if (command === undefined) {
+        command = candidate;
+        continue;
+      }
+      if (command === "help" && (candidate === "doctor" || candidate === "devices")) {
+        helpTarget = candidate;
+        continue;
+      }
+      return failure("CLI_USAGE", `Unexpected argument: ${argument}`);
+    }
+    const { option, inlineValue } = splitLongOption(argument);
+    if (inlineValue !== undefined && BOOLEAN_OPTIONS.has(option)) {
+      return failure("CLI_INVALID_OPTION", `${option} does not accept a value.`, option);
+    }
+    const readValue = () => {
+      if (inlineValue !== undefined) {
+        return inlineValue;
+      }
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith("-")) {
+        return failure("CLI_INVALID_VALUE", `${option} requires a value.`, option);
+      }
+      index += 1;
+      return value;
+    };
+    if (option === "-h" || option === "--help") {
+      if (command === "doctor" || command === "devices") {
+        helpTarget = command;
+      }
+      command = "help";
+    } else if (option === "-V" || option === "--version") {
+      command = "version";
+    } else if (option === "--json") {
+      format = "json";
+    } else if (option === "--format") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      if (!new Set(["human", "json", "ndjson", "plain"]).has(value)) {
+        return failure("CLI_INVALID_VALUE", `Invalid format: ${value}. Expected human, plain, json, or ndjson.`, option);
+      }
+      format = value;
+    } else if (option === "--quiet") {
+      quiet = true;
+    } else if (option === "--verbose") {
+      verbose = true;
+    } else if (option === "--non-interactive") {
+      nonInteractive = true;
+    } else if (option === "--color") {
+      color2 = true;
+    } else if (option === "--no-color") {
+      color2 = false;
+    } else if (option === "--unicode") {
+      unicode = true;
+    } else if (option === "--no-unicode") {
+      unicode = false;
+    } else if (option === "--animation") {
+      animation = true;
+    } else if (option === "--no-animation") {
+      animation = false;
+    } else if (option === "--select") {
+      select = true;
+    } else if (option === "--timeout") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      timeoutMs = parseDuration(value);
+      if (timeoutMs === undefined) {
+        return failure("CLI_INVALID_VALUE", `Invalid timeout: ${value}. Use a positive duration such as 500ms, 5s, or 1m.`, option);
+      }
+    } else if (option === "--adb") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      if (value.trim() === "") {
+        return failure("CLI_INVALID_VALUE", "--adb cannot be empty.", option);
+      }
+      adbPath = value;
+    } else if (option === "--adb-host") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      if (value.trim() === "") {
+        return failure("CLI_INVALID_VALUE", "--adb-host cannot be empty.", option);
+      }
+      adbHost = value;
+    } else if (option === "--adb-port") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      const parsed = Number(value);
+      if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 65535) {
+        return failure("CLI_INVALID_VALUE", `Invalid ADB server port: ${value}.`, option);
+      }
+      adbPort = parsed;
+    } else if (option === "--config") {
+      const value = readValue();
+      if (typeof value !== "string") {
+        return value;
+      }
+      if (value.trim() === "") {
+        return failure("CLI_INVALID_VALUE", "--config cannot be empty.", option);
+      }
+      configPath = value;
+    } else {
+      return failure("CLI_INVALID_OPTION", `Unknown option: ${option}`, option);
+    }
+  }
+  if (quiet && verbose) {
+    return failure("CLI_USAGE", "--quiet and --verbose cannot be used together.");
+  }
+  command ??= "help";
+  if (select && command !== "devices") {
+    return failure("CLI_USAGE", "--select can only be used with the devices command.", "--select");
+  }
+  if (select && nonInteractive) {
+    return failure("CLI_USAGE", "--select cannot be combined with --non-interactive.", "--select");
+  }
+  if (select && format !== "human") {
+    return failure("CLI_USAGE", "--select can only be used with human output.", "--select");
+  }
+  return {
+    ok: true,
+    options: {
+      command,
+      ...helpTarget === undefined ? {} : { helpTarget },
+      format,
+      quiet,
+      verbose,
+      nonInteractive,
+      ...color2 === undefined ? {} : { color: color2 },
+      ...unicode === undefined ? {} : { unicode },
+      ...animation === undefined ? {} : { animation },
+      ...timeoutMs === undefined ? {} : { timeoutMs },
+      ...adbPath === undefined ? {} : { adbPath },
+      ...adbHost === undefined ? {} : { adbHost },
+      ...adbPort === undefined ? {} : { adbPort },
+      ...configPath === undefined ? {} : { configPath },
+      select
+    }
+  };
+}
+
+// src/cli/main.ts
+var VERSION = package_default.version;
+var HELP = `ADB Ready
+
+Make an Android target ready, then keep the development session working.
+
+Usage:
+  adb-ready [command] [options]
+  adbr [command] [options]
+
+Commands:
+  doctor                 Inspect the local ADB environment
+  devices                List visible Android targets
+  help [doctor|devices]  Show help
+  version                Show version
+
+Output:
+  --format FORMAT        human, plain, json, or ndjson
+  --json                 Alias for --format json
+  --quiet                Hide successful human output
+  --verbose              Include diagnostic evidence
+  --[no-]color           Override color detection
+  --[no-]unicode         Override Unicode detection
+  --[no-]animation       Override motion detection
+
+Execution:
+  --non-interactive      Never prompt or control the terminal
+  --timeout DURATION     Positive duration such as 500ms, 5s, or 1m
+  --adb PATH             Use an explicit ADB executable
+  --adb-host HOST        Use an explicit ADB server host
+  --adb-port PORT        Use an explicit ADB server port
+  --config PATH          Use an explicit project configuration file
+  --select               Interactively select from listed devices
+
+Other:
+  -h, --help             Show help
+  -V, --version          Show version
+`;
+var COMMAND_HELP = {
+  doctor: `Usage: adb-ready doctor [options]
+
+Runs read-only host, ADB capability, server, and target diagnostics.
+`,
+  devices: `Usage: adb-ready devices [options]
+
+Lists every target visible to ADB. Add --select to open the keyboard picker.
+`
+};
+function inferredFormat(argv) {
+  let format = "human";
+  for (let index = 0;index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--json") {
+      format = "json";
+    } else if (argument?.startsWith("--format=")) {
+      const value = argument.slice("--format=".length);
+      if (value === "human" || value === "plain" || value === "json" || value === "ndjson") {
+        format = value;
+      }
+    } else if (argument === "--format") {
+      const value = argv[index + 1];
+      if (value === "human" || value === "plain" || value === "json" || value === "ndjson") {
+        format = value;
+      }
+      index += 1;
+    }
+  }
+  return format;
+}
+function capabilities(options, values, io, target, fallbackFormat) {
+  const stream = target === "error" ? io.error : io.output;
+  return resolveTerminalCapabilities({
+    format: options?.format ?? fallbackFormat,
+    nonInteractive: options?.nonInteractive === true || values.interactive === false,
+    ...values.color === undefined ? {} : { color: values.color },
+    ...values.unicode === undefined ? {} : { unicode: values.unicode },
+    ...values.animation === undefined ? {} : { animation: values.animation },
+    ...values.interactive === undefined ? {} : { interactive: values.interactive },
+    env: io.env,
+    inputIsTTY: io.input.isTTY === true,
+    outputIsTTY: stream.isTTY === true,
+    ...stream.columns === undefined ? {} : { columns: stream.columns }
+  });
+}
+function failureResult(command, problems, dependencies) {
+  const clock = dependencies.clock ?? (() => new Date);
+  const now = clock();
+  const commandId = (dependencies.idFactory ?? randomUUID3)();
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    command,
+    commandId,
+    ok: false,
+    startedAt: now.toISOString(),
+    finishedAt: now.toISOString(),
+    durationMs: 0,
+    data: null,
+    problems: problems.map((problem) => ({
+      ...problem,
+      correlation: { ...problem.correlation, commandId }
+    }))
+  };
+}
+function inputProblem(code, summary, detail, commandId = "cli") {
+  return {
+    code,
+    category: "input.cli",
+    severity: "error",
+    summary,
+    detail,
+    retryable: true,
+    evidence: [],
+    actions: [],
+    correlation: { commandId }
+  };
+}
+function configProblems(errors) {
+  return errors.map((error2) => ({
+    code: error2.code,
+    category: "input.configuration",
+    severity: "error",
+    summary: error2.message,
+    detail: `Invalid ${error2.source} configuration at ${error2.path}.`,
+    retryable: true,
+    evidence: [
+      { source: "configuration", field: "path", value: error2.path },
+      ...error2.location === undefined ? [] : [
+        {
+          source: "configuration",
+          field: "location",
+          value: redactText(error2.location).value
+        }
+      ]
+    ],
+    actions: [],
+    correlation: { commandId: "configuration" }
+  }));
+}
+function renderFailure(result, format, io) {
+  renderResult(result, {
+    format,
+    capabilities: capabilities(undefined, {}, io, "output", format),
+    sink: format === "human" ? io.error : io.output,
+    verbose: false
+  });
+}
+function cliConfig(options) {
+  return {
+    ...options.adbPath === undefined ? {} : { adbPath: options.adbPath },
+    ...options.adbHost === undefined ? {} : { adbHost: options.adbHost },
+    ...options.adbPort === undefined ? {} : { adbPort: options.adbPort },
+    ...options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs },
+    ...options.color === undefined ? {} : { color: options.color },
+    ...options.unicode === undefined ? {} : { unicode: options.unicode },
+    ...options.animation === undefined ? {} : { animation: options.animation },
+    ...options.nonInteractive ? { interactive: false } : {}
+  };
+}
+function selectionProblem(result, commandId) {
+  if (result === "interrupt" || result === "signal") {
+    return {
+      problem: inputProblem(ProblemCode.OperationInterrupted, "Target selection was interrupted.", "Run the command again when you are ready to select a target.", commandId),
+      exitCode: 130 /* Interrupted */
+    };
+  }
+  if (result === "unavailable") {
+    return {
+      problem: inputProblem(ProblemCode.InteractiveSelectionUnavailable, "Interactive target selection is unavailable.", "Run this command in a capable terminal or omit --select.", commandId),
+      exitCode: 2 /* InvalidInput */
+    };
+  }
+  return {
+    problem: inputProblem(ProblemCode.TargetSelectionCancelled, "Target selection was cancelled.", "No target was selected.", commandId),
+    exitCode: 2 /* InvalidInput */
+  };
+}
+async function runInteractiveSession(io, dependencies, terminal, signal) {
+  let presentation = "full";
+  while (true) {
+    const home = await showHomeScreen({
+      version: VERSION,
+      input: io.input,
+      sink: io.error,
+      capabilities: terminal,
+      presentation,
+      ...signal === undefined ? {} : { signal }
+    });
+    if (home.kind === "cancelled") {
+      return 130 /* Interrupted */;
+    }
+    if (home.kind !== "action") {
+      return 2 /* InvalidInput */;
+    }
+    if (home.action === "exit") {
+      return 0 /* Success */;
+    }
+    clearInteractiveScreen(io.error, terminal);
+    await runCliInternal([home.action], io, dependencies, signal);
+    if (signal?.aborted === true) {
+      return 130 /* Interrupted */;
+    }
+    presentation = "menu";
+  }
+}
+async function selectDevice(execution, io, terminal, signal) {
+  const data = execution.result.data;
+  if (data === null) {
+    return execution;
+  }
+  const selectable = data.devices.filter(({ state }) => state === "device");
+  if (selectable.length === 0) {
+    const problem = inputProblem(ProblemCode.NoSelectableTarget, "No ready Android target can be selected.", "Connect or recover a target until ADB reports the device state.", execution.result.commandId);
+    return {
+      exitCode: 20 /* Target */,
+      result: { ...execution.result, ok: false, problems: [...execution.result.problems, problem] }
+    };
+  }
+  const selection = await selectOne({
+    title: "Select an Android target",
+    options: data.devices.map((device) => ({
+      value: device,
+      label: device.model ?? device.serial,
+      description: `${device.serial} · ${device.state}`,
+      disabled: device.state !== "device",
+      recommended: selectable.length === 1 && device.serial === selectable[0]?.serial
+    })),
+    input: io.input,
+    sink: io.error,
+    capabilities: terminal,
+    ...signal === undefined ? {} : { signal }
+  });
+  if (selection.kind === "selected") {
+    return {
+      ...execution,
+      result: {
+        ...execution.result,
+        data: { ...data, selected: selection.value }
+      }
+    };
+  }
+  const failure2 = selectionProblem(selection.kind === "unavailable" ? "unavailable" : selection.reason, execution.result.commandId);
+  return {
+    exitCode: failure2.exitCode,
+    result: {
+      ...execution.result,
+      ok: false,
+      problems: [...execution.result.problems, failure2.problem]
+    }
+  };
+}
+async function runCliInternal(argv, io, dependencies = {}, signal) {
+  const fallbackFormat = inferredFormat(argv);
+  let effectiveArgv = argv;
+  if (argv.length === 0) {
+    const homeCapabilities = capabilities(undefined, {}, io, "error", "human");
+    if (homeCapabilities.interactive) {
+      return await runInteractiveSession(io, dependencies, homeCapabilities, signal);
+    } else {
+      effectiveArgv = ["help"];
+    }
+  }
+  const parsed = parseArguments(effectiveArgv);
+  if (!parsed.ok) {
+    const failure2 = failureResult("cli", [inputProblem(parsed.code, parsed.message, "Run adb-ready --help for usage.")], dependencies);
+    renderFailure(failure2, fallbackFormat, io);
+    return 2 /* InvalidInput */;
+  }
+  const options = parsed.options;
+  if (options.command === "help") {
+    io.output.write(options.helpTarget === undefined ? HELP : COMMAND_HELP[options.helpTarget]);
+    return 0 /* Success */;
+  }
+  if (options.command === "version") {
+    io.output.write(`${VERSION}
+`);
+    return 0 /* Success */;
+  }
+  const loaded = await (dependencies.loadConfig ?? loadConfig)({
+    cwd: io.cwd,
+    env: io.env,
+    ...options.configPath === undefined ? {} : { projectConfigPath: options.configPath },
+    explicitProjectConfig: options.configPath !== undefined,
+    cli: cliConfig(options)
+  });
+  if (!loaded.ok) {
+    const failure2 = failureResult(options.command, configProblems(loaded.errors), dependencies);
+    renderFailure(failure2, options.format, io);
+    return 2 /* InvalidInput */;
+  }
+  const values = loaded.config.values;
+  const errorCapabilities = capabilities(options, values, io, "error", options.format);
+  const outputCapabilities = capabilities(options, values, io, "output", options.format);
+  const bus = dependencies.bus ?? new EventBus(dependencies.clock);
+  const progress = options.format === "human" && !options.quiet ? new ProgressRenderer({
+    bus,
+    sink: io.error,
+    capabilities: errorCapabilities,
+    verbose: options.verbose
+  }) : undefined;
+  const events = options.format === "ndjson" ? new NdjsonEventRenderer(bus, io.output) : undefined;
+  const commandDependencies = { ...dependencies, bus };
+  const config = {
+    ...values.adbPath === undefined ? {} : { adbPath: values.adbPath },
+    ...values.adbHost === undefined ? {} : { adbHost: values.adbHost },
+    ...values.adbPort === undefined ? {} : { adbPort: values.adbPort },
+    timeoutMs: values.timeoutMs
+  };
+  let execution;
+  try {
+    execution = options.command === "doctor" ? await runDoctor(config, commandDependencies, signal) : await runDevices(config, commandDependencies, signal);
+  } finally {
+    progress?.dispose();
+    events?.dispose();
+  }
+  if (options.command === "devices" && options.select) {
+    execution = await selectDevice(execution, io, errorCapabilities, signal);
+  }
+  if (options.format !== "human" || !options.quiet || !execution.result.ok) {
+    const human = options.format === "human";
+    renderResult(execution.result, {
+      format: options.format,
+      capabilities: human ? errorCapabilities : outputCapabilities,
+      sink: human ? io.error : io.output,
+      verbose: options.verbose
+    });
+  }
+  return execution.exitCode;
+}
+async function runCli(argv, io, dependencies = {}, signal) {
+  try {
+    return await runCliInternal(argv, io, dependencies, signal);
+  } catch (caught) {
+    const message = redactText(caught instanceof Error ? caught.message : String(caught)).value;
+    const problem = {
+      code: "INTERNAL_ERROR",
+      category: "internal.unexpected",
+      severity: "error",
+      summary: "ADB Ready encountered an unexpected internal error.",
+      detail: "The operation stopped safely. Re-run with --verbose when reporting this issue.",
+      retryable: false,
+      evidence: message === "" ? [] : [{ source: "internal", field: "message", value: message }],
+      actions: [],
+      correlation: { commandId: "cli" }
+    };
+    renderFailure(failureResult("cli", [problem], dependencies), inferredFormat(argv), io);
+    return 70 /* Internal */;
+  }
+}
+function processIo() {
+  return {
+    input: process5.stdin,
+    output: process5.stdout,
+    error: process5.stderr,
+    cwd: process5.cwd(),
+    env: process5.env
+  };
+}
+
+// src/cli.ts
+var controller = new AbortController;
+var abort = () => controller.abort();
+process6.once("SIGINT", abort);
+process6.once("SIGTERM", abort);
+try {
+  process6.exitCode = await runCli(process6.argv.slice(2), processIo(), {}, controller.signal);
+} finally {
+  process6.removeListener("SIGINT", abort);
+  process6.removeListener("SIGTERM", abort);
+}
+
+//# debugId=E7C1326D860AA56164756E2164756E21