appduct 0.10.0 → 0.11.0

package/dist/client/index.js

@@ -1,16 +1,2379 @@
-/**
- * `appduct/client` (issue #8): a first-class programmatic client for test runners — a thin typed
- * wrapper over the same daemon RPC the CLI and MCP server use, so a Jest/Vitest/Detox spec can
- * `connect()`/`call()` instead of spawning `appduct invoke ... --json` and parsing stdout.
- *
- * ```ts
- * import { connect } from "appduct/client";
- *
- * const app = await connect();
- * const { total } = await app.call("sum", { a: 2, b: 3 });
- * await app.close();
- * ```
- */
-export { connect } from "./connect.js";
-export { link, waitForSession } from "./bootstrap.js";
-export { AppductError } from "./errors.js";
+// src/client/connect.ts
+import { RPC_METHODS as RPC_METHODS3 } from "@appduct/shared";
+
+// src/daemon/state-dir.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var resolveStateDir = (override) => {
+  return override ?? process.env.APPDUCT_STATE_DIR ?? join(homedir(), ".appduct");
+};
+var getStateDirPaths = (stateDir) => {
+  return {
+    root: stateDir,
+    socketPath: join(stateDir, "daemon.sock"),
+    pidFilePath: join(stateDir, "daemon.pid"),
+    logFilePath: join(stateDir, "daemon.log"),
+    keyPath: join(stateDir, "key.pem"),
+    configPath: join(stateDir, "config.json"),
+    auditDir: join(stateDir, "audit"),
+    spawnLockPath: join(stateDir, "daemon.spawn.lock")
+  };
+};
+
+// src/rpc/client.ts
+import { connect as connect2 } from "node:net";
+import { spawn as spawnChildProcess } from "node:child_process";
+import { open as open2, readFile as readFile3, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { RPC_METHODS } from "@appduct/shared";
+
+// src/daemon/log-rotation.ts
+import { chmod, rename, stat } from "node:fs/promises";
+
+// src/daemon/config.ts
+import { readFile } from "node:fs/promises";
+var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "wssPort",
+  "keyPath",
+  "graceSeconds",
+  "linkTtlSeconds",
+  "keepaliveIntervalSeconds",
+  "eventBufferSize",
+  "auditRetentionDays",
+  "daemonLogMaxBytes",
+  "policy",
+  "advertisedIp",
+  "scheme",
+  "restartDaemonOnVersionMismatch"
+]);
+var KNOWN_POLICY_KEYS = /* @__PURE__ */ new Set(["default", "destructive", "tools"]);
+var POLICY_DECISIONS = /* @__PURE__ */ new Set(["allow", "deny", "prompt"]);
+var DEFAULT_AUDIT_RETENTION_DAYS = 30;
+var DEFAULT_DAEMON_LOG_MAX_BYTES = 10 * 1024 * 1024;
+var AppductConfigError = class extends Error {
+  constructor(key, message) {
+    super(message);
+    this.key = key;
+    this.name = "AppductConfigError";
+  }
+};
+var configError = (key, message) => {
+  return new AppductConfigError(key, `Invalid Appduct config value for "${key}": ${message}`);
+};
+var requireWssPort = (value, key) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 65535) {
+    throw configError(key, "must be a port number between 0 and 65535 (0 binds an OS-assigned port).");
+  }
+  return value;
+};
+var requirePositiveInteger = (value, key) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw configError(key, "must be a positive integer.");
+  }
+  return value;
+};
+var requireNonEmptyString = (value, key) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw configError(key, "must be a non-empty string.");
+  }
+  return value;
+};
+var requireBoolean = (value, key) => {
+  if (typeof value !== "boolean") {
+    throw configError(key, "must be a boolean.");
+  }
+  return value;
+};
+var requirePolicyDecision = (value, key) => {
+  if (typeof value !== "string" || !POLICY_DECISIONS.has(value)) {
+    throw configError(key, 'must be "allow", "deny", or "prompt".');
+  }
+  return value;
+};
+var defaultConfig = (paths) => {
+  return {
+    wssPort: 8443,
+    keyPath: paths.keyPath,
+    graceSeconds: 600,
+    linkTtlSeconds: 300,
+    keepaliveIntervalSeconds: 15,
+    eventBufferSize: 256,
+    auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
+    daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+    restartDaemonOnVersionMismatch: false,
+    policy: {
+      default: "allow",
+      destructive: "allow"
+    }
+  };
+};
+var loadConfig = async (paths, options = {}) => {
+  const warn = options.warn ?? (() => {
+  });
+  const config = defaultConfig(paths);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(paths.configPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return config;
+    }
+    throw configError("config.json", `could not be read/parsed (${error.message}).`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw configError("config.json", "must be a JSON object.");
+  }
+  const parsed = raw;
+  for (const key of Object.keys(parsed)) {
+    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+      warn(`Unknown Appduct config key "${key}" is ignored.`);
+    }
+  }
+  if (parsed.wssPort !== void 0) {
+    config.wssPort = requireWssPort(parsed.wssPort, "wssPort");
+  }
+  if (parsed.keyPath !== void 0) {
+    config.keyPath = requireNonEmptyString(parsed.keyPath, "keyPath");
+  }
+  if (parsed.advertisedIp !== void 0) {
+    config.advertisedIp = requireNonEmptyString(parsed.advertisedIp, "advertisedIp");
+  }
+  if (parsed.scheme !== void 0) {
+    config.scheme = requireNonEmptyString(parsed.scheme, "scheme");
+  }
+  if (parsed.graceSeconds !== void 0) {
+    config.graceSeconds = requirePositiveInteger(parsed.graceSeconds, "graceSeconds");
+  }
+  if (parsed.linkTtlSeconds !== void 0) {
+    config.linkTtlSeconds = requirePositiveInteger(parsed.linkTtlSeconds, "linkTtlSeconds");
+  }
+  if (parsed.keepaliveIntervalSeconds !== void 0) {
+    config.keepaliveIntervalSeconds = requirePositiveInteger(
+      parsed.keepaliveIntervalSeconds,
+      "keepaliveIntervalSeconds"
+    );
+  }
+  if (parsed.eventBufferSize !== void 0) {
+    config.eventBufferSize = requirePositiveInteger(parsed.eventBufferSize, "eventBufferSize");
+  }
+  if (parsed.auditRetentionDays !== void 0) {
+    config.auditRetentionDays = requirePositiveInteger(parsed.auditRetentionDays, "auditRetentionDays");
+  }
+  if (parsed.daemonLogMaxBytes !== void 0) {
+    config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
+  }
+  if (parsed.restartDaemonOnVersionMismatch !== void 0) {
+    config.restartDaemonOnVersionMismatch = requireBoolean(
+      parsed.restartDaemonOnVersionMismatch,
+      "restartDaemonOnVersionMismatch"
+    );
+  }
+  if (parsed.policy !== void 0) {
+    if (typeof parsed.policy !== "object" || parsed.policy === null || Array.isArray(parsed.policy)) {
+      throw configError("policy", "must be an object.");
+    }
+    const policy = parsed.policy;
+    for (const key of Object.keys(policy)) {
+      if (!KNOWN_POLICY_KEYS.has(key)) {
+        warn(`Unknown Appduct config key "policy.${key}" is ignored.`);
+      }
+    }
+    if (policy.default !== void 0) {
+      config.policy.default = requirePolicyDecision(policy.default, "policy.default");
+    }
+    if (policy.destructive !== void 0) {
+      config.policy.destructive = requirePolicyDecision(policy.destructive, "policy.destructive");
+    }
+    if (policy.tools !== void 0) {
+      if (typeof policy.tools !== "object" || policy.tools === null || Array.isArray(policy.tools)) {
+        throw configError("policy.tools", "must be an object.");
+      }
+      const tools = {};
+      for (const [toolKey, toolValue] of Object.entries(policy.tools)) {
+        tools[toolKey] = requirePolicyDecision(toolValue, `policy.tools["${toolKey}"]`);
+      }
+      config.policy.tools = tools;
+    }
+  }
+  return config;
+};
+
+// src/daemon/pidfile.ts
+import { readFileSync } from "node:fs";
+import { open, readFile as readFile2, rm } from "node:fs/promises";
+var readProcStatus = (pid) => {
+  try {
+    return readFileSync(`/proc/${pid}/status`, "utf8");
+  } catch {
+    return void 0;
+  }
+};
+var isZombie = (pid, readStatus) => {
+  const status = readStatus(pid);
+  if (status === void 0) {
+    return false;
+  }
+  return /^State:\s*Z\b/mu.test(status);
+};
+var isProcessAlive = (pid, readStatus = readProcStatus) => {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+  return !isZombie(pid, readStatus);
+};
+var readPidFromFile = async (pidFilePath) => {
+  let contents;
+  try {
+    contents = await readFile2(pidFilePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const pid = Number.parseInt(contents.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+};
+
+// src/daemon/socket-probe.ts
+import { connect } from "node:net";
+var isSocketConnectable = (socketPath) => {
+  return new Promise((resolve2) => {
+    const socket = connect(socketPath);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve2(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+  });
+};
+
+// src/daemon/log-rotation.ts
+var STATE_FILE_MODE = 384;
+var daemonLogBackupPath = (logFilePath) => `${logFilePath}.1`;
+var isDaemonHoldingLog = async (pidFilePath) => {
+  try {
+    const pid = await readPidFromFile(pidFilePath);
+    return pid !== void 0 && isProcessAlive(pid);
+  } catch {
+    return false;
+  }
+};
+var rotateDaemonLogIfNeeded = async (options) => {
+  const warn = options.warn ?? ((message) => {
+    process.stderr.write(`${message}
+`);
+  });
+  try {
+    const stats = await stat(options.logFilePath);
+    if (!stats.isFile() || stats.size <= options.maxBytes) {
+      return { rotated: false };
+    }
+    const held = options.pidFilePath !== void 0 && await isDaemonHoldingLog(options.pidFilePath) || options.socketPath !== void 0 && await isSocketConnectable(options.socketPath);
+    if (held) {
+      warn(
+        `appduct: "${options.logFilePath}" is over its size cap but a daemon still holds it; leaving it in place.`
+      );
+      return { rotated: false, skipped: "daemon_running" };
+    }
+    const backupPath = daemonLogBackupPath(options.logFilePath);
+    await rename(options.logFilePath, backupPath);
+    try {
+      await chmod(backupPath, STATE_FILE_MODE);
+    } catch (error) {
+      warn(`appduct: rotated "${options.logFilePath}" but could not set 0600 on "${backupPath}": ${error.message}`);
+    }
+    return { rotated: true, rotatedBytes: stats.size };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { rotated: false };
+    }
+    warn(`appduct: failed to rotate "${options.logFilePath}": ${error.message}`);
+    return { rotated: false };
+  }
+};
+var ensureDaemonLogMode = async (logFilePath, warn = (message) => process.stderr.write(`${message}
+`)) => {
+  try {
+    await chmod(logFilePath, STATE_FILE_MODE);
+    return true;
+  } catch (error) {
+    warn(`appduct: could not set 0600 on "${logFilePath}": ${error.message}`);
+    return false;
+  }
+};
+var resolveDaemonLogMaxBytes = async (stateDir) => {
+  try {
+    return (await loadConfig(getStateDirPaths(stateDir))).daemonLogMaxBytes;
+  } catch {
+    return DEFAULT_DAEMON_LOG_MAX_BYTES;
+  }
+};
+
+// src/package-root.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "appduct";
+var cached;
+var getPackageRoot = () => {
+  if (cached !== void 0) {
+    return cached;
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const candidate = join2(dir, "package.json");
+    if (existsSync(candidate)) {
+      let name;
+      try {
+        name = JSON.parse(readFileSync2(candidate, "utf8")).name;
+      } catch {
+      }
+      if (name === PACKAGE_NAME) {
+        cached = dir;
+        return dir;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not locate the "${PACKAGE_NAME}" package root above ${import.meta.url}.`);
+    }
+    dir = parent;
+  }
+};
+
+// src/package-version.ts
+var DAEMON_VERSION_OVERRIDE_ENV = "APPDUCT_DAEMON_VERSION_OVERRIDE";
+
+// src/rpc/client.ts
+var defaultBinPath = join3(getPackageRoot(), "bin.js");
+var DaemonRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "DaemonRpcError";
+  }
+};
+var DaemonUnavailableError = class extends Error {
+  constructor(message, reason = "unreachable") {
+    super(message);
+    this.reason = reason;
+    this.name = "DaemonUnavailableError";
+  }
+};
+var isRequestTimeoutError = (error) => {
+  return error instanceof DaemonUnavailableError && error.reason === "timeout";
+};
+var describeLiveState = (state) => {
+  const parts = [];
+  if (state.sessions > 0) {
+    parts.push(`${state.sessions} connected session(s)`);
+  }
+  if (state.pendingLinks > 0) {
+    parts.push(`${state.pendingLinks} unclaimed link(s)`);
+  }
+  return parts.join(" and ");
+};
+var DaemonVersionMismatchError = class extends Error {
+  constructor(daemonVersion, clientVersion, live, message) {
+    super(
+      message ?? `The running Appduct daemon is version ${daemonVersion}, but this client is version ${clientVersion}. It was not restarted automatically because ${describeLiveState(live)} would be lost. Run "appduct daemon stop" once that state is expendable, or force it with "--daemon-restart".`
+    );
+    this.daemonVersion = daemonVersion;
+    this.clientVersion = clientVersion;
+    this.name = "DaemonVersionMismatchError";
+    this.sessionCount = live.sessions;
+    this.pendingLinkCount = live.pendingLinks;
+  }
+  sessionCount;
+  pendingLinkCount;
+};
+var DaemonVersionRestartIneffectiveError = class extends DaemonVersionMismatchError {
+  constructor(daemonVersion, clientVersion, live) {
+    super(
+      daemonVersion,
+      clientVersion,
+      live,
+      `The Appduct daemon was restarted to match this client (version ${clientVersion}), but the daemon now answering still reports version ${daemonVersion}. Either the old daemon never exited (compare "daemon.pid" with what "appduct daemon status" reports), or another process spawned an older daemon in the meantime. Run "appduct daemon stop", then retry.`
+    );
+    this.name = "DaemonVersionRestartIneffectiveError";
+  }
+};
+var parseVersion = (value) => {
+  const match = /^(\d+(?:\.\d+)*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value.trim());
+  if (!match) {
+    return void 0;
+  }
+  return {
+    numbers: match[1].split(".").map(Number),
+    // Build metadata (`+…`) is dropped, per semver: it never affects precedence, so two versions
+    // differing only there are the same version and neither restarts nor warns about the other.
+    prerelease: match[2]?.split(".")
+  };
+};
+var isNumericIdentifier = (identifier) => /^\d+$/u.test(identifier);
+var comparePrerelease = (left, right) => {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+    if (a === void 0) {
+      return -1;
+    }
+    if (b === void 0) {
+      return 1;
+    }
+    if (a === b) {
+      continue;
+    }
+    const aNumeric = isNumericIdentifier(a);
+    const bNumeric = isNumericIdentifier(b);
+    if (aNumeric && bNumeric) {
+      return Number(a) < Number(b) ? -1 : 1;
+    }
+    if (aNumeric !== bNumeric) {
+      return aNumeric ? -1 : 1;
+    }
+    return a < b ? -1 : 1;
+  }
+  return 0;
+};
+var compareVersions = (a, b) => {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) {
+    return void 0;
+  }
+  const length = Math.max(left.numbers.length, right.numbers.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (left.numbers[index] ?? 0) - (right.numbers[index] ?? 0);
+    if (difference !== 0) {
+      return difference < 0 ? -1 : 1;
+    }
+  }
+  if (left.prerelease === void 0 && right.prerelease === void 0) {
+    return 0;
+  }
+  if (left.prerelease === void 0) {
+    return 1;
+  }
+  if (right.prerelease === void 0) {
+    return -1;
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+};
+var isSameVersion = (a, b) => {
+  return a === b || compareVersions(a, b) === 0;
+};
+var isConnectionMissingError = (error) => {
+  const code = error.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+};
+var isDaemonUnreachableError = (error) => {
+  return error instanceof DaemonUnavailableError || isConnectionMissingError(error);
+};
+var nextRequestId = 1;
+var sendRequest = (socketPath, method, params, timeoutMs) => {
+  return new Promise((resolve2, reject) => {
+    const id = nextRequestId;
+    nextRequestId += 1;
+    let socket;
+    let settled = false;
+    let buffer = "";
+    const finish = (fn) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      socket.destroy();
+      fn();
+    };
+    const timeout = setTimeout(() => {
+      finish(
+        () => reject(new DaemonUnavailableError(`Timed out waiting for a response to "${method}".`, "timeout"))
+      );
+    }, timeoutMs);
+    socket = connect2(socketPath);
+    socket.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        newlineIndex = buffer.indexOf("\n");
+        if (line.length === 0) {
+          continue;
+        }
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message.id !== id) {
+          continue;
+        }
+        if (message.error) {
+          finish(
+            () => reject(new DaemonRpcError(message.error.code, message.error.message, message.error.data))
+          );
+          return;
+        }
+        finish(() => resolve2(message.result));
+        return;
+      }
+    });
+    socket.on("close", () => {
+      finish(
+        () => reject(new DaemonUnavailableError("Connection to the Appduct daemon closed.", "closed"))
+      );
+    });
+  });
+};
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var pollForSocket = async (socketPath, timeoutMs, pollIntervalMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isSocketConnectable(socketPath)) {
+      return true;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return isSocketConnectable(socketPath);
+};
+var unlinkStaleSocketIfDaemonDead = async (paths) => {
+  let pid;
+  try {
+    pid = Number.parseInt((await readFile3(paths.pidFilePath, "utf8")).trim(), 10);
+  } catch {
+    pid = void 0;
+  }
+  if (pid === void 0 || Number.isNaN(pid) || !isProcessAlive(pid)) {
+    await rm2(paths.socketPath, { force: true });
+  }
+};
+var defaultSpawn = async (args, context) => {
+  const paths = getStateDirPaths(context.stateDir);
+  await rotateDaemonLogIfNeeded({
+    logFilePath: context.logFilePath,
+    maxBytes: await resolveDaemonLogMaxBytes(context.stateDir),
+    pidFilePath: paths.pidFilePath,
+    socketPath: paths.socketPath
+  });
+  const logFd = await open2(context.logFilePath, "a", 384);
+  try {
+    await ensureDaemonLogMode(context.logFilePath);
+    const childEnv = { ...process.env, APPDUCT_STATE_DIR: context.stateDir };
+    delete childEnv[DAEMON_VERSION_OVERRIDE_ENV];
+    const child = spawnChildProcess(process.execPath, [defaultBinPath, ...args], {
+      detached: true,
+      stdio: ["ignore", logFd.fd, logFd.fd],
+      env: childEnv
+    });
+    child.unref();
+  } finally {
+    await logFd.close();
+  }
+};
+var SPAWN_LOCK_STALE_MS = 3e4;
+var pollUntilLockReleased = async (lockPath, timeoutMs, pollIntervalMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!await pathExists(lockPath)) {
+      return true;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return !await pathExists(lockPath);
+};
+var readPidfilePid = async (paths) => {
+  try {
+    const pid = Number.parseInt((await readFile3(paths.pidFilePath, "utf8")).trim(), 10);
+    return Number.isNaN(pid) ? void 0 : pid;
+  } catch {
+    return void 0;
+  }
+};
+var pathExists = async (target) => {
+  try {
+    await stat2(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var acquireSpawnLock = async (lockPath) => {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const lockHandle = await open2(lockPath, "wx", 384);
+      await lockHandle.close();
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+    let heldForMs;
+    try {
+      heldForMs = Date.now() - (await stat2(lockPath)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (heldForMs < SPAWN_LOCK_STALE_MS) {
+      return false;
+    }
+    await rm2(lockPath, { force: true });
+  }
+  return false;
+};
+var spawnDaemonAndWait = async (paths, spawn, waitTimeoutMs, pollIntervalMs, options = {}) => {
+  const acquiredLock = await acquireSpawnLock(paths.spawnLockPath);
+  let lockWaitTimedOut = false;
+  if (acquiredLock) {
+    try {
+      const shouldSpawn = options.beforeSpawn ? await options.beforeSpawn() : true;
+      if (shouldSpawn) {
+        await unlinkStaleSocketIfDaemonDead(paths);
+        await spawn(["daemon", "run"], { stateDir: paths.root, logFilePath: paths.logFilePath });
+      }
+    } finally {
+      await rm2(paths.spawnLockPath, { force: true });
+    }
+  } else if (options.awaitLockRelease) {
+    lockWaitTimedOut = !await pollUntilLockReleased(paths.spawnLockPath, waitTimeoutMs, pollIntervalMs);
+  }
+  const ready = await pollForSocket(paths.socketPath, waitTimeoutMs, pollIntervalMs);
+  if (!ready) {
+    const lockHint = await pathExists(paths.spawnLockPath) ? ` Another process holds the spawn-lock at "${paths.spawnLockPath}"; if no "appduct daemon" is starting, delete it and retry.` : "";
+    throw new DaemonUnavailableError(
+      `Timed out waiting for the Appduct daemon socket at "${paths.socketPath}".${lockHint}`
+    );
+  }
+  return { ownedLock: acquiredLock, lockWaitTimedOut };
+};
+var versionChecks = /* @__PURE__ */ new Map();
+var RESTART_REQUEST_TIMEOUT_MS = 3e3;
+var readStatusSpawningIfNeeded = async (context) => {
+  try {
+    return await sendRequest(
+      context.paths.socketPath,
+      RPC_METHODS.daemonStatus,
+      {},
+      context.requestTimeoutMs
+    );
+  } catch (error) {
+    if (!isConnectionMissingError(error)) {
+      throw error;
+    }
+    if (!context.autoSpawn) {
+      return void 0;
+    }
+    await spawnDaemonAndWait(context.paths, context.spawn, context.waitTimeoutMs, context.pollIntervalMs);
+    return sendRequest(
+      context.paths.socketPath,
+      RPC_METHODS.daemonStatus,
+      {},
+      context.requestTimeoutMs
+    );
+  }
+};
+var readStatusIfReachable = async (context) => {
+  try {
+    return await sendRequest(
+      context.paths.socketPath,
+      RPC_METHODS.daemonStatus,
+      {},
+      RESTART_REQUEST_TIMEOUT_MS
+    );
+  } catch (error) {
+    if (isConnectionMissingError(error)) {
+      return void 0;
+    }
+    if (isRequestTimeoutError(error)) {
+      throw new DaemonUnavailableError(
+        `The Appduct daemon at "${context.paths.socketPath}" did not answer "daemon.status" within ${RESTART_REQUEST_TIMEOUT_MS}ms, so it was not replaced. It is running but unresponsive \u2014 run "appduct daemon stop" and retry.`,
+        "timeout"
+      );
+    }
+    throw error;
+  }
+};
+var isDaemonGone = async (paths) => {
+  if (await isSocketConnectable(paths.socketPath)) {
+    return false;
+  }
+  let pid;
+  try {
+    pid = Number.parseInt((await readFile3(paths.pidFilePath, "utf8")).trim(), 10);
+  } catch {
+    return true;
+  }
+  return pid === void 0 || Number.isNaN(pid) || !isProcessAlive(pid);
+};
+var readLiveState = (status) => {
+  return {
+    sessions: Array.isArray(status.sessions) ? status.sessions.length : 0,
+    pendingLinks: typeof status.pendingLinks === "number" ? status.pendingLinks : 0
+  };
+};
+var isSafeToRestart = (live) => {
+  return live.sessions === 0 && live.pendingLinks === 0;
+};
+var pollUntilDaemonGone = async (paths, timeoutMs, pollIntervalMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isDaemonGone(paths)) {
+      return true;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return isDaemonGone(paths);
+};
+var restartDaemon = async (context) => {
+  const pidBefore = await readPidfilePid(context.paths);
+  const outcome = await spawnDaemonAndWait(
+    context.paths,
+    context.spawn,
+    context.waitTimeoutMs,
+    context.pollIntervalMs,
+    {
+      awaitLockRelease: true,
+      beforeSpawn: async () => {
+        const status = await readStatusIfReachable(context);
+        if (status === void 0) {
+          return true;
+        }
+        if (isSameVersion(status.version, context.check.clientVersion)) {
+          return false;
+        }
+        const live = readLiveState(status);
+        if (!isSafeToRestart(live) && !context.check.forceRestart) {
+          throw new DaemonVersionMismatchError(status.version, context.check.clientVersion, live);
+        }
+        try {
+          await sendRequest(
+            context.paths.socketPath,
+            RPC_METHODS.daemonShutdown,
+            {},
+            RESTART_REQUEST_TIMEOUT_MS
+          );
+        } catch (error) {
+          if (isRequestTimeoutError(error)) {
+            throw new DaemonUnavailableError(
+              `The Appduct daemon at "${context.paths.socketPath}" did not acknowledge "daemon.shutdown" within ${RESTART_REQUEST_TIMEOUT_MS}ms, so it was left running. Run "appduct daemon stop" and retry.`,
+              "timeout"
+            );
+          }
+          if (!isDaemonUnreachableError(error)) {
+            throw error;
+          }
+        }
+        if (!await pollUntilDaemonGone(context.paths, context.waitTimeoutMs, context.pollIntervalMs)) {
+          throw new DaemonUnavailableError(
+            `The Appduct daemon at "${context.paths.socketPath}" did not shut down in time; run "appduct daemon stop" and retry.`
+          );
+        }
+        return true;
+      }
+    }
+  );
+  if (!outcome.ownedLock && outcome.lockWaitTimedOut && await readPidfilePid(context.paths) === pidBefore) {
+    throw new DaemonUnavailableError(
+      `The Appduct daemon at "${context.paths.socketPath}" did not shut down in time: another process has held the spawn-lock at "${context.paths.spawnLockPath}" for longer than this command waited. Retry, or run "appduct daemon stop" if nothing is starting a daemon.`
+    );
+  }
+};
+var warnOlderClient = (context, daemonVersion) => {
+  const message = `appduct: the running daemon is version ${daemonVersion}, newer than this client (${context.check.clientVersion}). Continuing without restarting it \u2014 a newer daemon serves an older client, and replacing it would downgrade whatever started it. Run "appduct daemon stop" if you want this client's daemon instead.
+`;
+  const warn = context.check.onWarning ?? ((text) => void process.stderr.write(text));
+  warn(message);
+};
+var runVersionCheck = async (context) => {
+  const status = await readStatusSpawningIfNeeded(context);
+  if (status === void 0) {
+    return;
+  }
+  if (isSameVersion(status.version, context.check.clientVersion)) {
+    return;
+  }
+  if ((compareVersions(context.check.clientVersion, status.version) ?? -1) <= 0) {
+    warnOlderClient(context, status.version);
+    return;
+  }
+  const live = readLiveState(status);
+  if (!isSafeToRestart(live) && !context.check.forceRestart) {
+    throw new DaemonVersionMismatchError(status.version, context.check.clientVersion, live);
+  }
+  await restartDaemon(context);
+  const replacement = await readStatusIfReachable(context);
+  if (replacement === void 0) {
+    throw new DaemonUnavailableError(
+      `The Appduct daemon was restarted but nothing is listening at "${context.paths.socketPath}"; check "${context.paths.logFilePath}".`
+    );
+  }
+  if (isSameVersion(replacement.version, context.check.clientVersion)) {
+    return;
+  }
+  if ((compareVersions(context.check.clientVersion, replacement.version) ?? -1) <= 0) {
+    warnOlderClient(context, replacement.version);
+    return;
+  }
+  throw new DaemonVersionRestartIneffectiveError(
+    replacement.version,
+    context.check.clientVersion,
+    readLiveState(replacement)
+  );
+};
+var ensureDaemonVersion = async (paths, options, spawn) => {
+  const check = options.checkVersion;
+  if (!check) {
+    return;
+  }
+  const cached2 = versionChecks.get(paths.socketPath);
+  if (cached2) {
+    return cached2;
+  }
+  const pending = runVersionCheck({
+    paths,
+    spawn,
+    autoSpawn: options.autoSpawn ?? true,
+    requestTimeoutMs: options.requestTimeoutMs ?? 1e4,
+    waitTimeoutMs: options.spawnWaitTimeoutMs ?? 5e3,
+    pollIntervalMs: options.spawnPollIntervalMs ?? 100,
+    check
+  }).catch((error) => {
+    if (!(error instanceof DaemonVersionMismatchError)) {
+      versionChecks.delete(paths.socketPath);
+    }
+    throw error;
+  });
+  versionChecks.set(paths.socketPath, pending);
+  return pending;
+};
+var callDaemon = async (method, params, options) => {
+  const paths = getStateDirPaths(options.stateDir);
+  const autoSpawn = options.autoSpawn ?? true;
+  const spawn = options.spawn ?? defaultSpawn;
+  const requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
+  await ensureDaemonVersion(paths, options, spawn);
+  try {
+    return await sendRequest(paths.socketPath, method, params, requestTimeoutMs);
+  } catch (error) {
+    if (!autoSpawn || !isConnectionMissingError(error)) {
+      throw error;
+    }
+    await spawnDaemonAndWait(
+      paths,
+      spawn,
+      options.spawnWaitTimeoutMs ?? 5e3,
+      options.spawnPollIntervalMs ?? 100
+    );
+    return sendRequest(paths.socketPath, method, params, requestTimeoutMs);
+  }
+};
+var openDaemonStream = async (options) => {
+  const paths = getStateDirPaths(options.stateDir);
+  const autoSpawn = options.autoSpawn ?? true;
+  const spawn = options.spawn ?? defaultSpawn;
+  const requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
+  const connectSocket = () => {
+    return new Promise((resolve2, reject) => {
+      const socket2 = connect2(paths.socketPath);
+      socket2.once("connect", () => {
+        socket2.off("error", onError);
+        resolve2(socket2);
+      });
+      const onError = (error) => {
+        reject(error);
+      };
+      socket2.once("error", onError);
+    });
+  };
+  await ensureDaemonVersion(paths, options, spawn);
+  let socket;
+  try {
+    socket = await connectSocket();
+  } catch (error) {
+    if (!autoSpawn || !isConnectionMissingError(error)) {
+      throw error;
+    }
+    await spawnDaemonAndWait(
+      paths,
+      spawn,
+      options.spawnWaitTimeoutMs ?? 5e3,
+      options.spawnPollIntervalMs ?? 100
+    );
+    socket = await connectSocket();
+  }
+  socket.on("error", () => {
+  });
+  const notificationListeners = /* @__PURE__ */ new Set();
+  const closeListeners = /* @__PURE__ */ new Set();
+  const pendingCalls = /* @__PURE__ */ new Map();
+  let buffer = "";
+  socket.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      newlineIndex = buffer.indexOf("\n");
+      if (line.length === 0) {
+        continue;
+      }
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (message.method === "event") {
+        for (const listener of notificationListeners) {
+          try {
+            listener(message.params);
+          } catch {
+          }
+        }
+        continue;
+      }
+      const pending = typeof message.id === "number" ? pendingCalls.get(message.id) : void 0;
+      if (!pending) {
+        continue;
+      }
+      pendingCalls.delete(message.id);
+      clearTimeout(pending.timeout);
+      if (message.error) {
+        pending.reject(new DaemonRpcError(message.error.code, message.error.message, message.error.data));
+      } else {
+        pending.resolve(message.result);
+      }
+    }
+  });
+  socket.on("close", () => {
+    for (const [, pending] of pendingCalls) {
+      clearTimeout(pending.timeout);
+      pending.reject(new DaemonUnavailableError("Connection to the Appduct daemon closed.", "closed"));
+    }
+    pendingCalls.clear();
+    for (const listener of closeListeners) {
+      listener();
+    }
+  });
+  return {
+    call: (method, params, timeoutMs) => {
+      return new Promise((resolve2, reject) => {
+        const id = nextRequestId;
+        nextRequestId += 1;
+        const timeout = setTimeout(() => {
+          pendingCalls.delete(id);
+          reject(new DaemonUnavailableError(`Timed out waiting for a response to "${method}".`, "timeout"));
+        }, timeoutMs ?? requestTimeoutMs);
+        pendingCalls.set(id, {
+          resolve: resolve2,
+          reject,
+          timeout
+        });
+        socket.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+      });
+    },
+    onNotification: (callback) => {
+      notificationListeners.add(callback);
+      return () => {
+        notificationListeners.delete(callback);
+      };
+    },
+    onClose: (callback) => {
+      closeListeners.add(callback);
+      return () => {
+        closeListeners.delete(callback);
+      };
+    },
+    close: () => {
+      socket.destroy();
+    }
+  };
+};
+
+// src/client/app-client.ts
+import {
+  clampToolTimeoutMs,
+  MAX_TOOL_TIMEOUT_MS,
+  RPC_METHODS as RPC_METHODS2
+} from "@appduct/shared";
+
+// src/errors.ts
+var AppductCliError = class extends Error {
+  type;
+  details;
+  constructor(type, message, details) {
+    super(message);
+    this.name = "AppductCliError";
+    this.type = type;
+    this.details = details;
+  }
+};
+var usageError = (message, details) => {
+  return new AppductCliError("usage_error", message, details);
+};
+var connectionError = (message, details) => {
+  return new AppductCliError("connection_error", message, details);
+};
+var isAppductCliError = (value) => {
+  return value instanceof AppductCliError;
+};
+
+// src/client/errors.ts
+var AppductError = class extends Error {
+  type;
+  details;
+  /** The JSON-RPC error code, when this wraps a `DaemonRpcError`. */
+  code;
+  constructor(type, message, details, code) {
+    super(message);
+    this.name = "AppductError";
+    this.type = type;
+    this.details = details;
+    this.code = code;
+  }
+};
+var toAppductError = (error) => {
+  if (error instanceof AppductError) {
+    return error;
+  }
+  const withCause = (result) => {
+    result.cause = error;
+    return result;
+  };
+  if (error instanceof DaemonRpcError) {
+    const type = error.data?.type ?? "client_error";
+    return withCause(new AppductError(type, error.message, error.data?.details, error.code));
+  }
+  if (isDaemonUnreachableError(error)) {
+    return withCause(
+      new AppductError(
+        "connection_error",
+        error instanceof Error ? error.message : "The Appduct daemon is unreachable."
+      )
+    );
+  }
+  if (isAppductCliError(error)) {
+    return withCause(new AppductError("client_error", error.message, error.details));
+  }
+  if (error instanceof Error) {
+    return withCause(new AppductError("client_error", error.message));
+  }
+  return new AppductError("client_error", "An unexpected error occurred.", error);
+};
+
+// src/client/app-client.ts
+var DEFAULT_WAIT_FOR_EVENT_TIMEOUT_MS = 3e4;
+var CALL_TRANSPORT_TIMEOUT_SLACK_MS = 5e3;
+var transportTimeoutForToolCall = (timeoutMs) => {
+  const clamped = timeoutMs === void 0 || !Number.isFinite(timeoutMs) ? MAX_TOOL_TIMEOUT_MS : clampToolTimeoutMs(timeoutMs);
+  return clamped + CALL_TRANSPORT_TIMEOUT_SLACK_MS;
+};
+var makeAppClient = (stream, sessionId) => {
+  const client = {
+    sessionId,
+    tools: async () => {
+      try {
+        const result = await stream.call(RPC_METHODS2.toolsList, {
+          selector: sessionId
+        });
+        return Array.isArray(result) ? result : result.tools;
+      } catch (error) {
+        throw toAppductError(error);
+      }
+    },
+    call: async (name, args, options) => {
+      try {
+        const result = await stream.call(
+          RPC_METHODS2.toolsCall,
+          {
+            selector: sessionId,
+            name,
+            args,
+            timeoutMs: options?.timeoutMs,
+            caller: "client"
+          },
+          transportTimeoutForToolCall(options?.timeoutMs)
+        );
+        return result.result;
+      } catch (error) {
+        throw toAppductError(error);
+      }
+    },
+    events: async (options = {}) => {
+      try {
+        const result = await stream.call(RPC_METHODS2.eventsSince, {
+          selector: sessionId,
+          since: options.since,
+          limit: options.limit,
+          kinds: ["app_event"]
+        });
+        return {
+          events: result.events.map((event) => appEventFrom(event, sessionId)).filter((event) => event !== void 0),
+          cursor: result.cursor
+        };
+      } catch (error) {
+        throw toAppductError(error);
+      }
+    },
+    waitForEvent: (name, options = {}) => {
+      const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_FOR_EVENT_TIMEOUT_MS;
+      const toMatch = (event) => {
+        const appEvent = appEventFrom(event, sessionId);
+        if (!appEvent || appEvent.name !== name) {
+          return void 0;
+        }
+        if (options.match && !options.match(appEvent.payload)) {
+          return void 0;
+        }
+        return appEvent;
+      };
+      return new Promise((resolve2, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer);
+          unsubscribeClose();
+          liveHandler = null;
+          fn();
+        };
+        const timer = setTimeout(() => {
+          settle(
+            () => reject(new AppductError("timeout", `Timed out after ${timeoutMs}ms waiting for event "${name}".`))
+          );
+        }, timeoutMs);
+        let liveHandler = null;
+        const earlyEvents = [];
+        const unsubscribeNotification = stream.onNotification((payload) => {
+          const event = payload;
+          if (liveHandler) {
+            liveHandler(event);
+          } else {
+            earlyEvents.push(event);
+          }
+        });
+        let unsubscribeClose = () => {
+        };
+        const fail = (error) => {
+          settle(() => reject(toAppductError(error)));
+          unsubscribeNotification();
+        };
+        (async () => {
+          await stream.call(RPC_METHODS2.eventsSubscribe, { sessionSelector: sessionId, kinds: ["app_event"] });
+          const sinceResult = await stream.call(RPC_METHODS2.eventsSince, {
+            selector: sessionId,
+            since: options.since,
+            kinds: ["app_event"]
+          });
+          const seenSeqs = /* @__PURE__ */ new Set();
+          const backlog = [];
+          for (const event of [...sinceResult.events, ...earlyEvents]) {
+            if (event.sessionId === sessionId && !seenSeqs.has(event.seq)) {
+              seenSeqs.add(event.seq);
+              backlog.push(event);
+            }
+          }
+          backlog.sort((a, b) => a.seq - b.seq);
+          for (const event of backlog) {
+            try {
+              const matched = toMatch(event);
+              if (matched) {
+                settle(() => resolve2(matched));
+                unsubscribeNotification();
+                return;
+              }
+            } catch (error) {
+              fail(error);
+              return;
+            }
+          }
+          const highestConsideredSeq = backlog.length > 0 ? backlog[backlog.length - 1].seq : sinceResult.cursor;
+          unsubscribeClose = stream.onClose(() => {
+            settle(
+              () => reject(
+                new AppductError(
+                  "connection_error",
+                  `The connection to the Appduct daemon closed while waiting for event "${name}".`
+                )
+              )
+            );
+            unsubscribeNotification();
+          });
+          liveHandler = (event) => {
+            if (settled) {
+              return;
+            }
+            if (event.sessionId === sessionId && event.seq <= highestConsideredSeq) {
+              return;
+            }
+            try {
+              const matched = toMatch(event);
+              if (matched) {
+                settle(() => resolve2(matched));
+                unsubscribeNotification();
+              }
+            } catch (error) {
+              fail(error);
+            }
+          };
+        })().catch((error) => {
+          fail(error);
+        });
+      });
+    },
+    close: () => {
+      stream.close();
+    }
+  };
+  return client;
+};
+var appEventFrom = (event, sessionId) => {
+  if (event.kind !== "app_event" || event.sessionId !== sessionId) {
+    return void 0;
+  }
+  const data = event.data;
+  if (typeof data.name !== "string") {
+    return void 0;
+  }
+  return {
+    name: data.name,
+    payload: data.payload,
+    ts: event.ts,
+    sessionId: event.sessionId,
+    alias: event.alias,
+    seq: event.seq
+  };
+};
+
+// src/client/connect.ts
+var connect3 = async (options = {}) => {
+  const stateDir = resolveStateDir(options.stateDir);
+  let stream;
+  try {
+    stream = await openDaemonStream({
+      stateDir,
+      spawn: options.spawn,
+      autoSpawn: options.autoSpawn,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+  } catch (error) {
+    throw toAppductError(error);
+  }
+  try {
+    const detail = await stream.call(RPC_METHODS3.sessionsDescribe, {
+      selector: options.selector
+    });
+    return makeAppClient(stream, detail.sessionId);
+  } catch (error) {
+    stream.close();
+    throw toAppductError(error);
+  }
+};
+
+// src/client/bootstrap.ts
+import { RPC_METHODS as RPC_METHODS5 } from "@appduct/shared";
+
+// src/cli/open-target.ts
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile as readFile4, rm as rm3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var isOpenTarget = (value) => {
+  return value === "android" || value === "ios-sim" || value === "ios-device";
+};
+var OPEN_TARGETS = ["android", "ios-sim", "ios-device"];
+var usesLoopbackAddress = (target) => {
+  return target === "android" || target === "ios-sim";
+};
+var platformOf = (target) => {
+  if (target === "android") {
+    return "android";
+  }
+  if (target === "ios-device") {
+    return "ios";
+  }
+  return void 0;
+};
+var isLoopbackAddress = (address) => {
+  const normalized = address.trim().toLowerCase().replace(/^\[|\]$/gu, "");
+  return normalized === "localhost" || normalized === "::1" || normalized === "0.0.0.0" || normalized === "::" || /^127\./u.test(normalized);
+};
+var loopbackAddressMessage = (address) => `The daemon advertised "${address}", which a physical device cannot reach \u2014 it would point the phone at itself and the session would never be claimed. No routable LAN address was detected; set "advertisedIp" in config.json to this machine's address on the network the device is on, and retry.`;
+var defaultExec = (command, args) => {
+  return new Promise((resolve2, reject) => {
+    execFile(command, args, { encoding: "utf8" }, (error, stdout, stderr) => {
+      if (error) {
+        reject(Object.assign(error, { stdout, stderr }));
+        return;
+      }
+      resolve2({ stdout, stderr });
+    });
+  });
+};
+var TOOL_INSTALL_HINT = {
+  adb: "the Android platform-tools (adb)",
+  xcrun: "the Xcode command line tools (xcrun)"
+};
+var run = async (exec, command, args) => {
+  try {
+    return await exec(command, args);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      throw connectionError(
+        `"${command}" was not found on PATH. Install ${TOOL_INSTALL_HINT[command] ?? command} and retry.`
+      );
+    }
+    const stderr = (err.stderr ?? "").trim();
+    throw connectionError(
+      `"${command} ${args.join(" ")}" failed${stderr ? `: ${stderr}` : `: ${err.message}`}`
+    );
+  }
+};
+var parseBootedSimulators = (stdout) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  return Object.values(parsed.devices ?? {}).flat().filter(
+    (entry) => entry.state === "Booted" && typeof entry.udid === "string" && entry.udid.length > 0
+  ).map((entry) => ({ udid: entry.udid, name: entry.name ?? entry.udid }));
+};
+var listBootedSimulators = async (exec) => {
+  const preflight = await run(exec, "xcrun", ["simctl", "list", "devices", "booted", "--json"]);
+  return parseBootedSimulators(preflight.stdout);
+};
+var describeSimulator = (simulator) => `${simulator.name} (${simulator.udid})`;
+var deliverIosSim = async (exec, deepLink, device) => {
+  if (device) {
+    await run(exec, "xcrun", ["simctl", "openurl", device, deepLink]);
+    return;
+  }
+  const booted = await listBootedSimulators(exec);
+  if (booted.length === 0) {
+    throw usageError("No booted iOS simulator found. Boot a simulator (e.g. via Xcode) and retry.");
+  }
+  if (booted.length > 1) {
+    throw usageError(
+      `Multiple iOS simulators are booted (${booted.map(describeSimulator).join(", ")}); specify --device <udid>.`
+    );
+  }
+  await run(exec, "xcrun", ["simctl", "openurl", booted[0].udid, deepLink]);
+};
+var runDevicectlJson = async (exec, buildArgs) => {
+  let dir;
+  try {
+    dir = await mkdtemp(path.join(tmpdir(), "appduct-devicectl-"));
+  } catch (error) {
+    throw connectionError(
+      `A temporary directory for devicectl's --json-output could not be created in "${tmpdir()}" (${error.message}). Set TMPDIR to a writable directory and retry.`
+    );
+  }
+  const file = path.join(dir, "devicectl.json");
+  try {
+    await run(exec, "xcrun", buildArgs(file));
+    try {
+      return JSON.parse(await readFile4(file, "utf8"));
+    } catch {
+      return void 0;
+    }
+  } finally {
+    await rm3(dir, { force: true, recursive: true }).catch(() => {
+    });
+  }
+};
+var DELIVERABLE_PLATFORM = "ios";
+var UNREACHABLE_TUNNEL_STATE = "unavailable";
+var USABLE_PAIRING_STATE = "paired";
+var parsePairedIosDevices = (payload) => {
+  const devices = payload?.result?.devices;
+  if (!Array.isArray(devices)) {
+    return [];
+  }
+  return devices.map((entry) => {
+    const platform = entry?.hardwareProperties?.platform;
+    if (typeof platform === "string" && platform.toLowerCase() !== DELIVERABLE_PLATFORM) {
+      return void 0;
+    }
+    const tunnelState = entry?.connectionProperties?.tunnelState;
+    if (typeof tunnelState === "string" && tunnelState.toLowerCase() === UNREACHABLE_TUNNEL_STATE) {
+      return void 0;
+    }
+    const pairingState = entry?.connectionProperties?.pairingState;
+    if (typeof pairingState === "string" && pairingState.toLowerCase() !== USABLE_PAIRING_STATE) {
+      return void 0;
+    }
+    const hardwareUdid = entry?.hardwareProperties?.udid;
+    const udid = typeof hardwareUdid === "string" && hardwareUdid.length > 0 ? hardwareUdid : entry?.identifier;
+    return typeof udid === "string" && udid.length > 0 ? { udid, name: entry?.deviceProperties?.name ?? udid } : void 0;
+  }).filter((device) => device !== void 0);
+};
+var listPairedIosDevices = async (exec) => {
+  const payload = await runDevicectlJson(exec, (file) => [
+    "devicectl",
+    "list",
+    "devices",
+    "--timeout",
+    "5",
+    "--json-output",
+    file
+  ]);
+  return parsePairedIosDevices(payload);
+};
+var describeIosDevice = (device) => `${device.name} (${device.udid})`;
+var MISSING_APP_ID_MESSAGE = 'Delivering to a device needs the installed app\'s id (the Android package name, or the iOS bundle id): pass "--app-id <id>" (or "appId" over MCP), or record it as "appId.<platform>" in .appduct/config.json \u2014 run `appduct init --android-app-id <id> --ios-app-id <id>` to write it.';
+var APP_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+var isValidAppId = (value) => APP_ID_PATTERN.test(value);
+var invalidAppIdMessage = (value) => `"${value}" is not a valid app id (letters, digits, ".", "_" and "-", starting with a letter or digit).`;
+var resolveSingleIosDevice = async (exec) => {
+  const paired = await listPairedIosDevices(exec);
+  if (paired.length === 0) {
+    throw usageError(
+      'No connected iOS device was found ("xcrun devicectl list devices" listed none, ignoring disconnected devices and non-iOS ones such as a paired Watch or Vision Pro). Connect the device, trust this Mac, and enable Developer Mode on it, then retry.'
+    );
+  }
+  if (paired.length > 1) {
+    throw usageError(
+      `Multiple connected iOS devices were found (${paired.map(describeIosDevice).join(", ")}); specify --device <udid>.`
+    );
+  }
+  return paired[0].udid;
+};
+var deliverIosDevice = async (exec, deepLink, device, appId, relaunch) => {
+  if (!appId) {
+    throw usageError(MISSING_APP_ID_MESSAGE);
+  }
+  if (!isValidAppId(appId)) {
+    throw usageError(invalidAppIdMessage(appId));
+  }
+  const udid = device ?? await resolveSingleIosDevice(exec);
+  await run(exec, "xcrun", [
+    "devicectl",
+    "device",
+    "process",
+    "launch",
+    "--device",
+    udid,
+    // Opt-in only (`--relaunch` / `relaunch: true`). A plain `process launch` is what the vendored
+    // Expo CLI does, so it is the better-attested default; what it does when the app is *already
+    // running* is the one thing nobody here can verify without hardware. If that turns out to fail
+    // rather than deliver the URL, `--terminate-existing` is the escape hatch — it kills the
+    // running instance first, which Appduct copes with because a delivered link supersedes a
+    // held session.
+    ...relaunch ? ["--terminate-existing"] : [],
+    "--payload-url",
+    deepLink,
+    appId
+  ]);
+};
+var parseAdbDevices = (stdout) => {
+  return stdout.split("\n").slice(1).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+    const [serial = "", state = ""] = line.split(/\s+/u);
+    return { serial, state };
+  }).filter((entry) => entry.serial.length > 0);
+};
+var listAttachedAndroidDevices = async (exec) => {
+  const listing = await run(exec, "adb", ["devices"]);
+  return parseAdbDevices(listing.stdout).filter((entry) => entry.state === "device").map((entry) => entry.serial);
+};
+var resolveAndroidSerial = async (exec, device, env) => {
+  if (device) {
+    return device;
+  }
+  if (env.ANDROID_SERIAL) {
+    return void 0;
+  }
+  const attached = await listAttachedAndroidDevices(exec);
+  if (attached.length === 0) {
+    throw usageError('No Android device or emulator is attached ("adb devices" listed none).');
+  }
+  if (attached.length > 1) {
+    throw usageError(
+      `Multiple Android devices are attached (${attached.join(
+        ", "
+      )}); specify --device <serial> or set ANDROID_SERIAL.`
+    );
+  }
+  return void 0;
+};
+var withSerial = (args, serial) => {
+  return serial ? ["-s", serial, ...args] : args;
+};
+var AM_START_ERROR_PATTERN = /^(?:Error:|Exception occurred while executing|Security exception:)/mu;
+var deliverAndroid = async (exec, deepLink, wssPort, device, env, appId) => {
+  if (!isValidAppId(appId)) {
+    throw usageError(invalidAppIdMessage(appId));
+  }
+  const serial = await resolveAndroidSerial(exec, device, env);
+  await run(exec, "adb", withSerial(["reverse", `tcp:${wssPort}`, `tcp:${wssPort}`], serial));
+  const { stdout, stderr } = await run(
+    exec,
+    "adb",
+    withSerial(
+      [
+        "shell",
+        "am",
+        "start",
+        "-a",
+        "android.intent.action.VIEW",
+        "-d",
+        // `adb shell` reconstructs everything after "shell" into one string and re-parses it on the
+        // device's own shell; single-quoting the URL here (not just for local execFile, which never
+        // re-tokenizes argv) protects against that second, remote parse (ARCHITECTURE.md §8).
+        `'${deepLink}'`,
+        // Names the app explicitly: without this, more than one installed app declaring the same
+        // scheme makes Android show an "Open with" chooser, which `am start` still reports as a
+        // successful launch — see `AM_START_ERROR_PATTERN` below for the other half of the fix.
+        "-p",
+        appId
+      ],
+      serial
+    )
+  );
+  if (AM_START_ERROR_PATTERN.test(stdout) || AM_START_ERROR_PATTERN.test(stderr)) {
+    throw usageError(
+      `"adb shell am start" could not launch "${appId}": ${(stdout + stderr).trim() || "(no output)"} \u2014 the app is likely not installed on this device, or its installed build does not declare a matching deep-link scheme.`
+    );
+  }
+};
+var deliverToOpenTarget = async (options) => {
+  const exec = options.exec ?? defaultExec;
+  if (options.target === "ios-sim") {
+    await deliverIosSim(exec, options.deepLink, options.device);
+    return;
+  }
+  if (options.target === "ios-device") {
+    await deliverIosDevice(
+      exec,
+      options.deepLink,
+      options.device,
+      options.appId,
+      options.relaunch ?? false
+    );
+    return;
+  }
+  if (!options.appId) {
+    throw usageError(MISSING_APP_ID_MESSAGE);
+  }
+  await deliverAndroid(
+    exec,
+    options.deepLink,
+    options.wssPort,
+    options.device,
+    options.env ?? process.env,
+    options.appId
+  );
+};
+
+// src/link.ts
+import { RPC_METHODS as RPC_METHODS4 } from "@appduct/shared";
+
+// src/scheme.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
+
+// src/native-scheme.ts
+import { readdir, readFile as readFile5, stat as stat3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var MAX_PROBE_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_PLIST_WALK_DEPTH = 2;
+var MAX_WALK_ENTRIES = 5e3;
+var EXCLUDED_WALK_DIRS = /* @__PURE__ */ new Set(["Pods", "build", "node_modules", "DerivedData"]);
+var readCappedText = async (path2) => {
+  const buffer = await readCappedBuffer(path2);
+  if (!buffer.ok) {
+    return buffer;
+  }
+  return { ok: true, text: buffer.data.toString("utf8") };
+};
+var readCappedBuffer = async (path2) => {
+  let size;
+  try {
+    const stats = await stat3(path2);
+    if (!stats.isFile()) {
+      return { ok: false, reason: "not-found" };
+    }
+    size = stats.size;
+  } catch {
+    return { ok: false, reason: "not-found" };
+  }
+  if (size > MAX_PROBE_FILE_BYTES) {
+    return { ok: false, reason: "too-large" };
+  }
+  try {
+    return { ok: true, data: await readFile5(path2) };
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  }
+};
+var requireValidNativeScheme = (value, origin) => {
+  if (!isValidScheme(value)) {
+    throw usageError(
+      `Invalid deep-link scheme ${JSON.stringify(value)} from ${origin}: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://".`
+    );
+  }
+  return value;
+};
+var GRADLE_PLACEHOLDER_PATTERN = /manifestPlaceholders\s*(?:\[\s*["']appductScheme["']\s*\]|\.\s*appductScheme)\s*=\s*["']([^"']*)["']/u;
+var extractGradleScheme = (text) => {
+  const match = GRADLE_PLACEHOLDER_PATTERN.exec(text);
+  const value = match?.[1];
+  return value !== void 0 && value.length > 0 ? value : void 0;
+};
+var probeAndroidGradle = async (root) => {
+  const candidates = [join4(root, "app", "build.gradle.kts"), join4(root, "app", "build.gradle")];
+  const notes = [];
+  for (const candidate of candidates) {
+    const read = await readCappedText(candidate);
+    if (!read.ok) {
+      if (read.reason === "too-large") {
+        notes.push(`${candidate} (too large, skipped)`);
+      }
+      continue;
+    }
+    const scheme = extractGradleScheme(read.text);
+    if (scheme !== void 0) {
+      requireValidNativeScheme(scheme, `"appductScheme" in ${candidate}`);
+      return {
+        result: {
+          source: "android-gradle",
+          scheme,
+          origin: `"appductScheme" in ${candidate}`
+        },
+        tried: [describeAndroidGradleTried(candidates, notes)]
+      };
+    }
+  }
+  return { tried: [describeAndroidGradleTried(candidates, notes)] };
+};
+var describeAndroidGradleTried = (candidates, notes) => {
+  const base = `${candidates.join(", ")} ("appductScheme" manifest placeholder)`;
+  return notes.length === 0 ? base : `${base} \u2014 ${notes.join(", ")}`;
+};
+var INTENT_FILTER_PATTERN = /<intent-filter\b[^>]*>([\s\S]*?)<\/intent-filter>/giu;
+var VIEW_ACTION_PATTERN = /<action\b[^>]*\bandroid:name\s*=\s*["']android\.intent\.action\.VIEW["']/iu;
+var DATA_SCHEME_PATTERN = /<data\b[^>]*\bandroid:scheme\s*=\s*["']([^"']*)["']/iu;
+var extractManifestScheme = (xml) => {
+  for (const match of xml.matchAll(INTENT_FILTER_PATTERN)) {
+    const block = match[1] ?? "";
+    if (!VIEW_ACTION_PATTERN.test(block)) {
+      continue;
+    }
+    const dataMatch = DATA_SCHEME_PATTERN.exec(block);
+    const scheme = dataMatch?.[1];
+    if (scheme !== void 0 && scheme.length > 0) {
+      return scheme;
+    }
+  }
+  return void 0;
+};
+var probeAndroidManifest = async (root) => {
+  const manifestPath = join4(root, "app", "src", "main", "AndroidManifest.xml");
+  const read = await readCappedText(manifestPath);
+  const description = `${manifestPath} (first <data android:scheme> in a VIEW intent-filter)`;
+  if (!read.ok) {
+    return {
+      tried: [read.reason === "too-large" ? `${description} \u2014 too large, skipped` : description]
+    };
+  }
+  const scheme = extractManifestScheme(read.text);
+  if (scheme === void 0) {
+    return { tried: [description] };
+  }
+  requireValidNativeScheme(scheme, `"android:scheme" in ${manifestPath}`);
+  return {
+    result: {
+      source: "android-manifest",
+      scheme,
+      origin: `"android:scheme" in ${manifestPath}`
+    },
+    tried: [description]
+  };
+};
+var XML_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+var decodeXmlEntities = (text) => {
+  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/gu, (whole, entity) => {
+    if (entity.startsWith("#x")) {
+      const code = Number.parseInt(entity.slice(2), 16);
+      return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+    }
+    if (entity.startsWith("#")) {
+      const code = Number.parseInt(entity.slice(1), 10);
+      return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+    }
+    return XML_ENTITIES[entity] ?? whole;
+  });
+};
+var tokenizePlistXml = (xml) => {
+  const cleaned = xml.replace(/<\?[\s\S]*?\?>/gu, "").replace(/<!DOCTYPE[\s\S]*?>/giu, "").replace(/<!--[\s\S]*?-->/gu, "");
+  const root = { tag: "#root", children: [], text: "" };
+  const stack = [root];
+  const tagOrTextPattern = /<(\/?)([a-zA-Z][\w.:-]*)\b[^>]*?(\/?)>|([^<]+)/gu;
+  for (const match of cleaned.matchAll(tagOrTextPattern)) {
+    const [, closing, name, selfClosing, text] = match;
+    const top = stack[stack.length - 1];
+    if (text !== void 0) {
+      top.text += decodeXmlEntities(text);
+      continue;
+    }
+    if (closing) {
+      if (stack.length > 1) {
+        stack.pop();
+      }
+      continue;
+    }
+    const node = { tag: name ?? "", children: [], text: "" };
+    top.children.push(node);
+    if (!selfClosing) {
+      stack.push(node);
+    }
+  }
+  return root;
+};
+var plistNodeToValue = (node) => {
+  switch (node.tag) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "integer": {
+      const value = Number.parseInt(node.text.trim(), 10);
+      return Number.isNaN(value) ? node.text.trim() : value;
+    }
+    case "real": {
+      const value = Number.parseFloat(node.text.trim());
+      return Number.isNaN(value) ? node.text.trim() : value;
+    }
+    case "array":
+      return node.children.map(plistNodeToValue);
+    case "dict": {
+      const result = {};
+      for (let index = 0; index < node.children.length; index += 2) {
+        const keyNode = node.children[index];
+        const valueNode = node.children[index + 1];
+        if (keyNode?.tag === "key" && valueNode !== void 0) {
+          result[keyNode.text.trim()] = plistNodeToValue(valueNode);
+        }
+      }
+      return result;
+    }
+    default:
+      return node.text.trim();
+  }
+};
+var parsePlistXml = (xml) => {
+  const root = tokenizePlistXml(xml);
+  const plistNode = root.children.find((child) => child.tag === "plist");
+  const valueNode = plistNode?.children[0];
+  return valueNode ? plistNodeToValue(valueNode) : void 0;
+};
+var isBinaryPlist = (buffer) => {
+  return buffer.length >= 6 && buffer.subarray(0, 6).toString("latin1") === "bplist";
+};
+var firstPlistUrlScheme = (cfBundleURLTypes) => {
+  if (!Array.isArray(cfBundleURLTypes)) {
+    return void 0;
+  }
+  for (const entry of cfBundleURLTypes) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const scheme = firstConfiguredScheme(entry.CFBundleURLSchemes);
+    if (scheme !== void 0) {
+      return scheme;
+    }
+  }
+  return void 0;
+};
+var walkForFilename = async (root, filename, maxDepth) => {
+  const hits = [];
+  let visited = 0;
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited >= MAX_WALK_ENTRIES) {
+        return;
+      }
+      visited += 1;
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (EXCLUDED_WALK_DIRS.has(entry.name)) {
+          continue;
+        }
+        if (depth < maxDepth) {
+          await walk(join4(dir, entry.name), depth + 1);
+        }
+        continue;
+      }
+      if (entry.isFile() && entry.name === filename) {
+        hits.push({ path: join4(dir, entry.name), depth });
+      }
+    }
+  };
+  await walk(root, 0);
+  hits.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+  return hits;
+};
+var probeIosInfoPlist = async (root) => {
+  const files = await walkForFilename(root, "Info.plist", MAX_PLIST_WALK_DEPTH);
+  const describeSearch = (notes2) => {
+    const base = files.length === 0 ? `Info.plist up to ${MAX_PLIST_WALK_DEPTH} levels below ${root} (excluding Pods/build/node_modules/DerivedData) \u2014 none found` : `${files.map((file) => file.path).join(", ")} (first "CFBundleURLSchemes" entry)`;
+    return notes2.length === 0 ? base : `${base} \u2014 ${notes2.join(", ")}`;
+  };
+  const notes = [];
+  for (const file of files) {
+    const read = await readCappedBuffer(file.path);
+    if (!read.ok) {
+      notes.push(
+        `${file.path} (${read.reason === "too-large" ? "too large, skipped" : "unreadable"})`
+      );
+      continue;
+    }
+    if (isBinaryPlist(read.data)) {
+      notes.push(`${file.path} (binary plist \u2014 unreadable, use --scheme)`);
+      continue;
+    }
+    const value = parsePlistXml(read.data.toString("utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      continue;
+    }
+    const scheme = firstPlistUrlScheme(value.CFBundleURLTypes);
+    if (scheme === void 0) {
+      continue;
+    }
+    requireValidNativeScheme(scheme, `"CFBundleURLSchemes" in ${file.path}`);
+    return {
+      result: {
+        source: "ios-info-plist",
+        scheme,
+        origin: `"CFBundleURLSchemes" in ${file.path}`
+      },
+      tried: [describeSearch(notes)]
+    };
+  }
+  return { tried: [describeSearch(notes)] };
+};
+var PROJECT_YML_SCHEME_PATTERN = /CFBundleURLSchemes\s*:\s*(?:\[\s*["']?([^"'\],\r\n]*)["']?|\r?\n[ \t]*-[ \t]*["']?([^"'\r\n]*)["']?)/u;
+var extractProjectYmlScheme = (text) => {
+  const match = PROJECT_YML_SCHEME_PATTERN.exec(text);
+  const raw = (match?.[1] ?? match?.[2])?.trim();
+  return raw !== void 0 && raw.length > 0 ? raw : void 0;
+};
+var probeIosProjectYml = async (root) => {
+  const path2 = join4(root, "project.yml");
+  const description = `${path2} ("info.properties.CFBundleURLTypes" > "CFBundleURLSchemes")`;
+  const read = await readCappedText(path2);
+  if (!read.ok) {
+    return {
+      tried: [read.reason === "too-large" ? `${description} \u2014 too large, skipped` : description]
+    };
+  }
+  const scheme = extractProjectYmlScheme(read.text);
+  if (scheme === void 0) {
+    return { tried: [description] };
+  }
+  requireValidNativeScheme(scheme, `"CFBundleURLSchemes" in ${path2}`);
+  return {
+    result: { source: "ios-project-yml", scheme, origin: `"CFBundleURLSchemes" in ${path2}` },
+    tried: [description]
+  };
+};
+var PROBES = [
+  probeAndroidGradle,
+  probeAndroidManifest,
+  probeIosInfoPlist,
+  probeIosProjectYml
+];
+var discoverNativeScheme = async (root) => {
+  const tried = [];
+  const results = [];
+  for (const probe of PROBES) {
+    const outcome = await probe(root);
+    tried.push(...outcome.tried);
+    if (outcome.result !== void 0) {
+      results.push(outcome.result);
+    }
+  }
+  if (results.length === 0) {
+    return { tried };
+  }
+  const distinctSchemes = new Set(results.map((entry) => entry.scheme));
+  if (distinctSchemes.size > 1) {
+    throw usageError(
+      "Conflicting deep-link schemes found in this project: " + results.map((entry) => `${entry.origin} says ${JSON.stringify(entry.scheme)}`).join(", but ") + ". Appduct will not guess which one is right \u2014 pass --scheme <scheme> to pick one."
+    );
+  }
+  return { result: results[0], tried };
+};
+
+// src/scheme.ts
+var PROJECT_CONFIG_DIR = ".appduct";
+var PROJECT_CONFIG_FILENAME = "config.json";
+var PROJECT_CONFIG_RELATIVE_PATH = join5(PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILENAME);
+var APP_JSON_FILENAME = "app.json";
+var SCHEME_ENV_VAR = "APPDUCT_SCHEME";
+var SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*$/u;
+var isValidScheme = (value) => SCHEME_PATTERN.test(value);
+var requireValidScheme = (value, origin) => {
+  if (!isValidScheme(value)) {
+    throw usageError(
+      `Invalid deep-link scheme ${JSON.stringify(value)} from ${origin}: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://".`
+    );
+  }
+  return value;
+};
+var isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var readJsonFile = async (path2) => {
+  let text;
+  try {
+    text = await readFile6(path2, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return { raw: JSON.parse(text) };
+  } catch (error) {
+    throw usageError(`Could not parse ${path2}: ${error.message}`);
+  }
+};
+var firstConfiguredScheme = (value) => {
+  if (Array.isArray(value)) {
+    return value.find((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+var discoverExpoScheme = async (dir) => {
+  const path2 = join5(resolve(dir), APP_JSON_FILENAME);
+  const file = await readJsonFile(path2);
+  if (!file || !isPlainObject(file.raw)) {
+    return void 0;
+  }
+  const expo = file.raw.expo;
+  if (!isPlainObject(expo)) {
+    return void 0;
+  }
+  const scheme = firstConfiguredScheme(expo.scheme);
+  return scheme === void 0 ? void 0 : requireValidScheme(scheme, `"expo.scheme" in ${path2}`);
+};
+var discoverStaticProjectScheme = async (cwd) => {
+  const appJsonPath = join5(resolve(cwd), APP_JSON_FILENAME);
+  const tried = [`${appJsonPath} ("expo.scheme")`];
+  const appJsonScheme = await discoverExpoScheme(cwd);
+  if (appJsonScheme !== void 0) {
+    return { scheme: appJsonScheme, source: "app-json", origin: appJsonPath, tried };
+  }
+  const native = await discoverNativeScheme(resolve(cwd));
+  tried.push(...native.tried);
+  if (native.result !== void 0) {
+    return {
+      scheme: native.result.scheme,
+      source: native.result.source,
+      origin: native.result.origin,
+      tried
+    };
+  }
+  return { tried };
+};
+var globalConfigDirs = (options = {}) => {
+  const excluded = /* @__PURE__ */ new Set([join5(resolve(options.homeDir ?? homedir2()), PROJECT_CONFIG_DIR)]);
+  if (options.stateDirRoot !== void 0) {
+    excluded.add(resolve(options.stateDirRoot));
+  }
+  return excluded;
+};
+var findProjectConfigs = (startDir, options = {}) => {
+  const excluded = globalConfigDirs(options);
+  const found = [];
+  let dir = resolve(startDir);
+  for (; ; ) {
+    const projectDir = join5(dir, PROJECT_CONFIG_DIR);
+    if (!excluded.has(projectDir)) {
+      const candidate = join5(projectDir, PROJECT_CONFIG_FILENAME);
+      if (existsSync2(candidate)) {
+        found.push(candidate);
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return found;
+    }
+    dir = parent;
+  }
+};
+var readProjectConfigScheme = async (path2) => {
+  const file = await readJsonFile(path2);
+  if (!file) {
+    return void 0;
+  }
+  if (!isPlainObject(file.raw)) {
+    throw usageError(`Invalid Appduct project config at ${path2}: must be a JSON object.`);
+  }
+  const scheme = file.raw.scheme;
+  if (scheme === void 0) {
+    return void 0;
+  }
+  if (typeof scheme !== "string" || scheme.length === 0) {
+    throw usageError(
+      `Invalid Appduct project config at ${path2}: "scheme" must be a non-empty string.`
+    );
+  }
+  return requireValidScheme(scheme, `"scheme" in ${path2}`);
+};
+var APP_ID_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
+var readProjectConfigAppId = async (path2, platform) => {
+  const file = await readJsonFile(path2);
+  if (!file) {
+    return void 0;
+  }
+  if (!isPlainObject(file.raw)) {
+    throw usageError(`Invalid Appduct project config at ${path2}: must be a JSON object.`);
+  }
+  const appId = file.raw.appId;
+  if (appId === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(appId)) {
+    throw usageError(
+      `Invalid Appduct project config at ${path2}: "appId" must be an object with "ios" and/or "android" keys.`
+    );
+  }
+  for (const key of Object.keys(appId)) {
+    if (!APP_ID_PLATFORMS.has(key)) {
+      throw usageError(
+        `Invalid Appduct project config at ${path2}: unknown key "appId.${key}" (expected "ios" and/or "android").`
+      );
+    }
+  }
+  const value = appId[platform];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw usageError(
+      `Invalid Appduct project config at ${path2}: "appId.${platform}" must be a non-empty string.`
+    );
+  }
+  return value;
+};
+var resolveScheme = async (options = {}) => {
+  const env = options.env ?? process.env;
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const tried = [];
+  tried.push("the --scheme flag");
+  if (options.flagScheme !== void 0 && options.flagScheme.length > 0) {
+    return {
+      scheme: requireValidScheme(options.flagScheme, "the --scheme flag"),
+      source: "flag",
+      tried
+    };
+  }
+  tried.push(`the ${SCHEME_ENV_VAR} environment variable`);
+  const envScheme = env[SCHEME_ENV_VAR];
+  if (typeof envScheme === "string" && envScheme.length > 0) {
+    return {
+      scheme: requireValidScheme(envScheme, `the ${SCHEME_ENV_VAR} environment variable`),
+      source: "env",
+      tried
+    };
+  }
+  const projectConfigPaths = findProjectConfigs(cwd, {
+    stateDirRoot: options.stateDirRoot,
+    homeDir: options.homeDir
+  });
+  tried.push(
+    projectConfigPaths.length === 0 ? `${PROJECT_CONFIG_RELATIVE_PATH} (searched upwards from ${cwd})` : projectConfigPaths.join(", ")
+  );
+  for (const projectConfigPath of projectConfigPaths) {
+    const projectScheme = await readProjectConfigScheme(projectConfigPath);
+    if (projectScheme !== void 0) {
+      return { scheme: projectScheme, source: "project-config", tried };
+    }
+  }
+  tried.push(
+    options.stateConfigPath === void 0 ? `the state directory's config.json ("scheme")` : `${options.stateConfigPath} ("scheme")`
+  );
+  if (options.configScheme !== void 0 && options.configScheme.length > 0) {
+    return {
+      scheme: requireValidScheme(
+        options.configScheme,
+        options.stateConfigPath === void 0 ? `the state directory's config.json "scheme"` : `"scheme" in ${options.stateConfigPath}`
+      ),
+      source: "state-config",
+      tried
+    };
+  }
+  const discovered = await discoverStaticProjectScheme(cwd);
+  tried.push(...discovered.tried);
+  if (discovered.scheme !== void 0) {
+    return { scheme: discovered.scheme, source: discovered.source, tried };
+  }
+  return { tried };
+};
+var describeMissingScheme = (tried) => {
+  const locations = tried.length === 0 ? "" : `Looked in, in order:
+${tried.map((location, index) => `  ${index + 1}. ${location}`).join("\n")}
+`;
+  return "A deep-link scheme is required to compose the link, and none was found. " + locations + `Set one with --scheme <scheme>, ${SCHEME_ENV_VAR}=<scheme>, "expo.scheme" in ${APP_JSON_FILENAME}, or run \`appduct init\` in your app root to write ${PROJECT_CONFIG_RELATIVE_PATH}.`;
+};
+var resolveSchemeOrThrow = async (options = {}) => {
+  const resolved = await resolveScheme(options);
+  if (resolved.scheme === void 0) {
+    throw usageError(describeMissingScheme(resolved.tried));
+  }
+  return resolved.scheme;
+};
+var resolveAppId = async (options) => {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const tried = [];
+  tried.push("the --app-id flag");
+  if (options.flagAppId !== void 0 && options.flagAppId.length > 0) {
+    return { appId: options.flagAppId, source: "flag", tried };
+  }
+  const projectConfigPaths = findProjectConfigs(cwd, {
+    stateDirRoot: options.stateDirRoot,
+    homeDir: options.homeDir
+  });
+  tried.push(
+    projectConfigPaths.length === 0 ? `${PROJECT_CONFIG_RELATIVE_PATH} (searched upwards from ${cwd})` : projectConfigPaths.join(", ")
+  );
+  for (const projectConfigPath of projectConfigPaths) {
+    const projectAppId = await readProjectConfigAppId(projectConfigPath, options.platform);
+    if (projectAppId !== void 0) {
+      return { appId: projectAppId, source: "project-config", tried };
+    }
+  }
+  return { tried };
+};
+var describeMissingAppId = (platform, tried) => {
+  const locations = tried.length === 0 ? "" : `Looked in, in order:
+${tried.map((location, index) => `  ${index + 1}. ${location}`).join("\n")}
+`;
+  const platformLabel = platform === "android" ? "Android" : "a physical iPhone/iPad";
+  const initFlag = platform === "android" ? "--android-app-id" : "--ios-app-id";
+  return `Delivering to ${platformLabel} needs the installed app's id, and none was found. ${locations}Set one with \`appduct init ${initFlag} <id>\`, --app-id <id>, or "appId.${platform}" in ${PROJECT_CONFIG_RELATIVE_PATH}.`;
+};
+
+// src/link.ts
+var OPEN_TARGET_ADDRESS_OVERRIDE = "127.0.0.1";
+var composeDeepLink = (scheme, result) => `${scheme}:///?appduct=${result.deepLinkPayload}&pin=${encodeURIComponent(result.pin)}`;
+var mintLink = async (options) => {
+  if (options.target !== void 0 && !isOpenTarget(options.target)) {
+    throw usageError(
+      `"target" must be one of ${OPEN_TARGETS.map((target) => `"${target}"`).join(", ")} (got "${options.target}").`
+    );
+  }
+  if (options.device !== void 0 && options.target === void 0) {
+    throw usageError('"device" only applies alongside a target.');
+  }
+  if (options.appId !== void 0 && options.target !== "android" && options.target !== "ios-device") {
+    throw usageError('"appId" only applies alongside target "android" or target "ios-device".');
+  }
+  if (options.relaunch !== void 0 && options.target !== "ios-device") {
+    throw usageError('"relaunch" only applies alongside target "ios-device".');
+  }
+  const paths = getStateDirPaths(options.stateDir);
+  const config = await loadConfig(paths);
+  const scheme = await resolveSchemeOrThrow({
+    flagScheme: options.scheme,
+    env: options.schemeEnv,
+    cwd: options.cwd,
+    configScheme: config.scheme,
+    stateConfigPath: paths.configPath,
+    stateDirRoot: paths.root
+  });
+  const platform = options.target === void 0 ? void 0 : platformOf(options.target);
+  let appId;
+  if (platform !== void 0) {
+    const resolved = await resolveAppId({
+      platform,
+      flagAppId: options.appId,
+      cwd: options.cwd,
+      stateDirRoot: paths.root
+    });
+    if (resolved.appId === void 0) {
+      throw usageError(describeMissingAppId(platform, resolved.tried));
+    }
+    appId = resolved.appId;
+  }
+  if (appId !== void 0 && !isValidAppId(appId)) {
+    throw usageError(invalidAppIdMessage(appId));
+  }
+  const result = await callDaemon(
+    RPC_METHODS4.linkCreate,
+    {
+      ttlSeconds: options.ttlSeconds,
+      addressOverride: options.target && usesLoopbackAddress(options.target) ? OPEN_TARGET_ADDRESS_OVERRIDE : void 0
+    },
+    { stateDir: options.stateDir, spawn: options.spawn, autoSpawn: options.autoSpawn }
+  );
+  if (options.target === "ios-device" && isLoopbackAddress(result.endpoint.address)) {
+    throw usageError(loopbackAddressMessage(result.endpoint.address));
+  }
+  const deepLink = composeDeepLink(scheme, result);
+  if (options.target) {
+    await deliverToOpenTarget({
+      target: options.target,
+      deepLink,
+      wssPort: result.endpoint.port,
+      device: options.device,
+      appId,
+      relaunch: options.relaunch,
+      exec: options.exec,
+      env: options.env
+    });
+    return {
+      sessionId: result.sessionId,
+      deepLink,
+      endpoint: result.endpoint,
+      expiresAt: result.expiresAt,
+      pin: result.pin,
+      delivered: true,
+      target: options.target
+    };
+  }
+  return {
+    sessionId: result.sessionId,
+    deepLink,
+    endpoint: result.endpoint,
+    expiresAt: result.expiresAt,
+    pin: result.pin
+  };
+};
+
+// src/client/bootstrap.ts
+var DEFAULT_WAIT_FOR_SESSION_TIMEOUT_MS = 12e4;
+var link = async (options = {}) => {
+  try {
+    return await mintLink({
+      stateDir: resolveStateDir(options.stateDir),
+      spawn: options.spawn,
+      autoSpawn: options.autoSpawn,
+      ttlSeconds: options.ttlSeconds,
+      target: options.target,
+      device: options.device,
+      appId: options.appId,
+      relaunch: options.relaunch,
+      scheme: options.scheme,
+      cwd: options.cwd,
+      exec: options.exec,
+      env: options.env,
+      schemeEnv: options.schemeEnv
+    });
+  } catch (error) {
+    throw toAppductError(error);
+  }
+};
+var waitForSession = async (sessionId, options = {}) => {
+  const stateDir = resolveStateDir(options.stateDir);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_FOR_SESSION_TIMEOUT_MS;
+  let stream;
+  try {
+    stream = await openDaemonStream({ stateDir, spawn: options.spawn, autoSpawn: options.autoSpawn });
+  } catch (error) {
+    throw toAppductError(error);
+  }
+  try {
+    try {
+      await stream.call(RPC_METHODS5.sessionsDescribe, { selector: sessionId });
+      return makeAppClient(stream, sessionId);
+    } catch (error) {
+      if (!(error instanceof DaemonRpcError) || error.data?.type !== "unknown_session") {
+        throw error;
+      }
+    }
+    await new Promise((resolve2, reject) => {
+      let settled = false;
+      const settle = (fn) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        unsubscribeNotification();
+        unsubscribeClose();
+        fn();
+      };
+      const timer = setTimeout(() => {
+        settle(
+          () => reject(
+            new AppductError(
+              "timeout",
+              `Timed out after ${timeoutMs}ms waiting for session "${sessionId}" to be claimed.`
+            )
+          )
+        );
+      }, timeoutMs);
+      const unsubscribeClose = stream.onClose(() => {
+        settle(
+          () => reject(
+            new AppductError(
+              "connection_error",
+              `The connection to the Appduct daemon closed while waiting for session "${sessionId}" to be claimed.`
+            )
+          )
+        );
+      });
+      const unsubscribeNotification = stream.onNotification((payload) => {
+        if (settled) {
+          return;
+        }
+        const event = payload;
+        if (event.kind === "session_claimed" && event.sessionId === sessionId) {
+          settle(resolve2);
+        }
+      });
+      stream.call(RPC_METHODS5.eventsSubscribe, { sessionSelector: sessionId, kinds: ["session_claimed"] }).catch((error) => {
+        settle(() => reject(toAppductError(error)));
+      });
+    });
+    return makeAppClient(stream, sessionId);
+  } catch (error) {
+    stream.close();
+    throw toAppductError(error);
+  }
+};
+export {
+  AppductError,
+  connect3 as connect,
+  link,
+  waitForSession
+};