@pickforge/picklab 0.1.0

package/dist/chunk-SGSRIPSM.js

@@ -0,0 +1,3813 @@
+// src/commands/mcp.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp-server/dist/index.js
+import { createRequire } from "module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import fs8 from "fs";
+import path9 from "path";
+
+// ../core/dist/index.js
+import fs from "fs";
+import os from "os";
+import path from "path";
+import fs2 from "fs";
+import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
+import { spawn } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import { lstat, realpath } from "fs/promises";
+import path6 from "path";
+import { randomBytes } from "crypto";
+import fs5 from "fs";
+import path5 from "path";
+function picklabHome(env = process.env) {
+  const fromEnv = env.PICKLAB_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  return path.join(os.homedir(), ".picklab");
+}
+function sessionsDir(env = process.env) {
+  return path.join(picklabHome(env), "sessions");
+}
+function agentsDir(env = process.env) {
+  return path.join(picklabHome(env), "agents");
+}
+function projectConfigPath(projectDir) {
+  return path.join(projectDir, ".picklab", "config.json");
+}
+function globalConfigPath(env = process.env) {
+  return path.join(picklabHome(env), "config.json");
+}
+function runsDir(projectDir) {
+  return path.join(projectDir, ".picklab", "runs");
+}
+async function ensureDir(dir) {
+  await fs.promises.mkdir(dir, { recursive: true });
+  return dir;
+}
+var resolvedDefaults = {
+  android: { avdName: "picklab-avd" },
+  labUser: { name: "picklab-lab", home: "/var/lib/picklab/lab-home" }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, overlay) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === void 0) continue;
+    const existing = result[key];
+    if (isPlainObject(existing) && isPlainObject(value)) {
+      result[key] = deepMerge(existing, value);
+    } else {
+      result[key] = isPlainObject(value) ? deepMerge({}, value) : value;
+    }
+  }
+  return result;
+}
+async function readConfigFile(filePath) {
+  let raw;
+  try {
+    raw = await fs2.promises.readFile(filePath, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return {};
+    }
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+      throw new Error("expected a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(
+      `Invalid PickLab config at ${filePath}: ${error.message}`
+    );
+  }
+}
+async function loadConfig(projectDir, env = process.env) {
+  const global = await readConfigFile(globalConfigPath(env));
+  const project = await readConfigFile(projectConfigPath(projectDir));
+  return deepMerge(
+    deepMerge(deepMerge({}, resolvedDefaults), global),
+    project
+  );
+}
+var tmpCounter = 0;
+async function writeConfigFile(filePath, config) {
+  const dir = await ensureDir(path2.dirname(filePath));
+  tmpCounter += 1;
+  const tmp = path2.join(
+    dir,
+    `.${path2.basename(filePath)}.tmp-${process.pid}-${tmpCounter}`
+  );
+  await fs2.promises.writeFile(
+    tmp,
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+  await fs2.promises.rename(tmp, filePath);
+}
+async function saveProjectConfig(projectDir, config) {
+  await writeConfigFile(projectConfigPath(projectDir), config);
+}
+async function saveGlobalConfig(config, env = process.env) {
+  await writeConfigFile(globalConfigPath(env), config);
+}
+var SLUG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+var tmpCounter2 = 0;
+function assertValidSlug(slug) {
+  if (!SLUG_PATTERN.test(slug) || slug.includes("..")) {
+    throw new Error(
+      `Invalid run slug "${slug}": must start with a letter or digit and contain only letters, digits, ".", "_", or "-" (no path separators or "..")`
+    );
+  }
+}
+function formatTimestamp(date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}-${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`;
+}
+async function writeManifest(runDir, manifest) {
+  const target = path3.join(runDir, "manifest.json");
+  tmpCounter2 += 1;
+  const tmp = path3.join(
+    runDir,
+    `.manifest.json.tmp-${process.pid}-${tmpCounter2}`
+  );
+  await fs3.promises.writeFile(
+    tmp,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  await fs3.promises.rename(tmp, target);
+}
+var RunHandle = class {
+  dir;
+  manifest;
+  constructor(dir, manifest) {
+    this.dir = dir;
+    this.manifest = manifest;
+  }
+  get runId() {
+    return this.manifest.runId;
+  }
+  async addArtifact(type, name, artifactPath) {
+    const relative = path3.isAbsolute(artifactPath) ? path3.relative(this.dir, artifactPath) : artifactPath;
+    const artifact = {
+      type,
+      name,
+      path: relative,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.manifest.artifacts.push(artifact);
+    await writeManifest(this.dir, this.manifest);
+    return artifact;
+  }
+  async setStatus(status) {
+    this.manifest.status = status;
+    await writeManifest(this.dir, this.manifest);
+  }
+  async finish(status = "completed") {
+    await this.setStatus(status);
+  }
+};
+async function createRun(projectDir, slug, opts = {}) {
+  assertValidSlug(slug);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const baseName = `${formatTimestamp(now)}-${slug}`;
+  const parent = runsDir(projectDir);
+  await ensureDir(parent);
+  let runDir;
+  let runId = baseName;
+  for (let attempt = 1; runDir === void 0; attempt += 1) {
+    runId = attempt === 1 ? baseName : `${baseName}-${attempt}`;
+    const candidate = path3.join(parent, runId);
+    try {
+      await fs3.promises.mkdir(candidate);
+      runDir = candidate;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+  await ensureDir(path3.join(runDir, "screenshots"));
+  await ensureDir(path3.join(runDir, "logs"));
+  const manifest = {
+    runId,
+    slug,
+    createdAt: now.toISOString(),
+    status: "running",
+    artifacts: []
+  };
+  if (opts.sessionId !== void 0) manifest.sessionId = opts.sessionId;
+  if (opts.meta !== void 0) manifest.meta = opts.meta;
+  await writeManifest(runDir, manifest);
+  return new RunHandle(runDir, manifest);
+}
+async function listRuns(projectDir) {
+  const parent = runsDir(projectDir);
+  try {
+    const realProject = await fs3.promises.realpath(projectDir);
+    const realParent = await fs3.promises.realpath(parent);
+    if (realParent !== path3.join(realProject, ".picklab", "runs")) {
+      return [];
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  let entries;
+  try {
+    entries = await fs3.promises.readdir(parent, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const manifests = [];
+  for (const entry of entries) {
+    if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
+    const manifestPath = path3.join(parent, entry.name, "manifest.json");
+    try {
+      const manifestStat = await fs3.promises.lstat(manifestPath);
+      if (manifestStat.isSymbolicLink()) continue;
+      const raw = await fs3.promises.readFile(manifestPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && typeof parsed.runId === "string" && typeof parsed.createdAt === "string" && Array.isArray(parsed.artifacts)) {
+        manifests.push(parsed);
+      }
+    } catch {
+      continue;
+    }
+  }
+  manifests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  return manifests;
+}
+var REPLACEMENT = "[REDACTED]";
+var JSON_FIELD_RE = /("[^"\r\n]*(?:token|secret|password|passwd|api[_-]?key|authorization|bearer|credential)[^"\r\n]*"\s*:\s*)"(?:[^"\\]|\\.)*"/gi;
+var ASSIGNMENT_RE = /(\b[A-Za-z0-9_.-]*(?:token|secret|password|passwd|api[_-]?key|authorization|bearer|credential)[A-Za-z0-9_.-]*\s*[=:]\s*)("(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|(?:Bearer\s+)?(?:<[^<>\r\n]*>|[^\s\r\n"'<>]+(?:<[^<>\r\n]*>[^\s\r\n"'<>]*)*))/gi;
+var BEARER_VALUE_RE = /(\bBearer\s+)(?:<[^<>\r\n]*>|[^\s\r\n"'<>]+)/gi;
+var LITERAL_RES = [
+  /ghp_[A-Za-z0-9]{36}/g,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g
+];
+function redactSecrets(text) {
+  let result = text.replace(JSON_FIELD_RE, `$1"${REPLACEMENT}"`);
+  result = result.replace(ASSIGNMENT_RE, (_match, prefix, value) => {
+    const quote = value[0];
+    if (quote === '"' || quote === "'") {
+      return `${prefix}${quote}${REPLACEMENT}${quote}`;
+    }
+    return `${prefix}${REPLACEMENT}`;
+  });
+  result = result.replace(BEARER_VALUE_RE, `$1${REPLACEMENT}`);
+  for (const re of LITERAL_RES) {
+    result = result.replace(re, REPLACEMENT);
+  }
+  return result;
+}
+var DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+var DEFAULT_KILL_GRACE_MS = 2e3;
+var POLL_INTERVAL_MS = 50;
+var CommandError = class extends Error {
+  result;
+  constructor(cmd, args, result) {
+    const reason = result.code !== null ? `exited with code ${result.code}` : `killed with signal ${result.signal ?? "unknown"}`;
+    super(
+      `Command failed (${reason}${result.timedOut ? ", timed out" : ""}): ${cmd} ${args.join(" ")}`
+    );
+    this.name = "CommandError";
+    this.result = result;
+  }
+};
+function resolveEnv(opts) {
+  if (opts.cleanEnv) {
+    return opts.env ?? {};
+  }
+  return { ...process.env, ...opts.env };
+}
+function runCommand(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const maxBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const killGraceMs = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      env: resolveEnv(opts),
+      shell: false,
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let timedOut = false;
+    let settled = false;
+    let exited = false;
+    let exitCode = null;
+    let exitSignal = null;
+    const timers = [];
+    const collect = (chunks, counted, chunk) => {
+      if (counted >= maxBytes) return counted + chunk.length;
+      const remaining = maxBytes - counted;
+      chunks.push(chunk.length > remaining ? chunk.subarray(0, remaining) : chunk);
+      return counted + chunk.length;
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBytes = collect(stdoutChunks, stdoutBytes, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrBytes = collect(stderrChunks, stderrBytes, chunk);
+    });
+    const buildResult = (code, signal) => {
+      const stdoutBuffer = Buffer.concat(stdoutChunks);
+      const result = {
+        ok: code === 0 && !timedOut,
+        code,
+        signal,
+        stdout: opts.binary ? "" : stdoutBuffer.toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        timedOut,
+        stdoutTruncated: stdoutBytes > maxBytes,
+        stderrTruncated: stderrBytes > maxBytes
+      };
+      if (opts.binary) {
+        result.stdoutBuffer = stdoutBuffer;
+      }
+      return result;
+    };
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      for (const timer of timers) clearTimeout(timer);
+      if (opts.check && !result.ok) {
+        reject(new CommandError(cmd, args, result));
+        return;
+      }
+      resolve(result);
+    };
+    const killTree = (signal) => {
+      if (child.pid !== void 0) {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      try {
+        child.kill(signal);
+      } catch {
+      }
+    };
+    if (opts.timeoutMs !== void 0) {
+      timers.push(
+        setTimeout(() => {
+          timedOut = true;
+          killTree("SIGTERM");
+          timers.push(
+            setTimeout(() => {
+              killTree("SIGKILL");
+              timers.push(
+                setTimeout(() => {
+                  child.stdout.destroy();
+                  child.stderr.destroy();
+                  child.stdin.destroy();
+                  settle(
+                    buildResult(exitCode, exited ? exitSignal : "SIGKILL")
+                  );
+                }, killGraceMs)
+              );
+            }, killGraceMs)
+          );
+        }, opts.timeoutMs)
+      );
+    }
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      for (const timer of timers) clearTimeout(timer);
+      reject(error);
+    });
+    child.on("exit", (code, signal) => {
+      exited = true;
+      exitCode = code;
+      exitSignal = signal;
+    });
+    child.on("close", (code, signal) => {
+      settle(buildResult(code, signal));
+    });
+    child.stdin.on("error", () => {
+    });
+    if (opts.input !== void 0) {
+      child.stdin.write(opts.input);
+    }
+    child.stdin.end();
+  });
+}
+async function startDaemon(cmd, args, opts) {
+  await fs4.promises.mkdir(opts.logDir, { recursive: true });
+  const name = opts.name ?? path4.basename(cmd);
+  const logPath = path4.join(opts.logDir, `${name}.log`);
+  const fd = fs4.openSync(logPath, "a");
+  let child;
+  try {
+    child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      env: resolveEnv(opts),
+      shell: false,
+      detached: true,
+      stdio: ["ignore", fd, fd]
+    });
+  } catch (error) {
+    fs4.closeSync(fd);
+    throw error;
+  }
+  return new Promise((resolve, reject) => {
+    const onSpawn = () => {
+      cleanup();
+      if (child.pid === void 0) {
+        reject(new Error(`Failed to start daemon: ${cmd}`));
+        return;
+      }
+      child.unref();
+      resolve({ pid: child.pid, logPath });
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+      fs4.closeSync(fd);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function signalPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (error.code !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function stopPid(pid, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  if (!isPidAlive(pid)) return true;
+  signalPid(pid, "SIGTERM");
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) return true;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  signalPid(pid, "SIGKILL");
+  const killDeadline = Date.now() + 1e3;
+  while (Date.now() < killDeadline) {
+    if (!isPidAlive(pid)) return true;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return !isPidAlive(pid);
+}
+var ID_PREFIXES = {
+  desktop: "desk",
+  android: "andr",
+  "desktop+android": "duo"
+};
+var SESSION_ID_PATTERN = /^(desk|andr|duo)-[0-9a-f]{6,}$/;
+var MAX_ID_ATTEMPTS = 5;
+var tmpCounter3 = 0;
+function isValidSessionId(id) {
+  return SESSION_ID_PATTERN.test(id);
+}
+function invalidSessionIdError(id) {
+  return new Error(
+    `Invalid session id "${id}": must match ${SESSION_ID_PATTERN}`
+  );
+}
+function newSessionId(type) {
+  return `${ID_PREFIXES[type]}-${randomBytes(4).toString("hex")}`;
+}
+function sessionPath(id, env) {
+  return path5.join(sessionsDir(env), `${id}.json`);
+}
+function serialize(record) {
+  return `${JSON.stringify(record, null, 2)}
+`;
+}
+async function writeSession(record, env) {
+  const dir = await ensureDir(sessionsDir(env));
+  const target = path5.join(dir, `${record.id}.json`);
+  tmpCounter3 += 1;
+  const tmp = path5.join(
+    dir,
+    `.${record.id}.json.tmp-${process.pid}-${tmpCounter3}`
+  );
+  await fs5.promises.writeFile(tmp, serialize(record), "utf8");
+  await fs5.promises.rename(tmp, target);
+}
+async function createSession(input, env = process.env) {
+  await ensureDir(sessionsDir(env));
+  for (let attempt = 0; attempt < MAX_ID_ATTEMPTS; attempt += 1) {
+    const record = {
+      id: newSessionId(input.type),
+      type: input.type,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: input.status ?? "starting",
+      projectDir: input.projectDir
+    };
+    if (input.desktop !== void 0) record.desktop = input.desktop;
+    if (input.android !== void 0) record.android = input.android;
+    if (input.meta !== void 0) record.meta = input.meta;
+    try {
+      await fs5.promises.writeFile(sessionPath(record.id, env), serialize(record), {
+        encoding: "utf8",
+        flag: "wx"
+      });
+      return record;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+  throw new Error(
+    `Failed to allocate a unique session id after ${MAX_ID_ATTEMPTS} attempts`
+  );
+}
+async function getSession(id, env = process.env) {
+  if (!isValidSessionId(id)) {
+    return void 0;
+  }
+  const filePath = sessionPath(id, env);
+  let raw;
+  try {
+    raw = await fs5.promises.readFile(filePath, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid session record at ${filePath}: ${error.message}`
+    );
+  }
+}
+async function listSessions(env = process.env) {
+  let entries;
+  try {
+    entries = await fs5.promises.readdir(sessionsDir(env));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json") || entry.startsWith(".")) continue;
+    let record;
+    try {
+      record = await getSession(entry.slice(0, -".json".length), env);
+    } catch {
+      continue;
+    }
+    if (record !== void 0) records.push(record);
+  }
+  records.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return records;
+}
+async function updateSession(id, patch, env = process.env) {
+  if (!isValidSessionId(id)) {
+    throw invalidSessionIdError(id);
+  }
+  const existing = await getSession(id, env);
+  if (existing === void 0) {
+    throw new Error(`Session not found: ${id}`);
+  }
+  const updated = {
+    ...existing,
+    ...patch,
+    id: existing.id,
+    type: existing.type,
+    createdAt: existing.createdAt
+  };
+  await writeSession(updated, env);
+  return updated;
+}
+async function destroySessionRecord(id, env = process.env) {
+  if (!isValidSessionId(id)) {
+    throw invalidSessionIdError(id);
+  }
+  await fs5.promises.rm(sessionPath(id, env), { force: true });
+}
+async function resolveRunnableSession(type, id, opts) {
+  const env = opts.env ?? process.env;
+  if (id !== void 0) {
+    const record = await getSession(id, env);
+    if (record === void 0) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    if (record.type !== type) {
+      throw new Error(
+        `Session ${id} is of type "${record.type}", but this ${opts.consumerLabel} needs a ${type} session`
+      );
+    }
+    return record;
+  }
+  let candidates = (await listSessions(env)).filter(
+    (record) => record.type === type && record.status === "running"
+  );
+  let scopeLabel = "found";
+  if (opts.projectDir !== void 0) {
+    const projectDir = path6.resolve(opts.projectDir);
+    candidates = candidates.filter(
+      (record) => record.projectDir === projectDir
+    );
+    scopeLabel = "for this project";
+  }
+  if (candidates.length === 0) {
+    throw new Error(
+      `No running ${type} session ${scopeLabel}; ${opts.createHint}`
+    );
+  }
+  if (candidates.length > 1) {
+    throw new Error(
+      `Multiple running ${type} sessions ${scopeLabel} (${candidates.map((record) => record.id).join(", ")}); ` + opts.selectHint
+    );
+  }
+  return candidates[0];
+}
+function requireDisplay(record) {
+  const display = record.desktop?.display;
+  if (display === void 0) {
+    throw new Error(`Session ${record.id} has no display recorded`);
+  }
+  return display;
+}
+async function realpathNearest(target) {
+  let probe = target;
+  while (true) {
+    try {
+      const real = await realpath(probe);
+      if (probe === target) {
+        return real;
+      }
+      return path6.join(real, path6.relative(probe, target));
+    } catch {
+      const parent = path6.dirname(probe);
+      if (parent === probe) {
+        return target;
+      }
+      probe = parent;
+    }
+  }
+}
+async function resolveScreenshotTarget(opts) {
+  if (opts.out !== void 0 && opts.runSlug !== void 0) {
+    throw new Error(opts.conflictError);
+  }
+  if (opts.out !== void 0) {
+    if (opts.outBaseDir === void 0) {
+      return { outPath: path6.resolve(opts.out) };
+    }
+    const base = path6.resolve(opts.outBaseDir);
+    const outPath = path6.resolve(base, opts.out);
+    const relative = path6.relative(base, outPath);
+    if (relative === "" || relative.startsWith("..") || path6.isAbsolute(relative)) {
+      throw new Error(
+        `Refusing to write screenshot outside the project directory: ${opts.out}`
+      );
+    }
+    try {
+      const outStat = await lstat(outPath);
+      if (outStat.isSymbolicLink()) {
+        throw new Error(
+          `Refusing to write screenshot outside the project directory: ${opts.out}`
+        );
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const realBase = await realpathNearest(base);
+    const realProbe = await realpathNearest(outPath);
+    const realRelative = path6.relative(realBase, realProbe);
+    if (realProbe !== realBase && (realRelative.startsWith("..") || path6.isAbsolute(realRelative))) {
+      throw new Error(
+        `Refusing to write screenshot outside the project directory: ${opts.out}`
+      );
+    }
+    return { outPath };
+  }
+  const run = await createRun(
+    opts.projectDir,
+    opts.runSlug ?? opts.defaultSlug,
+    opts.sessionId === void 0 ? {} : { sessionId: opts.sessionId }
+  );
+  return {
+    outPath: path6.join(run.dir, "screenshots", "screenshot.png"),
+    run
+  };
+}
+async function captureToTarget(target, capture) {
+  try {
+    await capture();
+  } catch (error) {
+    if (target.run !== void 0) {
+      await target.run.finish("failed").catch(() => {
+      });
+    }
+    throw error;
+  }
+  const data = { path: target.outPath };
+  if (target.run !== void 0) {
+    try {
+      await target.run.addArtifact(
+        "screenshot",
+        path6.basename(target.outPath),
+        target.outPath
+      );
+      await target.run.finish("completed");
+    } catch (error) {
+      await target.run.finish("failed").catch(() => {
+      });
+      throw error;
+    }
+    data.runId = target.run.runId;
+    data.runDir = target.run.dir;
+  }
+  return data;
+}
+
+// ../mcp-server/dist/index.js
+import { z } from "zod";
+import fs24 from "fs";
+import path34 from "path";
+import {
+  ResourceTemplate
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+import path24 from "path";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+
+// ../android/dist/index.js
+import fs22 from "fs";
+import os2 from "os";
+import path22 from "path";
+import fs6 from "fs";
+import path7 from "path";
+import fs32 from "fs";
+import os22 from "os";
+import path32 from "path";
+import fs52 from "fs";
+import path52 from "path";
+import fs42 from "fs";
+import path42 from "path";
+import path62 from "path";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function findOnPath(name, env = process.env) {
+  const dirs = (env.PATH ?? "").split(path7.delimiter).filter((d) => d !== "");
+  for (const dir of dirs) {
+    const candidate = path7.join(dir, name);
+    if (isExecutableFile(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isExecutableFile(filePath) {
+  try {
+    fs6.accessSync(filePath, fs6.constants.X_OK);
+    return fs6.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+var SYSTEM_IMAGE_ID_PATTERN = /^system-images;[^;\s]+;[^;\s]+;[^;\s]+$/;
+var CMDLINE_TOOLS_VERSION_PATTERN = /^\d+(\.\d+)*$/;
+function commonSdkPaths(homeDir = os2.homedir()) {
+  return [
+    path22.join(homeDir, "Android", "Sdk"),
+    path22.join(homeDir, "Library", "Android", "sdk"),
+    path22.join("/opt", "android-sdk")
+  ];
+}
+function isDirectory(dir) {
+  try {
+    return fs22.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectSdkRoot(opts = {}) {
+  const env = opts.env ?? process.env;
+  for (const key of ["ANDROID_HOME", "ANDROID_SDK_ROOT"]) {
+    const candidate = env[key];
+    if (candidate !== void 0 && candidate !== "" && isDirectory(candidate)) {
+      return candidate;
+    }
+  }
+  const candidates = opts.commonPaths ?? commonSdkPaths(opts.homeDir);
+  for (const candidate of candidates) {
+    if (isDirectory(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function missingSdkMessage() {
+  return `Android SDK not found. Set ANDROID_HOME (or ANDROID_SDK_ROOT) to your SDK directory, or install it to one of: ${commonSdkPaths().join(", ")}. See https://developer.android.com/studio#command-line for command-line tools.`;
+}
+function resolveSdkRoot(sdk, env = process.env) {
+  return sdk === void 0 ? detectSdkRoot({ env }) : sdk;
+}
+function compareVersionsDesc(a, b) {
+  const left = a.split(".").map(Number);
+  const right = b.split(".").map(Number);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i += 1) {
+    const diff = (right[i] ?? 0) - (left[i] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+function cmdlineToolsBinDirs(sdk) {
+  const root = path22.join(sdk, "cmdline-tools");
+  const dirs = [path22.join(root, "latest", "bin")];
+  const versioned = listSubdirs(root).filter((name) => CMDLINE_TOOLS_VERSION_PATTERN.test(name)).sort(compareVersionsDesc);
+  for (const version2 of versioned) {
+    dirs.push(path22.join(root, version2, "bin"));
+  }
+  dirs.push(path22.join(root, "bin"));
+  return dirs;
+}
+function toolCandidateDirs(sdk, tool) {
+  if (tool === "emulator") {
+    return [path22.join(sdk, "emulator")];
+  }
+  return [...cmdlineToolsBinDirs(sdk), path22.join(sdk, "tools", "bin")];
+}
+function findSdkTool(sdk, tool, env = process.env) {
+  const root = resolveSdkRoot(sdk, env);
+  if (tool === "adb") {
+    if (root !== null) {
+      const candidate = path22.join(root, "platform-tools", "adb");
+      if (isExecutableFile(candidate)) {
+        return candidate;
+      }
+    }
+    return findOnPath("adb", env);
+  }
+  if (root === null) {
+    return findOnPath(tool, env);
+  }
+  for (const dir of toolCandidateDirs(root, tool)) {
+    const candidate = path22.join(dir, tool);
+    if (isExecutableFile(candidate)) {
+      return candidate;
+    }
+  }
+  return findOnPath(tool, env);
+}
+function detectSdkTools(opts = {}) {
+  const env = opts.env ?? process.env;
+  const sdk = resolveSdkRoot(opts.sdk, env);
+  return {
+    sdkmanager: findSdkTool(sdk, "sdkmanager", env),
+    avdmanager: findSdkTool(sdk, "avdmanager", env),
+    emulator: findSdkTool(sdk, "emulator", env),
+    adb: findSdkTool(sdk, "adb", env)
+  };
+}
+function listSubdirs(dir) {
+  let entries;
+  try {
+    entries = fs22.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const names = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      names.push(entry.name);
+    } else if (entry.isSymbolicLink() && isDirectory(path22.join(dir, entry.name))) {
+      names.push(entry.name);
+    }
+  }
+  return names;
+}
+function listSystemImages(sdk) {
+  const root = path22.join(sdk, "system-images");
+  const images = [];
+  for (const api of listSubdirs(root)) {
+    for (const tag of listSubdirs(path22.join(root, api))) {
+      for (const abi of listSubdirs(path22.join(root, api, tag))) {
+        images.push({
+          packageId: `system-images;${api};${tag};${abi}`,
+          api,
+          tag,
+          abi,
+          path: path22.join(root, api, tag, abi)
+        });
+      }
+    }
+  }
+  images.sort((a, b) => a.packageId.localeCompare(b.packageId));
+  return images;
+}
+function isValidSystemImageId(packageId) {
+  return SYSTEM_IMAGE_ID_PATTERN.test(packageId);
+}
+function assertSystemImageId(packageId) {
+  if (!isValidSystemImageId(packageId)) {
+    throw new Error(
+      `Invalid system image "${packageId}": expected the form "system-images;android-<api>;<tag>;<abi>"`
+    );
+  }
+}
+function sdkmanagerInstallCommand(packageId) {
+  assertSystemImageId(packageId);
+  return `sdkmanager "${packageId}"`;
+}
+function detectKvm(kvmPath = "/dev/kvm") {
+  const exists = fs22.existsSync(kvmPath);
+  let readable = false;
+  let writable = false;
+  if (exists) {
+    try {
+      fs22.accessSync(kvmPath, fs22.constants.R_OK);
+      readable = true;
+    } catch {
+      readable = false;
+    }
+    try {
+      fs22.accessSync(kvmPath, fs22.constants.W_OK);
+      writable = true;
+    } catch {
+      writable = false;
+    }
+  }
+  return { exists, readable, writable, supported: exists && readable && writable };
+}
+function detectAndroidEnvironment(opts = {}) {
+  const sdkRoot = detectSdkRoot(opts);
+  return {
+    sdkRoot,
+    tools: detectSdkTools({ sdk: sdkRoot, env: opts.env }),
+    systemImages: sdkRoot === null ? [] : listSystemImages(sdkRoot),
+    kvm: detectKvm(opts.kvmPath)
+  };
+}
+var DEFAULT_AVD_NAME = "picklab-avd";
+var AVD_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var LIST_AVDS_TIMEOUT_MS = 3e4;
+function assertAvdName(name) {
+  if (!AVD_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid AVD name "${name}": expected only letters, digits, dots, underscores, and hyphens`
+    );
+  }
+}
+function assertDeviceProfile(device) {
+  if (device === "" || device.startsWith("-") || /[\x00-\x1f\x7f]/.test(device)) {
+    throw new Error(
+      `Invalid device profile "${device}": expected a non-empty avdmanager device id or name`
+    );
+  }
+}
+function buildCreateAvdArgs(opts) {
+  assertAvdName(opts.name);
+  assertSystemImageId(opts.systemImage);
+  const args = ["create", "avd", "-n", opts.name, "-k", opts.systemImage];
+  if (opts.device !== void 0) {
+    assertDeviceProfile(opts.device);
+    args.push("--device", opts.device);
+  }
+  return args;
+}
+function avdHomeDir(env = process.env) {
+  const fromEnv = env.ANDROID_AVD_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  const home2 = env.HOME !== void 0 && env.HOME !== "" ? env.HOME : os22.homedir();
+  return path32.join(home2, ".android", "avd");
+}
+function parseEmulatorListAvds(output) {
+  return output.split("\n").map((line) => line.trim()).filter((line) => AVD_NAME_PATTERN.test(line));
+}
+function scanAvdHome(env = process.env) {
+  let entries;
+  try {
+    entries = fs32.readdirSync(avdHomeDir(env));
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".ini")).map((entry) => entry.slice(0, -".ini".length)).filter((name) => AVD_NAME_PATTERN.test(name)).sort();
+}
+async function listAvds(opts = {}) {
+  const env = opts.env ?? process.env;
+  const emulator = findSdkTool(opts.sdk, "emulator", env);
+  if (emulator !== null) {
+    try {
+      const result = await runCommand(emulator, ["-list-avds"], {
+        env: opts.env,
+        timeoutMs: LIST_AVDS_TIMEOUT_MS
+      });
+      if (result.ok) {
+        return parseEmulatorListAvds(result.stdout);
+      }
+    } catch {
+    }
+  }
+  return scanAvdHome(env);
+}
+var KEYCODE_HOME = "KEYCODE_HOME";
+var KEYCODE_BACK = "KEYCODE_BACK";
+var UI_DUMP_REMOTE_PATH = "/sdcard/picklab-ui.xml";
+var SERIAL_PATTERN = /^[A-Za-z0-9._:-]+$/;
+var PACKAGE_PATTERN = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/;
+var ACTIVITY_PATTERN = /^\.?[A-Za-z_$][A-Za-z0-9_$]*(\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+var KEYCODE_PATTERN = /^(KEYCODE_[A-Z0-9_]+|\d+)$/;
+var PNG_MAGIC = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var ADB_TIMEOUT_MS = 3e4;
+var INSTALL_TIMEOUT_MS = 3e5;
+var SCREENSHOT_TIMEOUT_MS = 6e4;
+var SCREENSHOT_MAX_BYTES = 64 * 1024 * 1024;
+var DEFAULT_LOGCAT_LINES = 500;
+var DEFAULT_UI_DUMP_ATTEMPTS = 15;
+var DEFAULT_UI_DUMP_RETRY_DELAY_MS = 2e3;
+function assertSerial(serial) {
+  if (!SERIAL_PATTERN.test(serial)) {
+    throw new Error(
+      `Invalid device serial "${serial}": expected only letters, digits, dots, colons, underscores, and hyphens`
+    );
+  }
+}
+function assertPackageName(packageName2) {
+  if (!PACKAGE_PATTERN.test(packageName2)) {
+    throw new Error(
+      `Invalid package name "${packageName2}": expected a Java package like "com.example.app"`
+    );
+  }
+}
+function assertActivity(activity) {
+  if (!ACTIVITY_PATTERN.test(activity)) {
+    throw new Error(
+      `Invalid activity "${activity}": expected a class name like ".MainActivity" or "com.example.app.MainActivity"`
+    );
+  }
+}
+function assertCoordinate(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(
+      `Invalid ${label} coordinate ${value}: expected a non-negative integer`
+    );
+  }
+}
+function resolveAdb(opts = {}) {
+  const adb = findSdkTool(opts.sdk, "adb", opts.env ?? process.env);
+  if (adb === null) {
+    throw new Error(
+      `adb not found in <sdk>/platform-tools or on PATH; install it with: sdkmanager "platform-tools" (or your distro's android-tools package)`
+    );
+  }
+  return adb;
+}
+function escapeInputText(text) {
+  return text.replace(/[\\()<>|;&*~"'`$]/g, (c) => `\\${c}`).replace(/ /g, "%s");
+}
+function splitInputText(text) {
+  return text.split(/(?<=%)(?=s)/);
+}
+function buildInstallApkArgs(serial, apkPath) {
+  assertSerial(serial);
+  if (apkPath === "") {
+    throw new Error("Invalid apkPath: expected a non-empty path");
+  }
+  return ["-s", serial, "install", "-r", apkPath];
+}
+function buildLaunchAppArgs(serial, packageName2, activity) {
+  assertSerial(serial);
+  assertPackageName(packageName2);
+  if (activity !== void 0) {
+    assertActivity(activity);
+    return [
+      "-s",
+      serial,
+      "shell",
+      "am",
+      "start",
+      "-n",
+      `${packageName2}/${activity}`
+    ];
+  }
+  return [
+    "-s",
+    serial,
+    "shell",
+    "monkey",
+    "-p",
+    packageName2,
+    "-c",
+    "android.intent.category.LAUNCHER",
+    "1"
+  ];
+}
+function buildScreenshotArgs(serial) {
+  assertSerial(serial);
+  return ["-s", serial, "exec-out", "screencap", "-p"];
+}
+function buildTapArgs(serial, x, y) {
+  assertSerial(serial);
+  assertCoordinate(x, "x");
+  assertCoordinate(y, "y");
+  return ["-s", serial, "shell", "input", "tap", String(x), String(y)];
+}
+function buildTypeTextArgs(serial, text) {
+  assertSerial(serial);
+  if (text === "") {
+    throw new Error("Invalid text: expected a non-empty string");
+  }
+  if (/[\x00-\x1f\x7f]/.test(text)) {
+    throw new Error(
+      "Invalid text: control characters (including newlines) are not supported by android input text"
+    );
+  }
+  if (/[^\x20-\x7e]/.test(text)) {
+    throw new Error(
+      'Invalid text: non-ASCII characters cannot be typed with android "input text"; use ASCII text, or set the field content through the app itself (clipboard or deep link)'
+    );
+  }
+  if (text.includes("%s")) {
+    throw new Error(
+      'Invalid text: the device input tool turns "%s" into a space; use typeText, which splits such text into safe chunks'
+    );
+  }
+  return ["-s", serial, "shell", "input", "text", escapeInputText(text)];
+}
+function buildKeyeventArgs(serial, key) {
+  assertSerial(serial);
+  if (!KEYCODE_PATTERN.test(key)) {
+    throw new Error(
+      `Invalid key "${key}": expected a KEYCODE_* name or a numeric keycode`
+    );
+  }
+  return ["-s", serial, "shell", "input", "keyevent", key];
+}
+function buildUiDumpArgs(serial) {
+  assertSerial(serial);
+  return ["-s", serial, "shell", "uiautomator", "dump", UI_DUMP_REMOTE_PATH];
+}
+function buildUiCatArgs(serial) {
+  assertSerial(serial);
+  return ["-s", serial, "exec-out", "cat", UI_DUMP_REMOTE_PATH];
+}
+function buildUiCleanupArgs(serial) {
+  assertSerial(serial);
+  return ["-s", serial, "shell", "rm", "-f", UI_DUMP_REMOTE_PATH];
+}
+function buildLogcatArgs(serial, opts = {}) {
+  assertSerial(serial);
+  const lines = opts.lines ?? DEFAULT_LOGCAT_LINES;
+  if (!Number.isInteger(lines) || lines <= 0) {
+    throw new Error(`Invalid lines ${lines}: expected a positive integer`);
+  }
+  const args = ["-s", serial, "logcat", "-d", "-t", String(lines)];
+  if (opts.filter !== void 0 && opts.filter.trim() !== "") {
+    args.push(...opts.filter.trim().split(/\s+/));
+  }
+  return args;
+}
+function buildClearLogcatArgs(serial) {
+  assertSerial(serial);
+  return ["-s", serial, "logcat", "-c"];
+}
+function parseAdbDevices(output) {
+  const devices = [];
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("List of devices") || trimmed.startsWith("*")) {
+      continue;
+    }
+    const [serial, state] = trimmed.split(/\s+/);
+    if (serial !== void 0 && state !== void 0 && SERIAL_PATTERN.test(serial)) {
+      devices.push({ serial, state });
+    }
+  }
+  return devices;
+}
+async function execAdb(opts, args, runOpts = {}) {
+  const adb = resolveAdb(opts);
+  const baseOpts = {
+    env: opts.env,
+    timeoutMs: runOpts.timeoutMs ?? ADB_TIMEOUT_MS,
+    maxOutputBytes: runOpts.maxOutputBytes
+  };
+  if (runOpts.binary === true) {
+    return runCommand(adb, args, { ...baseOpts, binary: true });
+  }
+  return runCommand(adb, args, baseOpts);
+}
+function commandFailure(what, args, result) {
+  const detail = result.stderr.trim() || result.stdout.trim() || (result.timedOut ? "timed out" : `exit code ${result.code}`);
+  return new Error(`${what} failed (adb ${args.join(" ")}): ${detail}`);
+}
+async function listDevices(opts = {}) {
+  const result = await execAdb(opts, ["devices"]);
+  if (!result.ok) {
+    throw commandFailure("adb devices", ["devices"], result);
+  }
+  return parseAdbDevices(result.stdout);
+}
+async function installApk(opts) {
+  const args = buildInstallApkArgs(opts.serial, opts.apkPath);
+  const result = await execAdb(opts, args, { timeoutMs: INSTALL_TIMEOUT_MS });
+  if (!result.ok || /Failure/.test(result.stdout)) {
+    throw commandFailure(`apk install of ${opts.apkPath}`, args, result);
+  }
+}
+async function launchApp(opts) {
+  const args = buildLaunchAppArgs(opts.serial, opts.packageName, opts.activity);
+  const result = await execAdb(opts, args);
+  if (!result.ok || /^Error/m.test(result.stdout) || /monkey aborted/i.test(result.stdout) || /monkey aborted/i.test(result.stderr)) {
+    throw commandFailure(`launch of ${opts.packageName}`, args, result);
+  }
+}
+async function screenshot(opts) {
+  const args = buildScreenshotArgs(opts.serial);
+  const result = await execAdb(opts, args, {
+    timeoutMs: SCREENSHOT_TIMEOUT_MS,
+    binary: true,
+    maxOutputBytes: SCREENSHOT_MAX_BYTES
+  });
+  if (!result.ok) {
+    throw commandFailure("screenshot", args, result);
+  }
+  if (result.stdoutTruncated) {
+    throw new Error(
+      `screenshot output exceeded ${SCREENSHOT_MAX_BYTES} bytes and was truncated`
+    );
+  }
+  const data = result.stdoutBuffer;
+  if (data.length < PNG_MAGIC.length || !data.subarray(0, PNG_MAGIC.length).equals(PNG_MAGIC)) {
+    throw new Error(
+      `screencap on ${opts.serial} did not produce a PNG image (got ${data.length} bytes)`
+    );
+  }
+  await fs42.promises.mkdir(path42.dirname(opts.outPath), { recursive: true });
+  await fs42.promises.writeFile(opts.outPath, data);
+  return { path: opts.outPath };
+}
+async function tap(opts) {
+  const args = buildTapArgs(opts.serial, opts.x, opts.y);
+  const result = await execAdb(opts, args);
+  if (!result.ok) {
+    throw commandFailure(`tap at (${opts.x}, ${opts.y})`, args, result);
+  }
+}
+async function typeText(opts) {
+  for (const chunk of splitInputText(opts.text)) {
+    const args = buildTypeTextArgs(opts.serial, chunk);
+    const result = await execAdb(opts, args);
+    if (!result.ok) {
+      throw commandFailure("text input", args, result);
+    }
+  }
+}
+async function pressKey(opts) {
+  const args = buildKeyeventArgs(opts.serial, opts.key);
+  const result = await execAdb(opts, args);
+  if (!result.ok) {
+    throw commandFailure(`keyevent ${opts.key}`, args, result);
+  }
+}
+async function back(opts) {
+  await pressKey({ ...opts, key: KEYCODE_BACK });
+}
+async function home(opts) {
+  await pressKey({ ...opts, key: KEYCODE_HOME });
+}
+async function dumpUiTreeOnce(opts) {
+  const dumpArgs = buildUiDumpArgs(opts.serial);
+  const dumpResult = await execAdb(opts, dumpArgs);
+  if (!dumpResult.ok || /ERROR/i.test(dumpResult.stderr) || /ERROR/.test(dumpResult.stdout)) {
+    throw commandFailure("uiautomator dump", dumpArgs, dumpResult);
+  }
+  try {
+    const catArgs = buildUiCatArgs(opts.serial);
+    const catResult = await execAdb(opts, catArgs);
+    if (!catResult.ok) {
+      throw commandFailure("ui tree read", catArgs, catResult);
+    }
+    const xml = catResult.stdout.trim();
+    if (!xml.startsWith("<?xml") && !xml.startsWith("<hierarchy")) {
+      throw new Error(
+        `uiautomator dump on ${opts.serial} did not return XML: ${xml.slice(0, 120)}`
+      );
+    }
+    return xml;
+  } finally {
+    await execAdb(opts, buildUiCleanupArgs(opts.serial)).catch(() => {
+    });
+  }
+}
+async function getUiTree(opts) {
+  const attempts = opts.attempts ?? DEFAULT_UI_DUMP_ATTEMPTS;
+  if (!Number.isInteger(attempts) || attempts <= 0) {
+    throw new Error(`Invalid attempts ${attempts}: expected a positive integer`);
+  }
+  const retryDelayMs = opts.retryDelayMs ?? DEFAULT_UI_DUMP_RETRY_DELAY_MS;
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      return await dumpUiTreeOnce(opts);
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts - 1) {
+        await sleep2(retryDelayMs);
+      }
+    }
+  }
+  throw lastError;
+}
+async function logcat(opts) {
+  const args = buildLogcatArgs(opts.serial, {
+    lines: opts.lines,
+    filter: opts.filter
+  });
+  const result = await execAdb(opts, args);
+  if (!result.ok) {
+    throw commandFailure("logcat", args, result);
+  }
+  return result.stdout;
+}
+async function clearLogcat(opts) {
+  const args = buildClearLogcatArgs(opts.serial);
+  const result = await execAdb(opts, args);
+  if (!result.ok) {
+    throw commandFailure("logcat clear", args, result);
+  }
+}
+async function runAdb(opts) {
+  const args = [...opts.args];
+  if (opts.serial !== void 0) {
+    assertSerial(opts.serial);
+    args.unshift("-s", opts.serial);
+  }
+  return execAdb(opts, args, { timeoutMs: opts.timeoutMs });
+}
+var MIN_CONSOLE_PORT = 5554;
+var MAX_CONSOLE_PORT = 5682;
+var DEFAULT_BOOT_TIMEOUT_MS = 18e4;
+var DEFAULT_BOOT_POLL_INTERVAL_MS = 2e3;
+var GETPROP_TIMEOUT_MS = 1e4;
+var EMU_KILL_TIMEOUT_MS = 1e4;
+var EMU_KILL_POLL_INTERVAL_MS = 200;
+function assertConsolePort(port) {
+  if (!Number.isInteger(port) || port < MIN_CONSOLE_PORT || port > MAX_CONSOLE_PORT || port % 2 !== 0) {
+    throw new Error(
+      `Invalid console port ${port}: expected an even integer between ${MIN_CONSOLE_PORT} and ${MAX_CONSOLE_PORT}`
+    );
+  }
+}
+function emulatorSerial(consolePort) {
+  assertConsolePort(consolePort);
+  return `emulator-${consolePort}`;
+}
+function buildEmulatorArgs(opts) {
+  assertAvdName(opts.avdName);
+  const port = opts.port ?? MIN_CONSOLE_PORT;
+  assertConsolePort(port);
+  const args = ["-avd", opts.avdName];
+  if (opts.headless !== false) {
+    args.push("-no-window");
+  }
+  args.push("-no-audio", "-no-boot-anim", "-port", String(port));
+  return args;
+}
+async function waitForBoot(opts) {
+  assertSerial(opts.serial);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_BOOT_TIMEOUT_MS;
+  const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_BOOT_POLL_INTERVAL_MS;
+  const logHint = opts.logPath !== void 0 ? `; check the log at ${opts.logPath}` : "";
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  for (; ; ) {
+    if (opts.signal?.aborted === true) {
+      throw new Error(
+        `Aborted while waiting for emulator ${opts.serial} to boot${logHint}`
+      );
+    }
+    if (opts.isEmulatorAlive !== void 0 && !opts.isEmulatorAlive()) {
+      throw new Error(
+        `Emulator for ${opts.serial} exited before finishing boot${logHint}`
+      );
+    }
+    opts.onProgress?.(
+      `waiting for emulator ${opts.serial} to boot (${Math.round((Date.now() - startedAt) / 1e3)}s elapsed)`
+    );
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(
+        `Emulator ${opts.serial} did not finish booting within ${timeoutMs}ms${logHint}`
+      );
+    }
+    const result = await runCommand(
+      opts.adbPath,
+      ["-s", opts.serial, "shell", "getprop", "sys.boot_completed"],
+      { env: opts.env, timeoutMs: Math.min(GETPROP_TIMEOUT_MS, remainingMs) }
+    );
+    if (result.ok && result.stdout.trim() === "1") {
+      if (opts.isEmulatorAlive !== void 0 && !opts.isEmulatorAlive()) {
+        throw new Error(
+          `Emulator for ${opts.serial} exited before finishing boot${logHint}`
+        );
+      }
+      return;
+    }
+    if (Date.now() + pollIntervalMs > deadline) {
+      throw new Error(
+        `Emulator ${opts.serial} did not finish booting within ${timeoutMs}ms${logHint}`
+      );
+    }
+    await sleep2(pollIntervalMs);
+  }
+}
+function consolePortLockPath(port, registryEnv = process.env) {
+  return path52.join(picklabHome(registryEnv), "ports", `emulator-${port}.lock`);
+}
+function readLockOwnerPid(lockPath) {
+  try {
+    const pid = Number(fs52.readFileSync(lockPath, "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function tryReserveConsolePort(port, registryEnv = process.env, ownerPid = process.pid) {
+  assertConsolePort(port);
+  const lockPath = consolePortLockPath(port, registryEnv);
+  fs52.mkdirSync(path52.dirname(lockPath), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs52.writeFileSync(lockPath, `${ownerPid}
+`, { flag: "wx" });
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const owner = readLockOwnerPid(lockPath);
+      if (owner !== null && isPidAlive(owner)) {
+        return false;
+      }
+      fs52.rmSync(lockPath, { force: true });
+    }
+  }
+  return false;
+}
+function releaseConsolePort(port, registryEnv = process.env) {
+  try {
+    fs52.rmSync(consolePortLockPath(port, registryEnv), { force: true });
+  } catch {
+  }
+}
+function claimConsolePort(port, ownerPid, registryEnv) {
+  try {
+    fs52.writeFileSync(consolePortLockPath(port, registryEnv), `${ownerPid}
+`);
+  } catch {
+  }
+}
+async function allocateConsolePort(opts) {
+  let devices;
+  try {
+    devices = await listDevices(opts);
+  } catch (error) {
+    throw new Error(
+      "Failed to list adb devices while allocating an emulator console port",
+      { cause: error }
+    );
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const device of devices) {
+    const match = /^emulator-(\d+)$/.exec(device.serial);
+    if (match !== null) {
+      used.add(Number(match[1]));
+    }
+  }
+  const registryEnv = opts.registryEnv ?? process.env;
+  for (let port = MIN_CONSOLE_PORT; port <= MAX_CONSOLE_PORT; port += 2) {
+    if (used.has(port)) {
+      continue;
+    }
+    if (tryReserveConsolePort(port, registryEnv)) {
+      return port;
+    }
+  }
+  throw new Error(
+    `No free emulator console port between ${MIN_CONSOLE_PORT} and ${MAX_CONSOLE_PORT}`
+  );
+}
+async function startEmulator(opts) {
+  const avdName = opts.avdName ?? DEFAULT_AVD_NAME;
+  const env = opts.env ?? process.env;
+  const registryEnv = opts.registryEnv ?? process.env;
+  const sdk = resolveSdkRoot(opts.sdk, env);
+  const emulator = findSdkTool(sdk, "emulator", env);
+  if (emulator === null) {
+    throw new Error(
+      'Android emulator binary not found (<sdk>/emulator/emulator or PATH); install it with: sdkmanager "emulator", or set ANDROID_HOME'
+    );
+  }
+  const adbPath = resolveAdb({ sdk, env: opts.env });
+  let port;
+  if (opts.port !== void 0) {
+    assertConsolePort(opts.port);
+    if (!tryReserveConsolePort(opts.port, registryEnv)) {
+      throw new Error(
+        `Console port ${opts.port} is already reserved by another PickLab emulator (${consolePortLockPath(opts.port, registryEnv)})`
+      );
+    }
+    port = opts.port;
+  } else {
+    port = await allocateConsolePort({ sdk, env: opts.env, registryEnv });
+  }
+  try {
+    const args = buildEmulatorArgs({
+      avdName,
+      headless: opts.headless,
+      port
+    });
+    const serial = emulatorSerial(port);
+    const sdkEnv = sdk !== null ? { ANDROID_HOME: sdk, ANDROID_SDK_ROOT: sdk } : {};
+    if (opts.signal?.aborted === true) {
+      throw new Error(
+        `Aborted before starting the emulator for AVD ${avdName}`
+      );
+    }
+    opts.onProgress?.(`starting emulator for AVD ${avdName} (${serial})`);
+    const daemon = await startDaemon(emulator, args, {
+      logDir: opts.logDir,
+      name: "emulator",
+      env: { ...sdkEnv, ...opts.env }
+    });
+    claimConsolePort(port, daemon.pid, registryEnv);
+    try {
+      await waitForBoot({
+        serial,
+        adbPath,
+        env: opts.env,
+        timeoutMs: opts.bootTimeoutMs,
+        pollIntervalMs: opts.bootPollIntervalMs,
+        isEmulatorAlive: () => isPidAlive(daemon.pid),
+        logPath: daemon.logPath,
+        onProgress: opts.onProgress,
+        signal: opts.signal
+      });
+    } catch (error) {
+      await stopPid(daemon.pid).catch(() => {
+      });
+      throw error;
+    }
+    return {
+      pid: daemon.pid,
+      serial,
+      consolePort: port,
+      logPath: daemon.logPath
+    };
+  } catch (error) {
+    releaseConsolePort(port, registryEnv);
+    throw error;
+  }
+}
+async function stopEmulator(opts) {
+  const stopped = await stopEmulatorProcess(opts);
+  if (stopped && opts.serial !== void 0) {
+    const match = /^emulator-(\d+)$/.exec(opts.serial);
+    if (match !== null) {
+      releaseConsolePort(Number(match[1]), opts.registryEnv ?? process.env);
+    }
+  }
+  return stopped;
+}
+async function stopEmulatorProcess(opts) {
+  const timeoutMs = opts.timeoutMs ?? EMU_KILL_TIMEOUT_MS;
+  let adbPath = null;
+  try {
+    adbPath = resolveAdb(opts);
+  } catch {
+    adbPath = null;
+  }
+  let sentEmuKill = false;
+  if (opts.serial !== void 0 && adbPath !== null) {
+    assertSerial(opts.serial);
+    const killResult = await runCommand(
+      adbPath,
+      ["-s", opts.serial, "emu", "kill"],
+      { env: opts.env, timeoutMs: 5e3 }
+    ).catch(() => null);
+    sentEmuKill = killResult !== null && killResult.ok;
+  }
+  if (opts.pid !== void 0) {
+    if (sentEmuKill) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline && isPidAlive(opts.pid)) {
+        await sleep2(EMU_KILL_POLL_INTERVAL_MS);
+      }
+    }
+    if (isPidAlive(opts.pid)) {
+      return stopPid(opts.pid);
+    }
+    return true;
+  }
+  if (opts.serial !== void 0 && adbPath !== null) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try {
+        const devices = await listDevices(opts);
+        if (!devices.some((device) => device.serial === opts.serial)) {
+          return true;
+        }
+      } catch {
+        return false;
+      }
+      await sleep2(EMU_KILL_POLL_INTERVAL_MS);
+    }
+    return false;
+  }
+  return true;
+}
+function androidSessionLogDir(id, registryEnv = process.env) {
+  return path62.join(sessionsDir(registryEnv), id);
+}
+async function createAndroidSession(opts) {
+  const registryEnv = opts.registryEnv ?? process.env;
+  const avdName = opts.avdName ?? DEFAULT_AVD_NAME;
+  const record = await createSession(
+    { type: "android", projectDir: opts.projectDir, android: { avdName } },
+    registryEnv
+  );
+  const logDir = androidSessionLogDir(record.id, registryEnv);
+  let emulator;
+  try {
+    emulator = await startEmulator({
+      avdName,
+      sdk: opts.sdk,
+      headless: opts.headless,
+      port: opts.port,
+      logDir,
+      env: opts.env,
+      registryEnv,
+      bootTimeoutMs: opts.bootTimeoutMs,
+      bootPollIntervalMs: opts.bootPollIntervalMs,
+      onProgress: opts.onProgress,
+      signal: opts.signal
+    });
+    const android = {
+      avdName,
+      serial: emulator.serial,
+      emulatorPid: emulator.pid,
+      consolePort: emulator.consolePort
+    };
+    await updateSession(record.id, { status: "running", android }, registryEnv);
+    return {
+      id: record.id,
+      avdName,
+      serial: emulator.serial,
+      consolePort: emulator.consolePort,
+      emulatorPid: emulator.pid,
+      logPath: emulator.logPath,
+      logDir
+    };
+  } catch (error) {
+    if (emulator !== void 0) {
+      await stopEmulator({
+        serial: emulator.serial,
+        pid: emulator.pid,
+        sdk: opts.sdk,
+        env: opts.env,
+        registryEnv
+      }).catch(() => {
+      });
+    }
+    await updateSession(record.id, { status: "error" }, registryEnv).catch(
+      () => {
+      }
+    );
+    throw error;
+  }
+}
+async function destroyAndroidSession(id, registryEnv = process.env, opts = {}) {
+  const record = await getSession(id, registryEnv);
+  if (record === void 0) {
+    throw new Error(`Android session not found: ${id}`);
+  }
+  const android = record.android;
+  if (android?.emulatorPid !== void 0 || android?.serial !== void 0) {
+    let stopped;
+    let failure;
+    try {
+      stopped = await stopEmulator({
+        serial: android.serial,
+        pid: android.emulatorPid,
+        sdk: opts.sdk,
+        env: opts.env,
+        registryEnv,
+        timeoutMs: opts.timeoutMs
+      });
+    } catch (error) {
+      stopped = false;
+      failure = error instanceof Error ? error : new Error(String(error));
+    }
+    if (!stopped) {
+      await updateSession(id, { status: "error" }, registryEnv).catch(() => {
+      });
+      throw new Error(
+        `Failed to stop emulator of android session ${id} (serial ${android.serial ?? "unknown"}, pid ${android.emulatorPid ?? "unknown"})` + (failure !== void 0 ? `: ${failure.message}` : "")
+      );
+    }
+  }
+  await destroySessionRecord(id, registryEnv);
+}
+async function getAndroidSessionStatus(id, registryEnv = process.env, opts = {}) {
+  const record = await getSession(id, registryEnv);
+  if (record === void 0) {
+    throw new Error(`Android session not found: ${id}`);
+  }
+  const android = record.android;
+  const emulatorAlive = android?.emulatorPid !== void 0 && isPidAlive(android.emulatorPid);
+  let deviceState = null;
+  if (android?.serial !== void 0) {
+    try {
+      const devices = await listDevices(opts);
+      deviceState = devices.find((device) => device.serial === android.serial)?.state ?? null;
+    } catch {
+      deviceState = null;
+    }
+  }
+  return { record, emulatorAlive, deviceState };
+}
+
+// ../desktop-linux/dist/index.js
+import fs23 from "fs";
+import fs7 from "fs";
+import path8 from "path";
+import net from "net";
+import crypto from "crypto";
+import fs33 from "fs";
+import path23 from "path";
+import path33 from "path";
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function findOnPath2(name, env = process.env) {
+  const dirs = (env.PATH ?? "").split(path8.delimiter).filter((d) => d !== "");
+  for (const dir of dirs) {
+    const candidate = path8.join(dir, name);
+    try {
+      fs7.accessSync(candidate, fs7.constants.X_OK);
+      if (fs7.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+var DISPLAY_PATTERN = /^:\d+$/;
+var DEFAULT_WIDTH = 1280;
+var DEFAULT_HEIGHT = 800;
+var DEFAULT_DEPTH = 24;
+var DEFAULT_START_DISPLAY = 90;
+var DEFAULT_MAX_ATTEMPTS = 200;
+var SOCKET_POLL_INTERVAL_MS = 100;
+var DEFAULT_WAIT_TIMEOUT_MS = 1e4;
+var ALLOCATION_RETRY_LIMIT = 5;
+function parseDisplayNumber(display) {
+  if (!DISPLAY_PATTERN.test(display)) {
+    throw new Error(
+      `Invalid display "${display}": expected the form ":<number>"`
+    );
+  }
+  return Number.parseInt(display.slice(1), 10);
+}
+function displaySocketPath(displayNumber) {
+  return `/tmp/.X11-unix/X${displayNumber}`;
+}
+function displayLockPath(displayNumber) {
+  return `/tmp/.X${displayNumber}-lock`;
+}
+function readLockPid(displayNumber) {
+  let raw;
+  try {
+    raw = fs23.readFileSync(displayLockPath(displayNumber), "utf8");
+  } catch {
+    return null;
+  }
+  const pid = Number.parseInt(raw.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`Invalid ${label} ${value}: expected a positive integer`);
+  }
+}
+function buildXvfbArgs(opts) {
+  parseDisplayNumber(opts.display);
+  const width = opts.width ?? DEFAULT_WIDTH;
+  const height = opts.height ?? DEFAULT_HEIGHT;
+  const depth = opts.depth ?? DEFAULT_DEPTH;
+  assertPositiveInteger(width, "width");
+  assertPositiveInteger(height, "height");
+  assertPositiveInteger(depth, "depth");
+  return [
+    opts.display,
+    "-screen",
+    "0",
+    `${width}x${height}x${depth}`,
+    "-nolisten",
+    "tcp"
+  ];
+}
+function allocateDisplay(opts = {}) {
+  const start = opts.start ?? DEFAULT_START_DISPLAY;
+  const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  for (let n = start; n < start + maxAttempts; n += 1) {
+    if (!fs23.existsSync(displayLockPath(n)) && !fs23.existsSync(displaySocketPath(n))) {
+      return `:${n}`;
+    }
+  }
+  throw new Error(
+    `No free X display found between :${start} and :${start + maxAttempts - 1}`
+  );
+}
+function isDisplayAlive(display) {
+  return fs23.existsSync(displaySocketPath(parseDisplayNumber(display)));
+}
+async function attemptStartXvfb(display, opts) {
+  const displayNumber = parseDisplayNumber(display);
+  const args = buildXvfbArgs({
+    display,
+    width: opts.width,
+    height: opts.height,
+    depth: opts.depth
+  });
+  const daemon = await startDaemon("Xvfb", args, {
+    logDir: opts.logDir,
+    name: "xvfb",
+    env: opts.env
+  });
+  const timeoutMs = opts.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const alive = isPidAlive(daemon.pid);
+    if (fs23.existsSync(displaySocketPath(displayNumber))) {
+      const lockPid = readLockPid(displayNumber);
+      if (lockPid !== null && lockPid !== daemon.pid && isPidAlive(lockPid)) {
+        await stopPid(daemon.pid);
+        return { outcome: "lost-race", logPath: daemon.logPath };
+      }
+      if (alive && (lockPid === null || lockPid === daemon.pid)) {
+        return {
+          outcome: "ready",
+          handle: { display, pid: daemon.pid, logPath: daemon.logPath }
+        };
+      }
+    }
+    if (!alive) {
+      return { outcome: "exited", logPath: daemon.logPath };
+    }
+    await sleep3(SOCKET_POLL_INTERVAL_MS);
+  }
+  await stopPid(daemon.pid);
+  return { outcome: "timeout", logPath: daemon.logPath };
+}
+function describeXvfbFailure(attempt, display, timeoutMs) {
+  switch (attempt.outcome) {
+    case "exited":
+      return `Xvfb exited during startup on ${display}; check the log at ${attempt.logPath}`;
+    case "lost-race":
+      return `Xvfb could not claim ${display}: another X server owns it; check the log at ${attempt.logPath}`;
+    case "timeout":
+      return `Xvfb did not come up on ${display} within ${timeoutMs}ms; check the log at ${attempt.logPath}`;
+  }
+}
+async function startXvfb(opts) {
+  const timeoutMs = opts.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  if (opts.display !== void 0) {
+    const attempt = await attemptStartXvfb(opts.display, opts);
+    if (attempt.outcome === "ready") {
+      return attempt.handle;
+    }
+    throw new Error(describeXvfbFailure(attempt, opts.display, timeoutMs));
+  }
+  let searchFrom = DEFAULT_START_DISPLAY;
+  let lastFailureMessage = "";
+  for (let retry = 0; retry < ALLOCATION_RETRY_LIMIT; retry += 1) {
+    const display = allocateDisplay({ start: searchFrom });
+    const attempt = await attemptStartXvfb(display, opts);
+    if (attempt.outcome === "ready") {
+      return attempt.handle;
+    }
+    lastFailureMessage = describeXvfbFailure(attempt, display, timeoutMs);
+    if (attempt.outcome === "timeout") {
+      throw new Error(lastFailureMessage);
+    }
+    searchFrom = parseDisplayNumber(display) + 1;
+  }
+  throw new Error(
+    `Xvfb failed to claim a free display after ${ALLOCATION_RETRY_LIMIT} attempts; last failure: ${lastFailureMessage}`
+  );
+}
+var VNC_BASE_PORT = 5900;
+var STARTUP_TIMEOUT_MS = 5e3;
+var STARTUP_POLL_INTERVAL_MS = 100;
+function assertValidPort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port ${port}: expected an integer in 1-65535`);
+  }
+}
+function buildVncArgs(opts) {
+  parseDisplayNumber(opts.display);
+  assertValidPort(opts.port);
+  return [
+    "-display",
+    opts.display,
+    "-rfbport",
+    String(opts.port),
+    "-localhost",
+    "-forever",
+    "-shared",
+    "-nopw",
+    "-quiet"
+  ];
+}
+function detectVncBinary(env = process.env) {
+  return findOnPath2("x11vnc", env);
+}
+function isPortListening(port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+async function startVnc(opts) {
+  const port = opts.port ?? VNC_BASE_PORT + parseDisplayNumber(opts.display);
+  const args = buildVncArgs({ display: opts.display, port });
+  const binary = detectVncBinary({ ...process.env, ...opts.env });
+  if (binary === null) {
+    throw new Error(
+      "x11vnc was not found on PATH; install x11vnc to enable VNC"
+    );
+  }
+  const daemon = await startDaemon(binary, args, {
+    logDir: opts.logDir,
+    name: "x11vnc",
+    env: opts.env
+  });
+  const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(daemon.pid)) {
+      throw new Error(
+        `x11vnc exited during startup on ${opts.display}; check the log at ${daemon.logPath}`
+      );
+    }
+    if (await isPortListening(port)) {
+      return { pid: daemon.pid, port, logPath: daemon.logPath };
+    }
+    await sleep3(STARTUP_POLL_INTERVAL_MS);
+  }
+  await stopPid(daemon.pid);
+  throw new Error(
+    `x11vnc did not start listening on 127.0.0.1:${port} within ${STARTUP_TIMEOUT_MS}ms; check the log at ${daemon.logPath}`
+  );
+}
+var XDOTOOL_TIMEOUT_MS = 5e3;
+var WINDOW_POLL_INTERVAL_MS = 100;
+var DEFAULT_WAIT_TIMEOUT_MS2 = 1e4;
+var LAUNCH_GRACE_MS = 300;
+var LAUNCH_POLL_INTERVAL_MS = 50;
+async function launchApp2(opts) {
+  parseDisplayNumber(opts.display);
+  const daemon = await startDaemon(opts.command, opts.args ?? [], {
+    logDir: opts.logDir,
+    cwd: opts.cwd,
+    env: { ...opts.env, DISPLAY: opts.display }
+  });
+  const graceDeadline = Date.now() + LAUNCH_GRACE_MS;
+  while (Date.now() < graceDeadline) {
+    if (!isPidAlive(daemon.pid)) {
+      throw new Error(
+        `${opts.command} exited immediately after launch on ${opts.display}; check the log at ${daemon.logPath}`
+      );
+    }
+    await sleep3(LAUNCH_POLL_INTERVAL_MS);
+  }
+  return { pid: daemon.pid, logPath: daemon.logPath };
+}
+async function runXdotoolQuery(display, args, env) {
+  try {
+    return await runCommand("xdotool", args, {
+      env: { ...env, DISPLAY: display },
+      timeoutMs: XDOTOOL_TIMEOUT_MS
+    });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(
+        "xdotool was not found on PATH; install xdotool to manage windows"
+      );
+    }
+    throw error;
+  }
+}
+async function listWindows(display, env) {
+  parseDisplayNumber(display);
+  const search = await runXdotoolQuery(
+    display,
+    ["search", "--onlyvisible", "--name", "."],
+    env
+  );
+  if (!search.ok) {
+    if (search.code === 1 && search.stderr.trim() === "") {
+      return [];
+    }
+    const detail = search.stderr.trim() || `exit code ${search.code}`;
+    throw new Error(`xdotool search failed on ${display}: ${detail}`);
+  }
+  const ids = search.stdout.split("\n").map((line) => line.trim()).filter((line) => /^\d+$/.test(line));
+  const windows = [];
+  for (const id of ids) {
+    const nameResult = await runXdotoolQuery(
+      display,
+      ["getwindowname", id],
+      env
+    );
+    windows.push({
+      id,
+      name: nameResult.ok ? nameResult.stdout.replace(/\n$/, "") : ""
+    });
+  }
+  return windows;
+}
+async function waitForWindow(display, namePattern, timeoutMs = DEFAULT_WAIT_TIMEOUT_MS2) {
+  const matches = typeof namePattern === "string" ? (name) => name.includes(namePattern) : (name) => namePattern.test(name);
+  const description = typeof namePattern === "string" ? JSON.stringify(namePattern) : String(namePattern);
+  const deadline = Date.now() + timeoutMs;
+  let lastSeen = [];
+  for (; ; ) {
+    lastSeen = await listWindows(display);
+    const match = lastSeen.find((win) => matches(win.name));
+    if (match !== void 0) {
+      return match;
+    }
+    if (Date.now() >= deadline) {
+      break;
+    }
+    await sleep3(WINDOW_POLL_INTERVAL_MS);
+  }
+  const seen = lastSeen.map((win) => JSON.stringify(win.name)).join(", ");
+  throw new Error(
+    `No window matching ${description} appeared on ${display} within ${timeoutMs}ms` + (seen === "" ? "" : `; visible windows: ${seen}`)
+  );
+}
+var SCREENSHOT_TIMEOUT_MS2 = 2e4;
+var PNG_MAGIC2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function detectScreenshotTool(env = process.env) {
+  if (findOnPath2("import", env) !== null) {
+    return "import";
+  }
+  if (findOnPath2("xwd", env) !== null && findOnPath2("convert", env) !== null) {
+    return "xwd";
+  }
+  if (findOnPath2("scrot", env) !== null) {
+    return "scrot";
+  }
+  return null;
+}
+function buildScreenshotCommand(tool, display, outPath, xwdDumpPath) {
+  parseDisplayNumber(display);
+  switch (tool) {
+    case "import":
+      return [
+        {
+          cmd: "import",
+          args: ["-display", display, "-window", "root", outPath]
+        }
+      ];
+    case "xwd": {
+      const dumpPath = xwdDumpPath ?? `${outPath}.xwd`;
+      return [
+        {
+          cmd: "xwd",
+          args: ["-root", "-silent", "-display", display, "-out", dumpPath]
+        },
+        {
+          cmd: "convert",
+          args: [`xwd:${dumpPath}`, `png:${outPath}`]
+        }
+      ];
+    }
+    case "scrot":
+      return [
+        {
+          cmd: "scrot",
+          args: ["--overwrite", outPath],
+          requiresDisplayEnv: true
+        }
+      ];
+  }
+}
+async function assertPngFile(outPath, tool) {
+  let stat;
+  try {
+    stat = await fs33.promises.stat(outPath);
+  } catch {
+    throw new Error(
+      `Screenshot command (${tool}) succeeded but produced no file at ${outPath}`
+    );
+  }
+  if (stat.size === 0) {
+    throw new Error(
+      `Screenshot command (${tool}) produced an empty file at ${outPath}`
+    );
+  }
+  const header = Buffer.alloc(PNG_MAGIC2.length);
+  const handle = await fs33.promises.open(outPath, "r");
+  try {
+    await handle.read(header, 0, PNG_MAGIC2.length, 0);
+  } finally {
+    await handle.close();
+  }
+  if (!header.equals(PNG_MAGIC2)) {
+    throw new Error(
+      `Screenshot command (${tool}) produced a file without a PNG signature at ${outPath}`
+    );
+  }
+}
+async function screenshot2(opts) {
+  parseDisplayNumber(opts.display);
+  const env = opts.env ?? process.env;
+  const tool = opts.tool ?? detectScreenshotTool(env);
+  if (tool === null) {
+    throw new Error(
+      "No screenshot tool found on PATH. Install one of: imagemagick (provides `import` and `convert`), xorg-xwd (`xwd`, combined with imagemagick `convert`), or scrot."
+    );
+  }
+  await fs33.promises.mkdir(path23.dirname(opts.outPath), { recursive: true });
+  const xwdDumpPath = tool === "xwd" ? `${opts.outPath}.${process.pid}-${crypto.randomBytes(4).toString("hex")}.xwd` : void 0;
+  const steps = buildScreenshotCommand(
+    tool,
+    opts.display,
+    opts.outPath,
+    xwdDumpPath
+  );
+  try {
+    for (const step of steps) {
+      const result = await runCommand(step.cmd, step.args, {
+        env: { ...opts.env, DISPLAY: opts.display },
+        timeoutMs: SCREENSHOT_TIMEOUT_MS2
+      });
+      if (!result.ok) {
+        const detail = result.stderr.trim() || `exit code ${result.code}`;
+        throw new Error(
+          `Screenshot command failed (${step.cmd} ${step.args.join(" ")}): ${detail}`
+        );
+      }
+    }
+  } finally {
+    if (xwdDumpPath !== void 0) {
+      await fs33.promises.rm(xwdDumpPath, { force: true });
+    }
+  }
+  await assertPngFile(opts.outPath, tool);
+  return { path: opts.outPath, tool };
+}
+var TYPE_DELAY_MS = 50;
+var INPUT_TIMEOUT_MS = 1e4;
+var TYPE_TIMEOUT_MS = 6e4;
+function assertCoordinate2(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(
+      `Invalid ${label} coordinate ${value}: expected a non-negative integer`
+    );
+  }
+}
+function buildClickArgs(opts) {
+  assertCoordinate2(opts.x, "x");
+  assertCoordinate2(opts.y, "y");
+  const button = opts.button ?? 1;
+  if (!Number.isInteger(button) || button < 1 || button > 9) {
+    throw new Error(`Invalid button ${button}: expected an integer in 1-9`);
+  }
+  return [
+    "mousemove",
+    "--sync",
+    String(opts.x),
+    String(opts.y),
+    "click",
+    String(button)
+  ];
+}
+function buildTypeArgs(text) {
+  if (text === "") {
+    throw new Error("Invalid text: expected a non-empty string");
+  }
+  return ["type", "--delay", String(TYPE_DELAY_MS), "--", text];
+}
+function buildKeyArgs(key) {
+  if (key === "") {
+    throw new Error("Invalid key: expected a non-empty string");
+  }
+  return ["key", "--", key];
+}
+async function runXdotool(display, args, timeoutMs) {
+  parseDisplayNumber(display);
+  await runCommand("xdotool", args, {
+    env: { DISPLAY: display },
+    timeoutMs,
+    check: true
+  });
+}
+async function click(opts) {
+  await runXdotool(
+    opts.display,
+    buildClickArgs({ x: opts.x, y: opts.y, button: opts.button }),
+    INPUT_TIMEOUT_MS
+  );
+}
+async function typeText2(opts) {
+  await runXdotool(opts.display, buildTypeArgs(opts.text), TYPE_TIMEOUT_MS);
+}
+async function pressKey2(opts) {
+  await runXdotool(opts.display, buildKeyArgs(opts.key), INPUT_TIMEOUT_MS);
+}
+function desktopSessionLogDir(id, registryEnv = process.env) {
+  return path33.join(sessionsDir(registryEnv), id);
+}
+async function createDesktopSession(opts) {
+  const registryEnv = opts.registryEnv ?? process.env;
+  if (opts.vnc === true && detectVncBinary({ ...process.env, ...opts.env }) === null) {
+    throw new Error(
+      "VNC was requested but x11vnc was not found on PATH; install x11vnc to enable it"
+    );
+  }
+  const record = await createSession(
+    { type: "desktop", projectDir: opts.projectDir },
+    registryEnv
+  );
+  const logDir = desktopSessionLogDir(record.id, registryEnv);
+  let xvfb;
+  let vnc;
+  try {
+    xvfb = await startXvfb({
+      width: opts.width,
+      height: opts.height,
+      logDir,
+      env: opts.env
+    });
+    if (opts.vnc === true) {
+      vnc = await startVnc({ display: xvfb.display, logDir, env: opts.env });
+    }
+    const desktop = {
+      display: xvfb.display,
+      xvfbPid: xvfb.pid
+    };
+    if (vnc !== void 0) {
+      desktop.vncPid = vnc.pid;
+      desktop.vncPort = vnc.port;
+    }
+    await updateSession(record.id, { status: "running", desktop }, registryEnv);
+    const handle = {
+      id: record.id,
+      display: xvfb.display,
+      xvfbPid: xvfb.pid,
+      logDir
+    };
+    if (vnc !== void 0) {
+      handle.vncPid = vnc.pid;
+      handle.vncPort = vnc.port;
+    }
+    return handle;
+  } catch (error) {
+    if (vnc !== void 0) {
+      await stopPid(vnc.pid).catch(() => {
+      });
+    }
+    if (xvfb !== void 0) {
+      await stopPid(xvfb.pid).catch(() => {
+      });
+    }
+    await updateSession(record.id, { status: "error" }, registryEnv).catch(
+      () => {
+      }
+    );
+    throw error;
+  }
+}
+async function destroyDesktopSession(id, registryEnv = process.env) {
+  const record = await getSession(id, registryEnv);
+  if (record === void 0) {
+    throw new Error(`Desktop session not found: ${id}`);
+  }
+  const desktop = record.desktop;
+  const failures = [];
+  const stops = [];
+  if (desktop?.vncPid !== void 0) {
+    stops.push(["x11vnc", desktop.vncPid]);
+  }
+  if (desktop?.xvfbPid !== void 0) {
+    stops.push(["Xvfb", desktop.xvfbPid]);
+  }
+  for (const [label, pid] of stops) {
+    try {
+      const stopped = await stopPid(pid);
+      if (!stopped) {
+        failures.push(
+          new Error(`${label} (pid ${pid}) survived SIGTERM and SIGKILL`)
+        );
+      }
+    } catch (error) {
+      failures.push(
+        error instanceof Error ? error : new Error(`Failed to stop ${label} (pid ${pid}): ${String(error)}`)
+      );
+    }
+  }
+  if (failures.length > 0) {
+    await updateSession(id, { status: "error" }, registryEnv).catch(() => {
+    });
+    throw new AggregateError(
+      failures,
+      `Failed to stop ${failures.length} process(es) of desktop session ${id}`
+    );
+  }
+  await destroySessionRecord(id, registryEnv);
+}
+async function getDesktopSessionStatus(id, registryEnv = process.env) {
+  const record = await getSession(id, registryEnv);
+  if (record === void 0) {
+    throw new Error(`Desktop session not found: ${id}`);
+  }
+  const desktop = record.desktop;
+  return {
+    record,
+    xvfbAlive: desktop?.xvfbPid !== void 0 && isPidAlive(desktop.xvfbPid),
+    vncAlive: desktop?.vncPid !== void 0 && isPidAlive(desktop.vncPid),
+    displayAlive: desktop !== void 0 && isDisplayAlive(desktop.display)
+  };
+}
+
+// ../mcp-server/dist/index.js
+import path43 from "path";
+import { z as z4 } from "zod";
+import path53 from "path";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+var MAX_INLINE_IMAGE_BYTES = 2 * 1024 * 1024;
+function resolveContext(opts = {}) {
+  const env = opts.env ?? process.env;
+  const projectDir = path9.resolve(
+    opts.projectDir ?? env.PICKLAB_PROJECT_DIR ?? process.cwd()
+  );
+  return { projectDir, env };
+}
+function reportResult(report) {
+  const errors = report.errors ?? [];
+  const body = { ok: errors.length === 0 };
+  for (const [key, value] of Object.entries(report.data ?? {})) {
+    if (key !== "ok" && key !== "errors") {
+      body[key] = value;
+    }
+  }
+  body.errors = errors;
+  const content = [
+    { type: "text", text: JSON.stringify(body, null, 2) },
+    ...report.extraContent ?? []
+  ];
+  return errors.length === 0 ? { content } : { content, isError: true };
+}
+async function runTool(fn) {
+  try {
+    return reportResult(await fn());
+  } catch (error) {
+    return reportResult({
+      errors: [error instanceof Error ? error.message : String(error)]
+    });
+  }
+}
+async function imageContent(filePath) {
+  let stat;
+  try {
+    stat = await fs8.promises.stat(filePath);
+  } catch {
+    return {
+      content: [],
+      meta: {
+        inlineImage: false,
+        inlineImageReason: `image file not readable: ${filePath}`
+      }
+    };
+  }
+  if (stat.size > MAX_INLINE_IMAGE_BYTES) {
+    return {
+      content: [],
+      meta: {
+        inlineImage: false,
+        inlineImageReason: `image is ${stat.size} bytes, over the ${MAX_INLINE_IMAGE_BYTES} byte inline limit; read it from ${filePath}`
+      }
+    };
+  }
+  const data = await fs8.promises.readFile(filePath);
+  return {
+    content: [
+      { type: "image", data: data.toString("base64"), mimeType: "image/png" }
+    ],
+    meta: { inlineImage: true }
+  };
+}
+async function resolveSessionRecord(ctx, type, id) {
+  return resolveRunnableSession(type, id, {
+    env: ctx.env,
+    projectDir: ctx.projectDir,
+    consumerLabel: "tool",
+    createHint: `create one with the session_create tool (type "${type}")`,
+    selectHint: 'pick one with the "session" argument'
+  });
+}
+async function resolveScreenshotTarget2(ctx, args, defaultSlug, sessionId) {
+  return resolveScreenshotTarget({
+    projectDir: ctx.projectDir,
+    out: args.out,
+    outBaseDir: ctx.projectDir,
+    runSlug: args.runSlug,
+    defaultSlug,
+    sessionId,
+    conflictError: 'Use either "out" or "runSlug", not both'
+  });
+}
+function userMessage(text) {
+  return { messages: [{ role: "user", content: { type: "text", text } }] };
+}
+var HUMAN_BLOCKER_GUIDELINE = "If you become blocked on anything that requires a human \u2014 credentials, license keys, 2FA, a judgment call, or a click you cannot perform \u2014 use the `request_user_input` tool (or ask in your conversation) and WAIT for the answer. Never guess credentials and never abandon the session; report what you need.";
+function registerPrompts(server) {
+  server.registerPrompt(
+    "test-flutter-desktop-visually",
+    {
+      title: "Test a desktop app visually",
+      description: "Build a Flutter (or any Linux) desktop app, run it in an isolated PickLab desktop session, and verify it visually with screenshots.",
+      argsSchema: {
+        appCommand: z.string().optional().describe(
+          "Command that starts the app (default: the project's release binary)"
+        ),
+        windowTitle: z.string().optional().describe("Window title (or fragment) to wait for after launch")
+      }
+    },
+    ({ appCommand, windowTitle }) => userMessage(
+      [
+        "Visually test the desktop app in an isolated PickLab session:",
+        "",
+        "1. Build the app first (for Flutter: `flutter build linux`). Fix any build errors before continuing.",
+        '2. Create an isolated display with the `session_create` tool (type "desktop"). Note the returned session id.',
+        `3. Launch the app with \`desktop_launch\` using command ${appCommand === void 0 ? "set to the built app binary (for Flutter: build/linux/x64/release/bundle/<app>)" : `\`${appCommand}\``} and arguments as an array.${windowTitle === void 0 ? " Use waitWindow with the app's window title so the launch blocks until the UI is up." : ` Use waitWindow \`${windowTitle}\` so the launch blocks until the UI is up.`}`,
+        "4. Capture the screen with `desktop_screenshot` and inspect the returned image. Check that the UI matches what the code should render: layout, labels, colors, missing assets.",
+        "5. Drive the app like a user: `desktop_click` at widget coordinates, `desktop_type` to fill fields, and `desktop_key` for keys/chords (Return, Tab, ctrl+s). Take a screenshot after each meaningful interaction to confirm the result.",
+        "6. If something looks wrong, fix the code, rebuild, relaunch inside the same session, and re-verify with new screenshots.",
+        "7. When finished, destroy the session with `session_destroy` and summarize what you verified. Use `artifact_report` to reference the captured screenshots.",
+        "",
+        "Never run the app on the user's real display; always work inside the PickLab session.",
+        HUMAN_BLOCKER_GUIDELINE
+      ].join("\n")
+    )
+  );
+  server.registerPrompt(
+    "debug-android-apk",
+    {
+      title: "Debug an Android APK",
+      description: "Install an APK in the PickLab Android emulator, drive its UI, and debug it with logcat and UI-tree dumps.",
+      argsSchema: {
+        apkPath: z.string().describe("Path to the APK to debug"),
+        packageName: z.string().optional().describe('Application package name, e.g. "com.example.app"')
+      }
+    },
+    ({ apkPath, packageName: packageName2 }) => userMessage(
+      [
+        "Debug the Android app inside the PickLab emulator lab:",
+        "",
+        '1. Start an emulator session with the `android_start` tool (or `session_create` with type "android"). Wait for it to report a device serial.',
+        `2. Install the APK with \`android_install_apk\` using apkPath \`${apkPath}\`.`,
+        "3. Clear old logs with `android_logcat` (clear=true) so later output only shows this debugging session.",
+        `4. Launch the app with \`android_launch_app\`${packageName2 === void 0 ? " using its package name" : ` using packageName \`${packageName2}\``}.`,
+        "5. Capture the screen with `android_screenshot` and dump the widget hierarchy with `android_get_ui_tree`. Use the XML bounds to compute tap coordinates.",
+        "6. Reproduce the issue: `android_tap` on widgets, `android_type` for text fields, `android_back`/`android_home` for navigation. Screenshot after each step.",
+        "7. Read `android_logcat` output (it is secret-redacted) and look for exceptions, ANRs, or suspicious log lines from the app process.",
+        "8. For anything else (e.g. `pm list packages`, `dumpsys`), use `android_run_adb` with an argument array.",
+        "9. Fix the code, rebuild the APK, reinstall with `android_install_apk`, and verify the fix the same way.",
+        "10. Destroy the session with `session_destroy` when done and summarize the root cause and fix.",
+        "",
+        HUMAN_BLOCKER_GUIDELINE
+      ].join("\n")
+    )
+  );
+  server.registerPrompt(
+    "run-visual-regression-check",
+    {
+      title: "Run a visual regression check",
+      description: "Capture fresh screenshots of the app in a PickLab session and compare them against a baseline directory.",
+      argsSchema: {
+        baselineDir: z.string().describe("Directory holding the baseline screenshots"),
+        appCommand: z.string().optional().describe("Command that starts the app")
+      }
+    },
+    ({ baselineDir, appCommand }) => userMessage(
+      [
+        "Run a visual regression check against the baseline screenshots:",
+        "",
+        `1. List the baseline images in \`${baselineDir}\` to learn which screens are covered and their file names.`,
+        '2. Create an isolated display with `session_create` (type "desktop") sized to match the baselines.',
+        `3. Launch the app with \`desktop_launch\`${appCommand === void 0 ? "" : ` using command \`${appCommand}\``} and wait for its window.`,
+        "4. For each baseline screen: navigate to the same state (`desktop_click`, `desktop_type`, `desktop_key`), then capture it with `desktop_screenshot` using a runSlug matching the baseline name.",
+        "5. Compare each captured screenshot with its baseline. Prefer a pixel diff (e.g. ImageMagick `compare -metric AE`) when available; otherwise inspect both images and describe differences in layout, text, color, and spacing.",
+        "6. Collect the verdict per screen: unchanged, intentionally changed, or regression. For regressions, include the run id and the differing region.",
+        "7. Destroy the session with `session_destroy`, then report results with `artifact_report` so every captured screenshot is referenced.",
+        `8. Only update files in \`${baselineDir}\` if the user confirms the new rendering is intended.`,
+        "",
+        HUMAN_BLOCKER_GUIDELINE
+      ].join("\n")
+    )
+  );
+}
+var RUN_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+function isSafeRunId(runId) {
+  return RUN_ID_PATTERN.test(runId) && runId !== "." && runId !== ".." && !runId.includes("..");
+}
+async function findRun(projectDir, runId) {
+  const manifests = (await listRuns(projectDir)).filter(
+    (candidate) => isSafeRunId(candidate.runId)
+  );
+  let manifest;
+  if (runId === void 0) {
+    manifest = manifests[0];
+    if (manifest === void 0) {
+      throw new Error(`No runs found under ${runsDir(projectDir)}`);
+    }
+  } else {
+    manifest = manifests.find((candidate) => candidate.runId === runId);
+    if (manifest === void 0) {
+      throw new Error(
+        `Run not found: ${runId} (see the artifact_list tool)`
+      );
+    }
+  }
+  return { manifest, dir: path24.join(runsDir(projectDir), manifest.runId) };
+}
+function renderRunReport(manifest, dir) {
+  const lines = [
+    `# PickLab run ${manifest.runId}`,
+    "",
+    `- Slug: ${manifest.slug}`,
+    `- Status: ${manifest.status}`,
+    `- Created: ${manifest.createdAt}`
+  ];
+  if (manifest.sessionId !== void 0) {
+    lines.push(`- Session: ${manifest.sessionId}`);
+  }
+  lines.push(
+    `- Directory: ${dir}`,
+    "",
+    `## Artifacts (${manifest.artifacts.length})`,
+    ""
+  );
+  if (manifest.artifacts.length === 0) {
+    lines.push("(none)");
+  }
+  for (const artifact of manifest.artifacts) {
+    lines.push(
+      `- [${artifact.type}] ${artifact.name} \u2014 ${artifact.path} (${artifact.createdAt})`
+    );
+  }
+  return lines.join("\n");
+}
+function registerArtifactTools(server, ctx) {
+  server.registerTool(
+    "artifact_list",
+    {
+      title: "List runs",
+      description: "List recorded runs (screenshots, logs, reports) under .picklab/runs in the project directory.",
+      inputSchema: {}
+    },
+    () => runTool(async () => {
+      const manifests = await listRuns(ctx.projectDir);
+      const runs = manifests.map((manifest) => ({
+        runId: manifest.runId,
+        slug: manifest.slug,
+        createdAt: manifest.createdAt,
+        status: manifest.status,
+        artifacts: manifest.artifacts.length
+      }));
+      return { data: { projectDir: ctx.projectDir, runs } };
+    })
+  );
+  server.registerTool(
+    "artifact_report",
+    {
+      title: "Run report",
+      description: "Render a report for one run (default: the most recent run), including its artifact inventory.",
+      inputSchema: {
+        runId: z2.string().min(1).optional().describe("Run id")
+      }
+    },
+    (args) => runTool(async () => {
+      const { manifest, dir } = await findRun(ctx.projectDir, args.runId);
+      return {
+        data: {
+          runId: manifest.runId,
+          dir,
+          manifest,
+          report: renderRunReport(manifest, dir)
+        }
+      };
+    })
+  );
+}
+function progressReporter(extra) {
+  const progressToken = extra._meta?.progressToken;
+  if (progressToken === void 0) {
+    return void 0;
+  }
+  let progress = 0;
+  return (message) => {
+    progress += 1;
+    void extra.sendNotification({
+      method: "notifications/progress",
+      params: { progressToken, progress, message }
+    }).catch(() => {
+    });
+  };
+}
+async function createDesktopLeg(ctx, args) {
+  const handle = await createDesktopSession({
+    projectDir: ctx.projectDir,
+    registryEnv: ctx.env,
+    env: ctx.env,
+    width: args.width,
+    height: args.height,
+    vnc: args.vnc
+  });
+  const summary = {
+    id: handle.id,
+    type: "desktop",
+    display: handle.display,
+    logDir: handle.logDir
+  };
+  if (handle.vncPort !== void 0) {
+    summary.vncPort = handle.vncPort;
+  }
+  return summary;
+}
+async function createAndroidLeg(ctx, args, lifecycle) {
+  const config = await loadConfig(ctx.projectDir, ctx.env);
+  const avdName = args.avdName ?? config.android?.avdName;
+  const handle = await createAndroidSession({
+    projectDir: ctx.projectDir,
+    registryEnv: ctx.env,
+    env: ctx.env,
+    onProgress: lifecycle.onProgress,
+    signal: lifecycle.signal,
+    ...avdName === void 0 ? {} : { avdName }
+  });
+  return {
+    id: handle.id,
+    type: "android",
+    avdName: handle.avdName,
+    serial: handle.serial,
+    consolePort: handle.consolePort,
+    logDir: handle.logDir
+  };
+}
+async function createSessions(ctx, args, lifecycle = {}) {
+  const type = args.type ?? "desktop";
+  const sessions = [];
+  if (type === "desktop" || type === "desktop+android") {
+    sessions.push(await createDesktopLeg(ctx, args));
+  }
+  if (type === "android" || type === "desktop+android") {
+    try {
+      if (lifecycle.signal?.aborted === true) {
+        throw new Error("Session creation aborted by the client");
+      }
+      sessions.push(await createAndroidLeg(ctx, args, lifecycle));
+    } catch (error) {
+      const desktop = sessions.find((session) => session.type === "desktop");
+      if (desktop !== void 0) {
+        await destroyDesktopSession(desktop.id, ctx.env).catch(() => {
+        });
+      }
+      throw error;
+    }
+  }
+  return sessions;
+}
+async function sessionStatusEntry(ctx, record) {
+  const entry = {
+    id: record.id,
+    type: record.type,
+    status: record.status,
+    createdAt: record.createdAt,
+    projectDir: record.projectDir
+  };
+  if (record.type === "desktop") {
+    const status = await getDesktopSessionStatus(record.id, ctx.env);
+    entry.desktop = {
+      ...record.desktop,
+      xvfbAlive: status.xvfbAlive,
+      vncAlive: status.vncAlive,
+      displayAlive: status.displayAlive
+    };
+  } else if (record.type === "android") {
+    const status = await getAndroidSessionStatus(record.id, ctx.env, {
+      env: ctx.env
+    });
+    entry.android = {
+      ...record.android,
+      emulatorAlive: status.emulatorAlive,
+      deviceState: status.deviceState
+    };
+  }
+  return entry;
+}
+async function destroyRecord(ctx, record) {
+  if (record.type === "desktop") {
+    await destroyDesktopSession(record.id, ctx.env);
+  } else if (record.type === "android") {
+    await destroyAndroidSession(record.id, ctx.env, { env: ctx.env });
+  } else {
+    throw new Error(
+      `Cannot destroy session ${record.id} of type "${record.type}"`
+    );
+  }
+}
+function registerSessionTools(server, ctx) {
+  server.registerTool(
+    "session_create",
+    {
+      title: "Create lab session",
+      description: 'Create an isolated lab session: a virtual desktop display (Xvfb) and/or an Android emulator. Defaults to type "desktop".',
+      inputSchema: {
+        type: z3.enum(["desktop", "android", "desktop+android"]).optional().describe('Session type (default "desktop")'),
+        width: z3.number().int().positive().optional().describe("Desktop display width in pixels"),
+        height: z3.number().int().positive().optional().describe("Desktop display height in pixels"),
+        vnc: z3.boolean().optional().describe("Expose the desktop display over VNC"),
+        avdName: z3.string().min(1).optional().describe("Android AVD name")
+      }
+    },
+    (args, extra) => runTool(async () => ({
+      data: {
+        sessions: await createSessions(ctx, args, {
+          onProgress: progressReporter(extra),
+          signal: extra.signal
+        })
+      }
+    }))
+  );
+  server.registerTool(
+    "session_status",
+    {
+      title: "Session status",
+      description: "Show liveness for one session (by id) or for all known sessions.",
+      inputSchema: {
+        sessionId: z3.string().min(1).optional().describe("Session id")
+      }
+    },
+    (args) => runTool(async () => {
+      let records;
+      if (args.sessionId !== void 0) {
+        const record = await getSession(args.sessionId, ctx.env);
+        if (record === void 0) {
+          throw new Error(`Session not found: ${args.sessionId}`);
+        }
+        records = [record];
+      } else {
+        records = await listSessions(ctx.env);
+      }
+      const sessions = [];
+      for (const record of records) {
+        sessions.push(await sessionStatusEntry(ctx, record));
+      }
+      return { data: { sessions } };
+    })
+  );
+  server.registerTool(
+    "session_destroy",
+    {
+      title: "Destroy lab session",
+      description: "Destroy a session and stop its processes. Pass a session id, or all=true to destroy every session.",
+      inputSchema: {
+        sessionId: z3.string().min(1).optional().describe("Session id"),
+        all: z3.boolean().optional().describe("Destroy all sessions")
+      }
+    },
+    (args) => runTool(async () => {
+      if (args.sessionId !== void 0 && args.all === true) {
+        throw new Error('Pass either "sessionId" or "all", not both');
+      }
+      if (args.sessionId === void 0 && args.all !== true) {
+        throw new Error('Pass a "sessionId" or set "all" to true');
+      }
+      const records = [];
+      if (args.sessionId !== void 0) {
+        const record = await getSession(args.sessionId, ctx.env);
+        if (record === void 0) {
+          throw new Error(`Session not found: ${args.sessionId}`);
+        }
+        records.push(record);
+      } else {
+        records.push(...await listSessions(ctx.env));
+      }
+      const destroyed = [];
+      const errors = [];
+      for (const record of records) {
+        try {
+          await destroyRecord(ctx, record);
+          destroyed.push(record.id);
+        } catch (error) {
+          errors.push(
+            `${record.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return { data: { destroyed }, errors };
+    })
+  );
+}
+var SAFE_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+var MAX_BLOB_BYTES = 8 * 1024 * 1024;
+function decodeVariable(variables, label) {
+  const raw = variables[label];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (value === void 0) {
+    throw new Error(`Missing "${label}" in resource URI`);
+  }
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    throw new Error(`Invalid "${label}" in resource URI`);
+  }
+  if (!SAFE_NAME_PATTERN.test(decoded) || decoded === "." || decoded.includes("..")) {
+    throw new Error(`Invalid "${label}" in resource URI: ${decoded}`);
+  }
+  return decoded;
+}
+function runFilePath(ctx, runId, subdir, name) {
+  const base = path34.join(runsDir(ctx.projectDir), runId, subdir);
+  const resolved = path34.resolve(base, name);
+  if (resolved !== path34.join(base, name)) {
+    throw new Error(`Invalid resource path: ${name}`);
+  }
+  return resolved;
+}
+async function isRunDirSafe(ctx, runId) {
+  const root = runsDir(ctx.projectDir);
+  const runDir = path34.join(root, runId);
+  try {
+    const realProject = await fs24.promises.realpath(ctx.projectDir);
+    const realRoot = await fs24.promises.realpath(root);
+    if (realRoot !== path34.join(realProject, ".picklab", "runs")) {
+      return false;
+    }
+    const realRunDir = await fs24.promises.realpath(runDir);
+    return realRunDir === path34.join(realRoot, runId);
+  } catch {
+    return false;
+  }
+}
+async function assertWithinSubdir(ctx, runId, subdir, filePath, notFound) {
+  if (!await isRunDirSafe(ctx, runId)) {
+    throw notFound();
+  }
+  try {
+    const lst = await fs24.promises.lstat(filePath);
+    if (lst.isSymbolicLink()) {
+      throw notFound();
+    }
+  } catch (err) {
+    if (err.code === void 0) {
+      throw err;
+    }
+    return;
+  }
+  const runDir = path34.join(runsDir(ctx.projectDir), runId);
+  const base = path34.join(runDir, subdir);
+  let realRunDir;
+  let realBase;
+  let realFile;
+  try {
+    realRunDir = await fs24.promises.realpath(runDir);
+    realBase = await fs24.promises.realpath(base);
+    realFile = await fs24.promises.realpath(filePath);
+  } catch {
+    return;
+  }
+  const expectedBase = path34.join(realRunDir, subdir);
+  if (realBase !== expectedBase) {
+    throw notFound();
+  }
+  if (realFile !== realBase && !realFile.startsWith(realBase + path34.sep)) {
+    throw notFound();
+  }
+}
+async function assertManifestWithinRun(ctx, runId, manifestPath, notFound) {
+  if (!await isRunDirSafe(ctx, runId)) {
+    throw notFound();
+  }
+  const runDir = path34.join(runsDir(ctx.projectDir), runId);
+  let realRunDir;
+  let realFile;
+  try {
+    realRunDir = await fs24.promises.realpath(runDir);
+    realFile = await fs24.promises.realpath(manifestPath);
+  } catch {
+    return;
+  }
+  if (realFile !== path34.join(realRunDir, "manifest.json")) {
+    throw notFound();
+  }
+}
+async function isManifestSafe(ctx, runId) {
+  if (!await isRunDirSafe(ctx, runId)) return false;
+  const runDir = path34.join(runsDir(ctx.projectDir), runId);
+  const manifestPath = path34.join(runDir, "manifest.json");
+  try {
+    const realRunDir = await fs24.promises.realpath(runDir);
+    const realFile = await fs24.promises.realpath(manifestPath);
+    return realFile === path34.join(realRunDir, "manifest.json");
+  } catch {
+    return false;
+  }
+}
+async function listSafeRuns(ctx) {
+  const safe = [];
+  for (const manifest of await listRuns(ctx.projectDir)) {
+    if (!isSafeRunId(manifest.runId)) continue;
+    if (!await isManifestSafe(ctx, manifest.runId)) continue;
+    safe.push(manifest);
+  }
+  return safe;
+}
+async function listRunFiles(ctx, subdir) {
+  const entries = [];
+  for (const manifest of await listSafeRuns(ctx)) {
+    const runDir = path34.join(runsDir(ctx.projectDir), manifest.runId);
+    const dir = path34.join(runDir, subdir);
+    try {
+      const realRunDir = await fs24.promises.realpath(runDir);
+      const realDir = await fs24.promises.realpath(dir);
+      if (realDir !== path34.join(realRunDir, subdir)) continue;
+    } catch {
+      continue;
+    }
+    let names;
+    try {
+      names = await fs24.promises.readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (!SAFE_NAME_PATTERN.test(name) || name.includes("..")) continue;
+      let entry;
+      try {
+        entry = await fs24.promises.lstat(path34.join(dir, name));
+      } catch {
+        continue;
+      }
+      if (entry.isSymbolicLink()) continue;
+      entries.push({ runId: manifest.runId, name });
+    }
+  }
+  return entries;
+}
+function registerResources(server, ctx) {
+  server.registerResource(
+    "runs",
+    "picklab://runs",
+    {
+      title: "PickLab runs",
+      description: "Index of recorded runs under .picklab/runs",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const runs = (await listSafeRuns(ctx)).map((manifest) => ({
+        runId: manifest.runId,
+        slug: manifest.slug,
+        createdAt: manifest.createdAt,
+        status: manifest.status,
+        artifacts: manifest.artifacts.length
+      }));
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(runs, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "run-manifest",
+    new ResourceTemplate("picklab://runs/{runId}/manifest", {
+      list: async () => ({
+        resources: (await listSafeRuns(ctx)).map((manifest) => ({
+          uri: `picklab://runs/${manifest.runId}/manifest`,
+          name: `Run ${manifest.runId} manifest`,
+          mimeType: "application/json"
+        }))
+      })
+    }),
+    {
+      title: "Run manifest",
+      description: "Manifest (status and artifacts) of a recorded run",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const runId = decodeVariable(variables, "runId");
+      const manifestPath = path34.join(
+        runsDir(ctx.projectDir),
+        runId,
+        "manifest.json"
+      );
+      await assertManifestWithinRun(
+        ctx,
+        runId,
+        manifestPath,
+        () => new Error(`Run not found: ${runId}`)
+      );
+      let raw;
+      try {
+        raw = await fs24.promises.readFile(manifestPath, "utf8");
+      } catch {
+        throw new Error(`Run not found: ${runId}`);
+      }
+      return {
+        contents: [
+          { uri: uri.href, mimeType: "application/json", text: raw }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "run-screenshot",
+    new ResourceTemplate("picklab://runs/{runId}/screenshots/{name}", {
+      list: async () => ({
+        resources: (await listRunFiles(ctx, "screenshots")).map((entry) => ({
+          uri: `picklab://runs/${entry.runId}/screenshots/${entry.name}`,
+          name: `Run ${entry.runId} screenshot ${entry.name}`,
+          mimeType: "image/png"
+        }))
+      })
+    }),
+    {
+      title: "Run screenshot",
+      description: "PNG screenshot captured during a run",
+      mimeType: "image/png"
+    },
+    async (uri, variables) => {
+      const runId = decodeVariable(variables, "runId");
+      const name = decodeVariable(variables, "name");
+      if (!name.endsWith(".png")) {
+        throw new Error(`Not a PNG screenshot: ${name}`);
+      }
+      const filePath = runFilePath(ctx, runId, "screenshots", name);
+      await assertWithinSubdir(
+        ctx,
+        runId,
+        "screenshots",
+        filePath,
+        () => new Error(`Screenshot not found: ${runId}/${name}`)
+      );
+      let stat;
+      try {
+        stat = await fs24.promises.stat(filePath);
+      } catch {
+        throw new Error(`Screenshot not found: ${runId}/${name}`);
+      }
+      if (stat.size > MAX_BLOB_BYTES) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Screenshot ${runId}/${name} is ${stat.size} bytes, over the ${MAX_BLOB_BYTES} byte inline limit; read the file directly at ${filePath}`
+            }
+          ]
+        };
+      }
+      let data;
+      try {
+        data = await fs24.promises.readFile(filePath);
+      } catch {
+        throw new Error(`Screenshot not found: ${runId}/${name}`);
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "image/png",
+            blob: data.toString("base64")
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "run-log",
+    new ResourceTemplate("picklab://runs/{runId}/logs/{name}", {
+      list: async () => ({
+        resources: (await listRunFiles(ctx, "logs")).map((entry) => ({
+          uri: `picklab://runs/${entry.runId}/logs/${entry.name}`,
+          name: `Run ${entry.runId} log ${entry.name}`,
+          mimeType: "text/plain"
+        }))
+      })
+    }),
+    {
+      title: "Run log",
+      description: "Log captured during a run (secrets redacted)",
+      mimeType: "text/plain"
+    },
+    async (uri, variables) => {
+      const runId = decodeVariable(variables, "runId");
+      const name = decodeVariable(variables, "name");
+      const filePath = runFilePath(ctx, runId, "logs", name);
+      await assertWithinSubdir(
+        ctx,
+        runId,
+        "logs",
+        filePath,
+        () => new Error(`Log not found: ${runId}/${name}`)
+      );
+      let raw;
+      try {
+        raw = await fs24.promises.readFile(filePath, "utf8");
+      } catch {
+        throw new Error(`Log not found: ${runId}/${name}`);
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/plain",
+            text: redactSecrets(raw)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    "session-status",
+    new ResourceTemplate("picklab://sessions/{sessionId}/status", {
+      list: async () => ({
+        resources: (await listSessions(ctx.env)).map((record) => ({
+          uri: `picklab://sessions/${record.id}/status`,
+          name: `Session ${record.id} status`,
+          mimeType: "application/json"
+        }))
+      })
+    }),
+    {
+      title: "Session status",
+      description: "Liveness and details of a lab session",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const sessionId = decodeVariable(variables, "sessionId");
+      const record = await getSession(sessionId, ctx.env);
+      if (record === void 0) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const entry = await sessionStatusEntry(ctx, record);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(entry, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+var targetArgs = {
+  session: z4.string().min(1).optional().describe("Android session id (default: the single running session)"),
+  serial: z4.string().min(1).optional().describe("Explicit adb device serial instead of a session")
+};
+async function resolveAndroidTarget(ctx, args) {
+  if (args.serial !== void 0 && args.session !== void 0) {
+    throw new Error('Pass either "session" or "serial", not both');
+  }
+  if (args.serial !== void 0) {
+    return { serial: args.serial };
+  }
+  const record = await resolveSessionRecord(ctx, "android", args.session);
+  const serial = record.android?.serial;
+  if (serial === void 0) {
+    throw new Error(`Session ${record.id} has no device serial recorded`);
+  }
+  return { serial, sessionId: record.id };
+}
+function targetData(target) {
+  const data = { serial: target.serial };
+  if (target.sessionId !== void 0) {
+    data.sessionId = target.sessionId;
+  }
+  return data;
+}
+function registerAndroidTools(server, ctx) {
+  server.registerTool(
+    "android_start",
+    {
+      title: "Start Android session",
+      description: "Start an Android emulator session (boots the dedicated PickLab AVD).",
+      inputSchema: {
+        avdName: z4.string().min(1).optional().describe("Android AVD name")
+      }
+    },
+    (args, extra) => runTool(async () => ({
+      data: {
+        sessions: await createSessions(
+          ctx,
+          { type: "android", avdName: args.avdName },
+          { onProgress: progressReporter(extra), signal: extra.signal }
+        )
+      }
+    }))
+  );
+  server.registerTool(
+    "android_install_apk",
+    {
+      title: "Install APK",
+      description: "Install an APK on the device (path relative to the project dir).",
+      inputSchema: {
+        ...targetArgs,
+        apkPath: z4.string().min(1).describe("Path to the APK")
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      const apkPath = path43.resolve(ctx.projectDir, args.apkPath);
+      await installApk({ serial: target.serial, apkPath, env: ctx.env });
+      return { data: { ...targetData(target), apkPath } };
+    })
+  );
+  server.registerTool(
+    "android_launch_app",
+    {
+      title: "Launch Android app",
+      description: "Launch an installed app by package name.",
+      inputSchema: {
+        ...targetArgs,
+        packageName: z4.string().min(1).describe('Application package name, e.g. "com.example.app"'),
+        activity: z4.string().min(1).optional().describe('Activity to start, e.g. ".MainActivity"')
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      await launchApp({
+        serial: target.serial,
+        packageName: args.packageName,
+        activity: args.activity,
+        env: ctx.env
+      });
+      return {
+        data: { ...targetData(target), packageName: args.packageName }
+      };
+    })
+  );
+  server.registerTool(
+    "android_screenshot",
+    {
+      title: "Android screenshot",
+      description: "Capture the device screen as PNG. By default the image is recorded as an artifact of a new run under .picklab/runs and returned inline when small enough.",
+      inputSchema: {
+        ...targetArgs,
+        out: z4.string().min(1).optional().describe("Explicit output path instead of a run artifact"),
+        runSlug: z4.string().min(1).optional().describe('Run slug (default "android")')
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      const destination = await resolveScreenshotTarget2(
+        ctx,
+        args,
+        "android",
+        target.sessionId
+      );
+      const data = await captureToTarget(destination, async () => {
+        await screenshot({
+          serial: target.serial,
+          outPath: destination.outPath,
+          env: ctx.env
+        });
+      });
+      Object.assign(data, targetData(target));
+      const image = await imageContent(destination.outPath);
+      Object.assign(data, image.meta);
+      return { data, extraContent: image.content };
+    })
+  );
+  server.registerTool(
+    "android_tap",
+    {
+      title: "Android tap",
+      description: "Tap at the given screen coordinates.",
+      inputSchema: {
+        ...targetArgs,
+        x: z4.number().int().nonnegative().describe("X coordinate"),
+        y: z4.number().int().nonnegative().describe("Y coordinate")
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      await tap({ serial: target.serial, x: args.x, y: args.y, env: ctx.env });
+      return { data: { ...targetData(target), x: args.x, y: args.y } };
+    })
+  );
+  server.registerTool(
+    "android_type",
+    {
+      title: "Android type",
+      description: "Type ASCII text into the focused field.",
+      inputSchema: {
+        ...targetArgs,
+        text: z4.string().min(1).describe("Text to type")
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      await typeText({ serial: target.serial, text: args.text, env: ctx.env });
+      return { data: { ...targetData(target), length: args.text.length } };
+    })
+  );
+  server.registerTool(
+    "android_back",
+    {
+      title: "Android back",
+      description: "Press the back button.",
+      inputSchema: { ...targetArgs }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      await back({ serial: target.serial, env: ctx.env });
+      return { data: targetData(target) };
+    })
+  );
+  server.registerTool(
+    "android_home",
+    {
+      title: "Android home",
+      description: "Press the home button.",
+      inputSchema: { ...targetArgs }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      await home({ serial: target.serial, env: ctx.env });
+      return { data: targetData(target) };
+    })
+  );
+  server.registerTool(
+    "android_get_ui_tree",
+    {
+      title: "Android UI tree",
+      description: "Dump the current UI hierarchy as XML (uiautomator dump). Use it to find widget bounds before tapping.",
+      inputSchema: { ...targetArgs }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      const xml = redactSecrets(
+        await getUiTree({ serial: target.serial, env: ctx.env })
+      );
+      return { data: { ...targetData(target), xml } };
+    })
+  );
+  server.registerTool(
+    "android_logcat",
+    {
+      title: "Android logcat",
+      description: "Dump recent device log lines with secrets redacted, or clear the log buffer with clear=true.",
+      inputSchema: {
+        ...targetArgs,
+        lines: z4.number().int().positive().optional().describe("Number of recent lines (default 500)"),
+        filter: z4.string().min(1).optional().describe('Logcat filter spec, e.g. "ActivityManager:I *:S"'),
+        clear: z4.boolean().optional().describe("Clear the log buffer instead of dumping it")
+      }
+    },
+    (args) => runTool(async () => {
+      const target = await resolveAndroidTarget(ctx, args);
+      if (args.clear === true) {
+        await clearLogcat({ serial: target.serial, env: ctx.env });
+        return { data: { ...targetData(target), cleared: true } };
+      }
+      const output = redactSecrets(
+        await logcat({
+          serial: target.serial,
+          lines: args.lines,
+          filter: args.filter,
+          env: ctx.env
+        })
+      );
+      return { data: { ...targetData(target), output } };
+    })
+  );
+  server.registerTool(
+    "android_run_adb",
+    {
+      title: "Run adb command",
+      description: "Run a raw adb command as an argument array. Output is redacted; use the picklab CLI for unredacted adb access.",
+      inputSchema: {
+        ...targetArgs,
+        args: z4.array(z4.string()).min(1).describe('adb arguments, e.g. ["shell", "pm", "list", "packages"]'),
+        timeoutMs: z4.number().int().positive().optional().describe("Command timeout in milliseconds")
+      }
+    },
+    (args) => runTool(async () => {
+      let target;
+      if (args.serial !== void 0 || args.session !== void 0) {
+        target = await resolveAndroidTarget(ctx, args);
+      } else {
+        try {
+          target = await resolveAndroidTarget(ctx, args);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (!message.startsWith("No running android session")) {
+            throw error;
+          }
+          target = void 0;
+        }
+      }
+      const result = await runAdb({
+        args: args.args,
+        serial: target?.serial,
+        env: ctx.env,
+        timeoutMs: args.timeoutMs
+      });
+      const data = {
+        ...target === void 0 ? {} : targetData(target),
+        code: result.code,
+        stdout: redactSecrets(result.stdout),
+        stderr: redactSecrets(result.stderr)
+      };
+      return {
+        data,
+        errors: result.ok ? [] : [`adb exited with code ${result.code}`]
+      };
+    })
+  );
+}
+var sessionArg = {
+  session: z5.string().min(1).optional().describe("Desktop session id (default: the single running session)")
+};
+async function resolveDesktop(ctx, session) {
+  const record = await resolveSessionRecord(ctx, "desktop", session);
+  return { id: record.id, display: requireDisplay(record) };
+}
+function registerDesktopTools(server, ctx) {
+  server.registerTool(
+    "desktop_launch",
+    {
+      title: "Launch desktop app",
+      description: "Launch an application inside the desktop session (argument array, no shell). Optionally wait for a window whose name contains a pattern.",
+      inputSchema: {
+        ...sessionArg,
+        command: z5.string().min(1).describe("Executable to launch"),
+        args: z5.array(z5.string()).optional().describe("Arguments for the executable"),
+        cwd: z5.string().min(1).optional().describe("Working directory (relative to the project dir)"),
+        waitWindow: z5.string().min(1).optional().describe("Wait for a window whose name contains this pattern")
+      }
+    },
+    (args) => runTool(async () => {
+      const { id, display } = await resolveDesktop(ctx, args.session);
+      const app = await launchApp2({
+        display,
+        command: args.command,
+        args: args.args ?? [],
+        env: ctx.env,
+        logDir: desktopSessionLogDir(id, ctx.env),
+        cwd: args.cwd === void 0 ? void 0 : path53.resolve(ctx.projectDir, args.cwd)
+      });
+      const data = {
+        sessionId: id,
+        display,
+        pid: app.pid,
+        logPath: app.logPath
+      };
+      if (args.waitWindow !== void 0) {
+        data.window = await waitForWindow(display, args.waitWindow);
+      }
+      return { data };
+    })
+  );
+  server.registerTool(
+    "desktop_screenshot",
+    {
+      title: "Desktop screenshot",
+      description: "Capture the desktop display as PNG. By default the image is recorded as an artifact of a new run under .picklab/runs and returned inline when small enough.",
+      inputSchema: {
+        ...sessionArg,
+        out: z5.string().min(1).optional().describe("Explicit output path instead of a run artifact"),
+        runSlug: z5.string().min(1).optional().describe('Run slug (default "desktop")')
+      }
+    },
+    (args) => runTool(async () => {
+      const { id, display } = await resolveDesktop(ctx, args.session);
+      const target = await resolveScreenshotTarget2(ctx, args, "desktop", id);
+      let tool;
+      const data = await captureToTarget(target, async () => {
+        const result = await screenshot2({
+          display,
+          outPath: target.outPath,
+          env: ctx.env
+        });
+        tool = result.tool;
+      });
+      data.sessionId = id;
+      data.display = display;
+      data.tool = tool;
+      const image = await imageContent(target.outPath);
+      Object.assign(data, image.meta);
+      return { data, extraContent: image.content };
+    })
+  );
+  server.registerTool(
+    "desktop_click",
+    {
+      title: "Desktop click",
+      description: "Click at the given desktop coordinates.",
+      inputSchema: {
+        ...sessionArg,
+        x: z5.number().int().nonnegative().describe("X coordinate"),
+        y: z5.number().int().nonnegative().describe("Y coordinate"),
+        button: z5.number().int().min(1).max(9).optional().describe("Mouse button (1-9, default 1)")
+      }
+    },
+    (args) => runTool(async () => {
+      const { id, display } = await resolveDesktop(ctx, args.session);
+      await click({ display, x: args.x, y: args.y, button: args.button });
+      return {
+        data: {
+          sessionId: id,
+          display,
+          x: args.x,
+          y: args.y,
+          button: args.button ?? 1
+        }
+      };
+    })
+  );
+  server.registerTool(
+    "desktop_type",
+    {
+      title: "Desktop type",
+      description: "Type text into the focused desktop window.",
+      inputSchema: {
+        ...sessionArg,
+        text: z5.string().min(1).describe("Text to type")
+      }
+    },
+    (args) => runTool(async () => {
+      const { id, display } = await resolveDesktop(ctx, args.session);
+      await typeText2({ display, text: args.text });
+      return {
+        data: { sessionId: id, display, length: args.text.length }
+      };
+    })
+  );
+  server.registerTool(
+    "desktop_key",
+    {
+      title: "Desktop key press",
+      description: 'Press a key or chord (e.g. "Return", "Tab", "ctrl+s") in the desktop session.',
+      inputSchema: {
+        ...sessionArg,
+        key: z5.string().min(1).describe("Key or chord to press")
+      }
+    },
+    (args) => runTool(async () => {
+      const { id, display } = await resolveDesktop(ctx, args.session);
+      await pressKey2({ display, key: args.key });
+      return { data: { sessionId: id, display, key: args.key } };
+    })
+  );
+}
+var SECRET_QUESTION_PATTERN = /password|api[_ -]?key|token|secret|2fa|otp|credential/i;
+var SECRET_GUIDANCE = `This looks like a request for a secret (password, API key, token, 2FA code, or other credential). Never collect secrets through this tool. Ask the user to enter the secret directly into the lab app (e.g. via VNC) or into the environment, then confirm out-of-band with kind "confirm" (e.g. "I've entered the password, continue?").`;
+var NO_ELICITATION_GUIDANCE = "This client does not support elicitation. Relay the question to the user in your conversation and wait for their answer before continuing.";
+function registerUserTools(server) {
+  server.registerTool(
+    "request_user_input",
+    {
+      title: "Ask the user",
+      description: 'Ask the human user a question and wait for the answer. Use this when you are blocked on something only a human can provide: a judgment call, a license acceptance, a click you cannot perform, or confirmation that an out-of-band step is done. SECURITY: never request passwords, API keys, or tokens through this tool \u2014 ask the user to enter them directly into the lab app (e.g. via VNC) or environment instead, then confirm completion with kind "confirm".',
+      inputSchema: {
+        question: z6.string().min(1).describe("The question to put to the user"),
+        kind: z6.enum(["text", "confirm"]).optional().describe(
+          'Answer kind: "text" for a free-form answer, "confirm" for a yes/no decision (default "text")'
+        ),
+        context: z6.string().min(1).optional().describe("Why this input is needed, shown alongside the question")
+      }
+    },
+    (args) => runTool(async () => {
+      const kind = args.kind ?? "text";
+      if (kind === "text" && SECRET_QUESTION_PATTERN.test(args.question)) {
+        return { errors: [SECRET_GUIDANCE] };
+      }
+      if (server.server.getClientCapabilities()?.elicitation === void 0) {
+        return { errors: [NO_ELICITATION_GUIDANCE] };
+      }
+      const message = args.context === void 0 ? args.question : `${args.question}
+
+Context: ${args.context}`;
+      const fieldName = kind === "confirm" ? "confirmed" : "answer";
+      const requestedSchema = {
+        type: "object",
+        properties: {
+          [fieldName]: kind === "confirm" ? {
+            type: "boolean",
+            title: "Confirm",
+            description: args.question
+          } : {
+            type: "string",
+            title: "Answer",
+            description: args.question
+          }
+        },
+        required: [fieldName]
+      };
+      const result = await server.server.elicitInput({
+        message,
+        requestedSchema
+      });
+      if (result.action === "accept") {
+        const value = kind === "confirm" ? result.content?.confirmed : result.content?.answer;
+        return { data: { action: "accept", value } };
+      }
+      if (result.action === "decline") {
+        return {
+          data: { action: "decline" },
+          errors: [
+            "The user declined to answer. Do not ask again through this tool; continue without this input or ask in your conversation."
+          ]
+        };
+      }
+      return {
+        data: { action: "cancel" },
+        errors: [
+          "The user dismissed the prompt without answering. Relay the question in your conversation, or retry later."
+        ]
+      };
+    })
+  );
+}
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function createMcpServer(opts = {}) {
+  const ctx = resolveContext(opts);
+  const server = new McpServer({ name: "picklab", version });
+  registerSessionTools(server, ctx);
+  registerDesktopTools(server, ctx);
+  registerAndroidTools(server, ctx);
+  registerArtifactTools(server, ctx);
+  registerUserTools(server);
+  registerResources(server, ctx);
+  registerPrompts(server);
+  return server;
+}
+
+// src/commands/mcp.ts
+async function runMcpServe() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("picklab mcp server: listening on stdio");
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      void server.close().catch(() => {
+      }).then(() => resolve(0));
+    };
+    server.server.onclose = finish;
+    process.stdin.on("end", finish);
+    process.stdin.on("close", finish);
+  });
+}
+
+export {
+  picklabHome,
+  agentsDir,
+  projectConfigPath,
+  globalConfigPath,
+  runsDir,
+  ensureDir,
+  resolvedDefaults,
+  deepMerge,
+  readConfigFile,
+  loadConfig,
+  saveProjectConfig,
+  saveGlobalConfig,
+  listRuns,
+  redactSecrets,
+  runCommand,
+  getSession,
+  listSessions,
+  resolveRunnableSession,
+  requireDisplay,
+  resolveScreenshotTarget,
+  captureToTarget,
+  findOnPath,
+  missingSdkMessage,
+  isValidSystemImageId,
+  sdkmanagerInstallCommand,
+  detectAndroidEnvironment,
+  buildCreateAvdArgs,
+  listAvds,
+  installApk,
+  launchApp,
+  screenshot,
+  tap,
+  typeText,
+  back,
+  home,
+  getUiTree,
+  logcat,
+  clearLogcat,
+  runAdb,
+  createAndroidSession,
+  destroyAndroidSession,
+  getAndroidSessionStatus,
+  findOnPath2,
+  detectVncBinary,
+  launchApp2,
+  waitForWindow,
+  detectScreenshotTool,
+  screenshot2,
+  click,
+  typeText2,
+  pressKey2 as pressKey,
+  desktopSessionLogDir,
+  createDesktopSession,
+  destroyDesktopSession,
+  getDesktopSessionStatus,
+  runMcpServe
+};