vibeview 0.7.0

package/dist/cli.js

@@ -0,0 +1,1947 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/run-suite.ts
+import chalk3 from "chalk";
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".vibeview");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+
+// src/lib/auth.ts
+function resolveAuth(options) {
+  const token = options.token || process.env.VIBEVIEW_API_TOKEN || loadConfig().token;
+  if (!token) {
+    console.error("Error: No API token found.");
+    console.error(
+      "Set VIBEVIEW_API_TOKEN environment variable, use --token flag, or run: vibeview login"
+    );
+    process.exit(2);
+  }
+  const baseUrl = options.baseUrl || process.env.VIBEVIEW_BASE_URL || loadConfig().baseUrl || "https://vibeview.io";
+  return { token, baseUrl };
+}
+
+// src/lib/api-client.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+var ApiClient = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}/api/v1/ci${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+    const resp = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      if (resp.status === 401) throw new Error("Authentication failed. Check your API token.");
+      if (resp.status === 404) throw new Error(`Not found: ${path}`);
+      throw new Error(`API error ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+  async listSuites(opts) {
+    const params = new URLSearchParams();
+    if (opts?.tags && opts.tags.length > 0) params.set("tags", opts.tags.join(","));
+    if (opts?.match) params.set("match", opts.match);
+    const qs = params.toString();
+    return this.request("GET", `/list-suites${qs ? `?${qs}` : ""}`);
+  }
+  async runSuite(suiteId, options) {
+    return this.request("POST", "/run-suite", {
+      suite_id: suiteId,
+      commit_sha: options?.commitSha,
+      model: options?.model,
+      provider: options?.provider,
+      mode: options?.mode,
+      // When pinning a specific device, omit device_category — the backend
+      // rejects the combo.
+      device_category: options?.device ? void 0 : options?.deviceCategory ?? "phone",
+      device_id: options?.device,
+      build_id: options?.build,
+      metadata: options?.metadata
+    });
+  }
+  async runTest(testId, options) {
+    return this.request("POST", "/run-test", {
+      test_id: testId,
+      commit_sha: options?.commitSha,
+      model: options?.model,
+      provider: options?.provider,
+      mode: options?.mode,
+      device_category: options?.device ? void 0 : options?.deviceCategory ?? "phone",
+      device_id: options?.device,
+      build_id: options?.build,
+      metadata: options?.metadata
+    });
+  }
+  /** Cancel a still-queued CI run by its queue entry id. Idempotent best-effort. */
+  async cancelQueueEntry(queueEntryId) {
+    await this.request("DELETE", `/queue/${queueEntryId}`);
+  }
+  /**
+   * Request cancellation of a still-running multi-suite run.
+   * The aggregate transitions to CANCELLED on the runner's next
+   * aggregate-status write; the active child suite stops at its
+   * next case boundary.
+   */
+  async cancelMultiSuiteRun(aggregateId) {
+    await this.request("DELETE", `/multi-suite-runs/${aggregateId}`);
+  }
+  async getRunStatus(runId) {
+    const data = await this.request("GET", `/runs/${runId}`);
+    return { ...data, url: data.run_url ?? `${this.baseUrl}/tests/runs/${runId}` };
+  }
+  /** Request without /ci prefix — for non-CI endpoints like /apps, /tests */
+  async requestRaw(method, path, body) {
+    const url = `${this.baseUrl}/api/v1${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+    const resp = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      if (resp.status === 401) throw new Error("Authentication failed. Check your API token.");
+      if (resp.status === 404) throw new Error(`Not found: ${path}`);
+      throw new Error(`API error ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+  /** FormData request without /ci prefix — for file uploads */
+  async requestFormData(method, path, formData) {
+    const url = `${this.baseUrl}/api/v1${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`
+      // Do NOT set Content-Type — let fetch set multipart boundary automatically
+    };
+    const resp = await fetch(url, {
+      method,
+      headers,
+      body: formData
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      if (resp.status === 401) throw new Error("Authentication failed. Check your API token.");
+      if (resp.status === 404) throw new Error(`Not found: ${path}`);
+      throw new Error(`API error ${resp.status}: ${text}`);
+    }
+    return resp.json();
+  }
+  async listApps() {
+    return this.requestRaw("GET", "/apps/");
+  }
+  async uploadApp(filePath, name) {
+    const fileBuffer = readFileSync2(filePath);
+    const blob = new Blob([fileBuffer]);
+    const formData = new FormData();
+    formData.append("file", blob, basename(filePath));
+    if (name) {
+      formData.append("name", name);
+    }
+    return this.requestFormData("POST", "/apps/upload", formData);
+  }
+  async uploadBuild(appPublicId, filePath, version) {
+    const fileBuffer = readFileSync2(filePath);
+    const blob = new Blob([fileBuffer]);
+    const formData = new FormData();
+    formData.append("file", blob, basename(filePath));
+    if (version) {
+      formData.append("version", version);
+    }
+    return this.requestFormData("POST", `/apps/${appPublicId}/builds`, formData);
+  }
+  async createTest(body) {
+    return this.requestRaw("POST", "/tests/cases/", body);
+  }
+  async runSuites(body) {
+    return this.request("POST", "/run-suites", body);
+  }
+  async getMultiSuiteRun(aggregateId) {
+    return this.request("GET", `/multi-suite-runs/${aggregateId}`);
+  }
+  async listDevices(opts) {
+    const params = new URLSearchParams();
+    if (opts?.type) params.set("device_type", opts.type);
+    if (opts?.category) params.set("category", opts.category);
+    const qs = params.toString();
+    const url = qs ? `/devices?${qs}` : "/devices";
+    const all = await this.requestRaw("GET", url);
+    if (opts?.status) {
+      return all.filter((d) => d.status === opts.status);
+    }
+    return all;
+  }
+  async getDevice(deviceId) {
+    return this.requestRaw("GET", `/devices/${deviceId}`);
+  }
+  async createSession(body) {
+    return this.requestRaw("POST", "/sessions/", body);
+  }
+  async startSession(sessionId, deviceId) {
+    return this.requestRaw("POST", `/sessions/${sessionId}/start`, { device_id: deviceId });
+  }
+  async getSession(sessionId) {
+    return this.requestRaw("GET", `/sessions/${sessionId}`);
+  }
+  async stopSession(sessionId) {
+    await this.requestRaw("DELETE", `/sessions/${sessionId}`);
+  }
+};
+
+// src/lib/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  const isCI = process.env.CI === "true" || process.env.CI === "1" || !process.stdout.isTTY;
+  return ora({ text, isEnabled: !isCI, stream: process.stderr });
+}
+
+// src/lib/poll.ts
+import chalk2 from "chalk";
+
+// src/lib/formatters/human.ts
+import chalk from "chalk";
+function failureLines(failure) {
+  const lines = [];
+  if (failure.error_kind) {
+    const desc = failure.error_kind_description ? `  ${failure.error_kind_description}` : "";
+    lines.push(`        ${chalk.yellow(`[${failure.error_kind}]`)}${chalk.dim(desc)}`);
+  }
+  const detail = failure.error ?? failure.error_message;
+  if (detail) {
+    lines.push(`        ${chalk.dim(detail)}`);
+  }
+  if (failure.screenshot_signed_url) {
+    lines.push(`        ${chalk.dim(`\u2192 ${failure.screenshot_signed_url}`)}`);
+  }
+  return lines;
+}
+function formatHuman(result, verbose) {
+  const lines = [];
+  const icon = result.status === "passed" ? chalk.green("PASS") : chalk.red("FAIL");
+  const duration = result.duration_ms ? `${(result.duration_ms / 1e3).toFixed(1)}s` : "-";
+  lines.push("");
+  if (result.suite_name) {
+    lines.push(`  ${icon}  ${chalk.bold(result.suite_name)}  ${chalk.dim(duration)}`);
+  } else {
+    lines.push(`  ${icon}  ${chalk.bold(result.run_id)}  ${chalk.dim(duration)}`);
+  }
+  const passed = result.test_runs.filter((t) => t.status === "passed").length;
+  const total = result.test_runs.length;
+  lines.push(`  ${chalk.dim(`${passed}/${total} cases passed`)}`);
+  if (result.url) {
+    lines.push(`  ${chalk.dim(result.url)}`);
+  }
+  if (result.test_runs.length > 0) {
+    lines.push("");
+    for (const tr of result.test_runs) {
+      const caseIcon = tr.status === "passed" ? chalk.green("  PASS") : tr.status === "cancelled" || tr.status === "pending" || tr.status === "running" ? chalk.yellow("  SKIP") : chalk.red("  FAIL");
+      const caseDuration = tr.duration_ms ? `${(tr.duration_ms / 1e3).toFixed(1)}s` : "-";
+      lines.push(`  ${caseIcon}  ${tr.case_name}  ${chalk.dim(caseDuration)}`);
+      if (tr.url) {
+        lines.push(`        ${chalk.dim(tr.url)}`);
+      }
+      if (tr.status !== "passed") {
+        lines.push(...failureLines(tr));
+      }
+    }
+  }
+  if (result.steps && result.steps.length > 0) {
+    lines.push("");
+    if (result.case_name) {
+      lines.push(`  ${chalk.bold(result.case_name)}`);
+    }
+    for (const step of result.steps) {
+      const stepIcon = step.status === "passed" ? chalk.green("  PASS") : chalk.red("  FAIL");
+      const stepDuration = step.duration_ms ? `${(step.duration_ms / 1e3).toFixed(1)}s` : "-";
+      lines.push(`  ${stepIcon}  ${step.step}  ${chalk.dim(stepDuration)}`);
+      if (verbose && step.actions && step.actions.length > 0) {
+        for (const action of step.actions) {
+          lines.push(`        ${chalk.dim(formatAction(action))}`);
+        }
+      }
+      if (step.status !== "passed") {
+        lines.push(...failureLines(step));
+      }
+    }
+  }
+  if (result.error_message) {
+    lines.push(`
+  ${chalk.red("Error:")} ${result.error_message}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/lib/formatters/json.ts
+function formatJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/lib/formatters/junit.ts
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatJunit(result) {
+  const suiteName = escapeXml(result.suite_name || result.run_id);
+  const tests = result.test_runs.length;
+  const failures = result.test_runs.filter((t) => t.status === "failed").length;
+  const errors = result.test_runs.filter((t) => t.status === "error").length;
+  const totalTime = result.duration_ms ? (result.duration_ms / 1e3).toFixed(1) : "0";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push(
+    `<testsuites name="vibeview" tests="${tests}" failures="${failures}" errors="${errors}" time="${totalTime}">`
+  );
+  lines.push(
+    `  <testsuite name="${suiteName}" tests="${tests}" failures="${failures}" errors="${errors}" time="${totalTime}" timestamp="${timestamp}">`
+  );
+  for (const tr of result.test_runs) {
+    const caseName = escapeXml(tr.case_name);
+    const caseTime = tr.duration_ms ? (tr.duration_ms / 1e3).toFixed(1) : "0";
+    if (tr.status === "passed") {
+      lines.push(`    <testcase name="${caseName}" classname="${suiteName}" time="${caseTime}" />`);
+    } else if (tr.status === "failed") {
+      const msg = escapeXml(tr.error_message || "Test failed");
+      lines.push(`    <testcase name="${caseName}" classname="${suiteName}" time="${caseTime}">`);
+      lines.push(`      <failure message="${msg}" type="TestFailure">${msg}</failure>`);
+      lines.push("    </testcase>");
+    } else {
+      const msg = escapeXml(tr.error_message || "Infrastructure error");
+      lines.push(`    <testcase name="${caseName}" classname="${suiteName}" time="${caseTime}">`);
+      lines.push(`      <error message="${msg}" type="InfraError">${msg}</error>`);
+      lines.push("    </testcase>");
+    }
+  }
+  lines.push("  </testsuite>");
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+function formatMultiSuiteJunit(result) {
+  const tests = result.suite_runs.reduce((sum, sr) => sum + sr.passed + sr.failed, 0);
+  const failures = result.suite_runs.reduce((sum, sr) => sum + sr.failed, 0);
+  const totalErrors = result.suite_runs.filter((sr) => sr.status === "error").length;
+  const timestamp = result.started_at ?? (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push(
+    `<testsuites name="vibeview-multi" tests="${tests}" failures="${failures}" errors="${totalErrors}">`
+  );
+  for (const sr of result.suite_runs) {
+    const suiteName = escapeXml(sr.suite_name || sr.suite_id);
+    const suiteTests = sr.passed + sr.failed;
+    const suiteFails = sr.failed;
+    const suiteErrors = sr.status === "error" ? 1 : 0;
+    lines.push(
+      `  <testsuite name="${suiteName}" tests="${suiteTests}" failures="${suiteFails}" errors="${suiteErrors}" timestamp="${timestamp}">`
+    );
+    if (suiteErrors > 0) {
+      lines.push(`    <error message="Suite errored" type="InfraError" />`);
+    }
+    lines.push("  </testsuite>");
+  }
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+
+// src/lib/types.ts
+var EXIT_PASS = 0;
+var EXIT_TEST_FAIL = 1;
+var EXIT_INFRA_ERROR = 2;
+
+// src/lib/poll.ts
+function printBelowSpinner(spinner, line) {
+  const text = spinner.text;
+  spinner.stop();
+  process.stderr.write(line + "\n");
+  spinner.start(text);
+}
+async function pollUntilComplete(client, runId, timeoutMs, spinner, onQueueObserved) {
+  const deadline = Date.now() + timeoutMs;
+  const isCI = process.env.CI === "true" || process.env.CI === "1" || !process.stdout.isTTY;
+  let lastLogTime = Date.now();
+  let lastSeenEventCount = 0;
+  let totalSteps;
+  let currentStepLabel = "";
+  let cachedDeviceLabel = null;
+  const caseStateBefore = /* @__PURE__ */ new Map();
+  const caseStartedPrinted = /* @__PURE__ */ new Set();
+  while (Date.now() < deadline) {
+    const result = await client.getRunStatus(runId);
+    const progress = result.progress || [];
+    if (progress.length > lastSeenEventCount) {
+      const newEvents = progress.slice(lastSeenEventCount);
+      for (const evt of newEvents) {
+        const ctx = { spinner, totalSteps, currentStepLabel };
+        displayProgressEvent(evt, ctx);
+        totalSteps = ctx.totalSteps;
+        currentStepLabel = ctx.currentStepLabel;
+      }
+      lastSeenEventCount = progress.length;
+    }
+    if (result.type === "suite_run" && Array.isArray(result.test_runs)) {
+      for (const tr of result.test_runs) {
+        if (!tr.public_id) continue;
+        const prev = caseStateBefore.get(tr.public_id);
+        const cur = tr.status ?? "pending";
+        if (cur === "running" && !caseStartedPrinted.has(tr.public_id)) {
+          caseStartedPrinted.add(tr.public_id);
+          printBelowSpinner(
+            spinner,
+            `${chalk2.cyan("\u25B6")} ${chalk2.bold(tr.case_name || "Case")} started`
+          );
+        }
+        const isTerminal = ["passed", "failed", "error", "cancelled"].includes(cur);
+        const wasTerminal = prev && ["passed", "failed", "error", "cancelled"].includes(prev);
+        if (isTerminal && !wasTerminal) {
+          const icon = cur === "passed" ? chalk2.green("\u2713") : cur === "cancelled" ? chalk2.yellow("\u26A0") : chalk2.red("\u2717");
+          const dur = tr.duration_ms ? ` (${(tr.duration_ms / 1e3).toFixed(1)}s)` : "";
+          printBelowSpinner(spinner, `${icon} ${chalk2.bold(tr.case_name || "Case")} ${cur}${dur}`);
+          if (tr.error_message && cur !== "passed") {
+            printBelowSpinner(spinner, `    ${chalk2.red(tr.error_message)}`);
+          }
+        }
+        caseStateBefore.set(tr.public_id, cur);
+      }
+    }
+    if (["passed", "failed", "error", "cancelled"].includes(result.status)) {
+      return result;
+    }
+    if (result.status === "queued" && result.queue) {
+      const q = result.queue;
+      if (onQueueObserved) {
+        onQueueObserved(q.entry_id);
+      }
+      let label;
+      if (q.specific_device_id) {
+        if (cachedDeviceLabel === null) {
+          try {
+            const dev2 = await client.getDevice(q.specific_device_id);
+            cachedDeviceLabel = `${dev2.name} (${dev2.device_id})`;
+          } catch {
+            cachedDeviceLabel = q.specific_device_id;
+          }
+        }
+        label = cachedDeviceLabel;
+      } else {
+        label = "the device pool";
+      }
+      spinner.text = `Queued \u2014 position ${q.position} in line for ${label}`;
+    }
+    if (progress.length === 0) {
+      if (result.status === "pending") {
+        spinner.text = "Waiting for device...";
+      } else if (result.status === "running") {
+        if (result.type === "suite_run" && Array.isArray(result.test_runs)) {
+          const total = result.total_cases ?? result.test_runs.length;
+          const done = result.test_runs.filter(
+            (tr) => ["passed", "failed", "error", "cancelled"].includes(tr.status ?? "")
+          ).length;
+          spinner.text = `Running suite \u2014 ${done}/${total} cases complete...`;
+        } else {
+          spinner.text = "Running tests...";
+        }
+      } else {
+        spinner.text = `Status: ${result.status}...`;
+      }
+    }
+    if (isCI && Date.now() - lastLogTime >= 3e4) {
+      console.log(`Status: ${result.status}...`);
+      lastLogTime = Date.now();
+    }
+    await new Promise((r) => setTimeout(r, 3e3));
+  }
+  throw new Error(`Timeout: run did not complete within ${Math.round(timeoutMs / 1e3)}s`);
+}
+function formatAction(action) {
+  const tool = action.tool;
+  const args = action.args || {};
+  switch (tool) {
+    case "tap":
+      return `tap ${args.element_ref || ""}`;
+    case "tap_coordinates":
+      return `tap (${args.x}, ${args.y})`;
+    case "type_text":
+      return `type "${args.text || ""}"`;
+    case "swipe":
+      return `swipe ${args.direction || ""}`;
+    case "press_button":
+      return `press ${args.button || ""}`;
+    case "wait":
+      return `wait ${args.seconds || args.ms || ""}s`;
+    case "step_complete":
+      return `step complete: ${args.summary || ""}`;
+    case "step_failed":
+      return `step failed: ${args.reason || ""}`;
+    default:
+      return `${tool}(${Object.entries(args).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ")})`;
+  }
+}
+function formatToolCall(tc) {
+  return formatAction({ tool: tc.name, args: tc.args });
+}
+function displayProgressEvent(evt, ctx) {
+  const { spinner } = ctx;
+  switch (evt.event) {
+    case "run_started":
+      printBelowSpinner(
+        spinner,
+        `${chalk2.cyan("\u25B6")} AI test started \u2014 ${evt.total_steps} step(s), model: ${chalk2.bold(evt.model || "default")}`
+      );
+      ctx.totalSteps = evt.total_steps ?? ctx.totalSteps;
+      break;
+    case "step_started": {
+      const stepNum = (evt.step_index ?? 0) + 1;
+      const total = ctx.totalSteps ?? evt.total_steps ?? "?";
+      ctx.currentStepLabel = `Step ${stepNum}/${total}: ${evt.step_text || "..."}`;
+      spinner.text = `  ${ctx.currentStepLabel}`;
+      break;
+    }
+    case "step_completed": {
+      const stepNum = (evt.step_index ?? 0) + 1;
+      const total = ctx.totalSteps ?? evt.total_steps ?? "?";
+      const icon = evt.status === "passed" ? chalk2.green("\u2713") : evt.status === "failed" ? chalk2.red("\u2717") : chalk2.yellow("!");
+      spinner.stop();
+      process.stderr.write(`  ${icon} Step ${stepNum}/${total}: ${evt.step_text || ""}
+`);
+      if (evt.actions && evt.actions.length > 0) {
+        for (const action of evt.actions) {
+          process.stderr.write(`    ${chalk2.dim(formatAction(action))}
+`);
+        }
+      }
+      if (evt.error) {
+        process.stderr.write(`    ${chalk2.red(evt.error)}
+`);
+      }
+      spinner.start();
+      break;
+    }
+    case "conversation_turn": {
+      const turn = evt.turn;
+      if (!turn) break;
+      if (turn.role === "assistant" && turn.tool_calls && turn.tool_calls.length > 0) {
+        const lastAction = turn.tool_calls[turn.tool_calls.length - 1];
+        spinner.text = `  ${ctx.currentStepLabel} ${chalk2.dim("\u2192 " + formatToolCall(lastAction))}`;
+      }
+      break;
+    }
+    case "run_completed": {
+      const icon = evt.status === "passed" ? chalk2.green("\u2713") : evt.status === "cancelled" ? chalk2.yellow("\u26A0") : chalk2.red("\u2717");
+      spinner.stop();
+      process.stderr.write(
+        `${icon} Run ${evt.status}${evt.duration_ms ? ` (${(evt.duration_ms / 1e3).toFixed(1)}s)` : ""}
+`
+      );
+      spinner.start();
+      break;
+    }
+    case "app_installing":
+      spinner.text = "  Installing app...";
+      break;
+    case "app_installed":
+      spinner.text = "  App installed. Starting test...";
+      break;
+    default:
+      break;
+  }
+}
+function outputResult(result, options) {
+  switch (options.output) {
+    case "json":
+      console.log(formatJson(result));
+      break;
+    case "junit":
+      console.log(formatJunit(result));
+      break;
+    default:
+      console.log(formatHuman(result, options.verbose ?? false));
+  }
+}
+function mapExitCode(status) {
+  if (status === "passed") return EXIT_PASS;
+  if (status === "failed") return EXIT_TEST_FAIL;
+  return EXIT_INFRA_ERROR;
+}
+
+// src/commands/run-suite.ts
+async function runSuite(suiteId, options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  const spinner = createSpinner("Starting suite run...");
+  let sessionId;
+  let lastQueueEntryId;
+  let cleaning = false;
+  const cleanup = async (signal) => {
+    if (cleaning) process.exit(130);
+    cleaning = true;
+    try {
+      spinner.stop();
+    } catch {
+    }
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    process.stderr.write(`
+${signal} received.
+`);
+    if (lastQueueEntryId !== void 0) {
+      process.stderr.write("Cancelling queued run...\n");
+      try {
+        await client.cancelQueueEntry(lastQueueEntryId);
+        process.stderr.write("Queue entry cancelled.\n");
+      } catch {
+      }
+    }
+    if (sessionId) {
+      process.stderr.write("Stopping session...\n");
+      try {
+        await client.stopSession(sessionId);
+        process.stderr.write("Session stopped.\n");
+      } catch {
+      }
+    }
+    process.exit(130);
+  };
+  process.on("SIGINT", () => void cleanup("SIGINT"));
+  process.on("SIGTERM", () => void cleanup("SIGTERM"));
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (key) => {
+      if (key[0] === 3 || key[0] === 4) {
+        void cleanup("Ctrl+C");
+      }
+    });
+  }
+  spinner.start();
+  try {
+    const response = await client.runSuite(suiteId, {
+      commitSha: options.commitSha,
+      model: options.model,
+      provider: options.provider,
+      mode: options.mode,
+      deviceCategory: options.deviceCategory,
+      device: options.device,
+      build: options.build,
+      metadata: options.metadata
+    });
+    sessionId = response.session_id;
+    spinner.stop();
+    process.stderr.write(
+      `${chalk3.dim("Suite:")} ${suiteId}
+${chalk3.dim("Run:")} ${response.run_id}
+` + (sessionId ? `${chalk3.dim("Session:")} ${sessionId}
+` : "")
+    );
+    spinner.start("Waiting for device...");
+    const timeoutMs = (options.timeout ?? 300) * 1e3;
+    const result = await pollUntilComplete(
+      client,
+      response.run_id,
+      timeoutMs,
+      spinner,
+      (entryId) => {
+        lastQueueEntryId = entryId;
+      }
+    );
+    spinner.stop();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    outputResult(result, options);
+    process.exit(mapExitCode(result.status));
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Unknown error");
+    if (lastQueueEntryId !== void 0) {
+      try {
+        await client.cancelQueueEntry(lastQueueEntryId);
+      } catch {
+      }
+    }
+    if (sessionId) {
+      try {
+        await client.stopSession(sessionId);
+      } catch {
+      }
+    }
+    process.exit(EXIT_INFRA_ERROR);
+  }
+}
+
+// src/commands/run-suites.ts
+import chalk4 from "chalk";
+var AGGREGATE_TIMEOUT_CAP_S = 7200;
+async function runSuites(opts) {
+  if (!opts.tag || opts.tag.length === 0) {
+    process.stderr.write("error: at least one --tag is required\n");
+    process.exit(EXIT_INFRA_ERROR);
+  }
+  const { token, baseUrl } = resolveAuth(opts);
+  const client = new ApiClient(baseUrl, token);
+  const spinner = createSpinner("Submitting multi-suite run...");
+  let aggregateId;
+  let cleaning = false;
+  const cleanup = async (signal) => {
+    if (cleaning) process.exit(130);
+    cleaning = true;
+    try {
+      spinner.stop();
+    } catch {
+    }
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    process.stderr.write(`
+${signal} received.
+`);
+    if (aggregateId) {
+      process.stderr.write("Cancelling multi-suite run...\n");
+      try {
+        await client.cancelMultiSuiteRun(aggregateId);
+        process.stderr.write("Cancellation requested.\n");
+      } catch {
+      }
+    }
+    process.exit(130);
+  };
+  process.on("SIGINT", () => void cleanup("SIGINT"));
+  process.on("SIGTERM", () => void cleanup("SIGTERM"));
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (key) => {
+      if (key[0] === 3 || key[0] === 4) {
+        void cleanup("Ctrl+C");
+      }
+    });
+  }
+  spinner.start();
+  let start;
+  try {
+    start = await client.runSuites({
+      tags: opts.tag,
+      match: opts.match ?? "any",
+      platform: opts.platform,
+      commit_sha: opts.commitSha,
+      model: opts.model,
+      provider: opts.provider,
+      mode: opts.mode,
+      device_category: opts.device ? void 0 : opts.deviceCategory ?? "phone",
+      device_id: opts.device,
+      build_id: opts.build,
+      metadata: opts.metadata
+    });
+  } catch (err) {
+    spinner.stop();
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.startsWith("Not found:") || msg.includes("404") || /No suites match tags/.test(msg)) {
+      const suffix = opts.platform ? ` on platform ${opts.platform}` : "";
+      process.stderr.write(chalk4.yellow(`No suites match tags: ${opts.tag.join(", ")}${suffix}
+`));
+      process.exit(EXIT_INFRA_ERROR);
+    }
+    process.stderr.write(chalk4.red(`Failed to start: ${msg}
+`));
+    process.exit(EXIT_INFRA_ERROR);
+  }
+  aggregateId = start.aggregate_id;
+  spinner.stop();
+  const matchedNames = start.matched_suites?.map((s) => s.name) ?? [];
+  const totalMatched = start.matched_suite_ids.length;
+  process.stderr.write(
+    `${chalk4.dim("Aggregate:")} ${start.aggregate_id}
+${chalk4.dim("Tags:")} ${opts.tag.join(", ")} ${chalk4.dim("(" + (opts.match ?? "any") + ")")}
+${chalk4.dim("Matched:")} ${totalMatched} suite(s)${matchedNames.length ? " \u2014 " + matchedNames.join(", ") : ""}
+`
+  );
+  const excluded = start.excluded_suites ?? [];
+  if (excluded.length) {
+    const names = excluded.map((s) => s.name).join(", ");
+    process.stderr.write(
+      chalk4.dim(`Excluded ${excluded.length} suite(s) (platform mismatch): ${names}
+`)
+    );
+  }
+  spinner.start(`Running ${totalMatched} suite(s)...`);
+  const perSuiteTimeout = Math.max(opts.timeout ?? 300, 30);
+  const totalTimeout = Math.min(
+    perSuiteTimeout * start.matched_suite_ids.length,
+    AGGREGATE_TIMEOUT_CAP_S
+  );
+  const deadline = Date.now() + totalTimeout * 1e3;
+  const suiteStateBefore = /* @__PURE__ */ new Map();
+  const suiteStartedPrinted = /* @__PURE__ */ new Set();
+  const print = (line) => {
+    spinner.stop();
+    process.stderr.write(line + "\n");
+    spinner.start();
+  };
+  const TERMINAL = /* @__PURE__ */ new Set(["passed", "failed", "error", "cancelled"]);
+  let last = null;
+  while (Date.now() < deadline) {
+    last = await client.getMultiSuiteRun(start.aggregate_id);
+    let doneCount = 0;
+    let queuedChild;
+    for (const sr of last.suite_runs) {
+      const cur = sr.status;
+      const prev = suiteStateBefore.get(sr.run_id);
+      if (cur === "queued" && prev !== "queued") {
+        queuedChild = sr;
+      }
+      if (cur === "running" && !suiteStartedPrinted.has(sr.run_id)) {
+        suiteStartedPrinted.add(sr.run_id);
+        print(`${chalk4.cyan("\u25B6")} ${chalk4.bold(sr.suite_name)} started`);
+      }
+      const wasTerminal = prev !== void 0 && TERMINAL.has(prev);
+      if (TERMINAL.has(cur) && !wasTerminal) {
+        const mark = cur === "passed" ? chalk4.green("\u2713") : cur === "cancelled" ? chalk4.yellow("\u26A0") : chalk4.red("\u2717");
+        const link = sr.url ? chalk4.dim(" " + sr.url) : "";
+        print(
+          `${mark} ${chalk4.bold(sr.suite_name)} ${cur}: ${sr.passed} passed, ${sr.failed} failed${link}`
+        );
+        if (sr.error_message) {
+          print(`    ${chalk4.red(sr.error_message)}`);
+        }
+      }
+      suiteStateBefore.set(sr.run_id, cur);
+      if (TERMINAL.has(cur)) doneCount++;
+      if (cur === "queued") queuedChild = sr;
+    }
+    if (queuedChild && queuedChild.queue) {
+      const q = queuedChild.queue;
+      const target = q.specific_device_id ?? "the device pool";
+      spinner.text = `Queued \u2014 ${chalk4.bold(queuedChild.suite_name)} position ${q.position} for ${target} (${doneCount}/${totalMatched} suite(s) complete)`;
+    } else {
+      spinner.text = `Running suites \u2014 ${doneCount}/${totalMatched} complete...`;
+    }
+    if (last.status !== "pending" && last.status !== "running") break;
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  spinner.stop();
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  }
+  if (!last) {
+    process.stderr.write(chalk4.red("Timed out before any status was returned.\n"));
+    process.exit(EXIT_INFRA_ERROR);
+  }
+  if (opts.output === "json") {
+    process.stdout.write(JSON.stringify(last, null, 2) + "\n");
+  } else if (opts.output === "junit") {
+    process.stdout.write(formatMultiSuiteJunit(last) + "\n");
+  } else {
+    process.stdout.write(`
+Aggregate: ${last.status}
+`);
+    for (const sr of last.suite_runs) {
+      const mark = sr.status === "passed" ? chalk4.green("\u2713") : chalk4.red("\u2717");
+      const link = sr.url ? chalk4.dim(` ${sr.url}`) : "";
+      process.stdout.write(
+        `  ${mark} ${sr.suite_name}: ${sr.passed} passed, ${sr.failed} failed${link}
+`
+      );
+      if (sr.error_message) {
+        process.stdout.write(`      ${chalk4.red(sr.error_message)}
+`);
+      }
+      for (const cr of sr.case_runs ?? []) {
+        const caseMark = cr.status === "passed" ? chalk4.green("\u2713") : cr.status === "cancelled" || cr.status === "pending" || cr.status === "running" ? chalk4.yellow("-") : chalk4.red("\u2717");
+        const dur = cr.duration_ms ? chalk4.dim(` (${(cr.duration_ms / 1e3).toFixed(1)}s)`) : "";
+        process.stdout.write(
+          `      ${caseMark} ${cr.case_name ?? "Case"} ${cr.status ?? "?"}${dur} ${chalk4.dim(cr.url)}
+`
+        );
+        if (cr.error_message && cr.status !== "passed") {
+          process.stdout.write(`          ${chalk4.red(cr.error_message)}
+`);
+        }
+      }
+    }
+  }
+  if (last.status === "passed") process.exit(EXIT_PASS);
+  if (last.status === "failed") process.exit(EXIT_TEST_FAIL);
+  process.exit(EXIT_INFRA_ERROR);
+}
+
+// src/commands/run-test.ts
+import chalk5 from "chalk";
+async function runTest(testId, options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  let sessionId;
+  let lastQueueEntryId;
+  const spinner = createSpinner("Starting test run...");
+  let cleaning = false;
+  const cleanup = async (signal) => {
+    if (cleaning) process.exit(130);
+    cleaning = true;
+    try {
+      spinner.stop();
+    } catch {
+    }
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    process.stderr.write(`
+${signal} received.
+`);
+    if (lastQueueEntryId !== void 0) {
+      process.stderr.write("Cancelling queued run...\n");
+      try {
+        await client.cancelQueueEntry(lastQueueEntryId);
+        process.stderr.write("Queue entry cancelled.\n");
+      } catch {
+      }
+    }
+    if (sessionId) {
+      process.stderr.write("Stopping session...\n");
+      try {
+        await client.stopSession(sessionId);
+        process.stderr.write("Session stopped.\n");
+      } catch {
+      }
+    }
+    process.exit(130);
+  };
+  process.on("SIGINT", () => void cleanup("SIGINT"));
+  process.on("SIGTERM", () => void cleanup("SIGTERM"));
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (key) => {
+      if (key[0] === 3 || key[0] === 4) {
+        void cleanup("Ctrl+C");
+      }
+    });
+  }
+  spinner.start();
+  try {
+    const response = await client.runTest(testId, {
+      commitSha: options.commitSha,
+      model: options.model,
+      provider: options.provider,
+      mode: options.mode,
+      deviceCategory: options.deviceCategory,
+      device: options.device,
+      build: options.build,
+      metadata: options.metadata
+    });
+    sessionId = response.session_id;
+    spinner.stop();
+    process.stderr.write(
+      `${chalk5.dim("Session:")} ${sessionId || "unknown"}
+${chalk5.dim("Device:")} ${response.device_name || "allocating..."}
+${chalk5.dim("Test:")} ${testId}
+${chalk5.dim("Run:")} ${response.run_id}
+`
+    );
+    spinner.start("Waiting for device...");
+    const timeoutMs = (options.timeout ?? 300) * 1e3;
+    const result = await pollUntilComplete(
+      client,
+      response.run_id,
+      timeoutMs,
+      spinner,
+      (entryId) => {
+        lastQueueEntryId = entryId;
+      }
+    );
+    spinner.stop();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    outputResult(result, options);
+    process.exit(mapExitCode(result.status));
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Unknown error");
+    if (lastQueueEntryId !== void 0) {
+      try {
+        await client.cancelQueueEntry(lastQueueEntryId);
+      } catch {
+      }
+    }
+    if (sessionId) {
+      try {
+        await client.stopSession(sessionId);
+      } catch {
+      }
+    }
+    process.exit(EXIT_INFRA_ERROR);
+  }
+}
+
+// src/commands/list-suites.ts
+import chalk6 from "chalk";
+async function listSuites(options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  const suites = await client.listSuites({
+    tags: options.tag && options.tag.length > 0 ? options.tag : void 0,
+    match: options.match
+  });
+  if (options.output === "json") {
+    console.log(JSON.stringify(suites, null, 2));
+    return;
+  }
+  if (suites.length === 0) {
+    console.log("No test suites found.");
+    return;
+  }
+  console.log(chalk6.bold(`
+  ${suites.length} suite(s)
+`));
+  for (const s of suites) {
+    const platform = s.platform ? chalk6.dim(` [${s.platform}]`) : "";
+    const tagsText = s.tags && s.tags.length > 0 ? chalk6.dim(` [${s.tags.map((t) => t.display_name).join(", ")}]`) : "";
+    console.log(`  ${chalk6.cyan(s.id)}  ${s.name}${platform}${tagsText}  (${s.case_count} cases)`);
+  }
+  console.log();
+}
+
+// src/commands/list-apps.ts
+import chalk7 from "chalk";
+async function listApps(options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  const apps = await client.listApps();
+  if (options.output === "json") {
+    console.log(JSON.stringify(apps, null, 2));
+    return;
+  }
+  if (apps.length === 0) {
+    console.log("No apps found.");
+    return;
+  }
+  console.log(chalk7.bold(`
+  ${apps.length} app(s)
+`));
+  for (const app of apps) {
+    const platform = chalk7.dim(` [${app.platform}]`);
+    const pkg2 = chalk7.dim(app.package_name);
+    console.log(`  ${chalk7.cyan(app.public_id)}  ${app.name}${platform}  ${pkg2}`);
+    console.log(chalk7.dim(`    ${baseUrl}/apps/${app.public_id}`));
+  }
+  console.log();
+}
+
+// src/commands/upload-app.ts
+import chalk8 from "chalk";
+import { existsSync } from "fs";
+async function uploadApp(filePath, options) {
+  if (!existsSync(filePath)) {
+    console.error(chalk8.red(`Error: File not found: ${filePath}`));
+    process.exit(EXIT_INFRA_ERROR);
+  }
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  const spinner = createSpinner("Uploading app...");
+  spinner.start();
+  try {
+    const result = await client.uploadApp(filePath, options.name);
+    const isNew = result.is_new !== false;
+    spinner.succeed(
+      isNew ? `New app created: ${result.name}` : `Build added to existing app: ${result.name}`
+    );
+    if (options.output === "json") {
+      console.log(
+        JSON.stringify(
+          {
+            app_id: result.public_id,
+            name: result.name,
+            package_name: result.package_name,
+            platform: result.platform,
+            is_new: isNew,
+            url: `${baseUrl}/apps/${result.public_id}`,
+            warnings: result.warnings ?? []
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(
+        `
+  ${chalk8.cyan(result.public_id)}  ${result.name}  ${chalk8.dim(`[${result.platform}]`)}`
+      );
+      console.log(`  ${chalk8.dim(result.package_name)}`);
+      console.log(chalk8.dim(`  ${baseUrl}/apps/${result.public_id}
+`));
+    }
+    for (const w of result.warnings ?? []) {
+      console.error(chalk8.yellow(`
+\u26A0 ${w}`));
+    }
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Upload failed");
+    process.exit(EXIT_INFRA_ERROR);
+  }
+}
+
+// src/commands/create-test.ts
+import chalk9 from "chalk";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    const timeout = setTimeout(() => {
+      process.stdin.removeAllListeners();
+      resolve(data);
+    }, 5e3);
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+async function resolveSteps(options) {
+  if (options.steps) {
+    return JSON.parse(options.steps);
+  }
+  if (options.stepsFile) {
+    if (!existsSync2(options.stepsFile)) {
+      throw new Error(`Steps file not found: ${options.stepsFile}`);
+    }
+    return JSON.parse(readFileSync3(options.stepsFile, "utf-8"));
+  }
+  if (!process.stdin.isTTY) {
+    const input = await readStdin();
+    if (input.trim()) {
+      return JSON.parse(input.trim());
+    }
+  }
+  throw new Error("No steps provided. Use --steps, --steps-file, or pipe JSON to stdin.");
+}
+async function resolveAppId(client, appRef, platform) {
+  if (appRef.includes(".")) {
+    if (!platform) {
+      throw new Error(
+        "When using a package name for --app, you must also specify --platform (ios, android)."
+      );
+    }
+    const apps = await client.listApps();
+    const match = apps.find((a) => a.package_name === appRef && a.platform === platform);
+    if (!match) {
+      throw new Error(`No app found with package name "${appRef}" and platform "${platform}".`);
+    }
+    return match.public_id;
+  }
+  return appRef;
+}
+async function createTest(options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  try {
+    const steps = await resolveSteps(options);
+    let appPublicId;
+    if (options.app) {
+      appPublicId = await resolveAppId(client, options.app, options.platform);
+    }
+    const spinner = createSpinner("Creating test...");
+    spinner.start();
+    const result = await client.createTest({
+      name: options.testName || "CLI Test",
+      app_id: appPublicId || "",
+      steps,
+      context: options.context,
+      mode: "ai"
+    });
+    spinner.succeed(`Test created: ${result.name}`);
+    if (options.output === "json") {
+      console.log(
+        JSON.stringify(
+          {
+            test_id: result.public_id,
+            name: result.name,
+            app_id: appPublicId || null,
+            url: `${baseUrl}/tests?tab=standalone`
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(`
+  ${chalk9.cyan(result.public_id)}  ${result.name}`);
+      if (result.app_name) {
+        console.log(`  ${chalk9.dim(`App: ${result.app_name}`)}`);
+      }
+      if (result.platform) {
+        console.log(`  ${chalk9.dim(`Platform: ${result.platform}`)}`);
+      }
+      console.log(`  ${chalk9.dim(`Steps: ${steps.length}`)}`);
+      console.log(chalk9.dim(`  ${baseUrl}/tests?tab=standalone
+`));
+    }
+  } catch (err) {
+    console.error(chalk9.red(err instanceof Error ? err.message : "Failed to create test"));
+    process.exit(EXIT_INFRA_ERROR);
+  }
+}
+
+// src/commands/login.ts
+import { randomUUID } from "crypto";
+import open from "open";
+async function login(options) {
+  const baseUrl = options.baseUrl || process.env.VIBEVIEW_BASE_URL || loadConfig().baseUrl || "https://vibeview.io";
+  const code = randomUUID();
+  try {
+    await fetch(`${baseUrl}/api/v1/auth/cli-token/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+  } catch {
+  }
+  const loginUrl = `${baseUrl}/login?cli_code=${code}`;
+  console.log(`
+Opening browser to log in...
+  ${loginUrl}
+`);
+  await open(loginUrl);
+  const spinner = createSpinner("Waiting for browser login...");
+  spinner.start();
+  const deadline = Date.now() + 12e4;
+  while (Date.now() < deadline) {
+    try {
+      const resp = await fetch(`${baseUrl}/api/v1/auth/cli-token?code=${code}`);
+      if (resp.status === 410) {
+        spinner.fail("Login code expired. Please try again.");
+        process.exit(EXIT_INFRA_ERROR);
+      }
+      const data = await resp.json();
+      if (data.status === "complete" && data.token) {
+        spinner.succeed("Logged in successfully.");
+        saveConfig({ token: data.token, baseUrl });
+        console.log("  Token saved to ~/.vibeview/config.json");
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  spinner.fail("Login timed out. Please try again.");
+  process.exit(EXIT_INFRA_ERROR);
+}
+
+// src/commands/dev.ts
+import { select } from "@inquirer/prompts";
+import chalk10 from "chalk";
+import openBrowser from "open";
+
+// src/lib/tunnel-client.ts
+import net from "net";
+import WebSocket from "ws";
+
+// src/lib/mux.ts
+var FRAME_OPEN = 1;
+var FRAME_DATA = 2;
+var FRAME_CLOSE = 3;
+var HEADER_LEN = 5;
+var KNOWN = /* @__PURE__ */ new Set([FRAME_OPEN, FRAME_DATA, FRAME_CLOSE]);
+function encodeFrame(type, streamId, payload = Buffer.alloc(0)) {
+  const header = Buffer.alloc(HEADER_LEN);
+  header.writeUInt8(type, 0);
+  header.writeUInt32BE(streamId, 1);
+  return Buffer.concat([header, payload]);
+}
+function decodeFrame(data) {
+  if (data.length < HEADER_LEN) throw new Error(`tunnel frame too short: ${data.length}`);
+  const type = data.readUInt8(0);
+  if (!KNOWN.has(type)) throw new Error(`unknown tunnel frame type: ${type}`);
+  return { type, streamId: data.readUInt32BE(1), payload: data.subarray(HEADER_LEN) };
+}
+
+// src/lib/tunnel-client.ts
+var FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([4008, 4009]);
+var MAX_BACKOFF_MS = 8e3;
+var STABLE_MS = 2e3;
+var TunnelClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.url = opts.url;
+  }
+  ws = null;
+  sockets = /* @__PURE__ */ new Map();
+  stopped = false;
+  backoffMs = 1e3;
+  metroWarned = false;
+  reconnectTimer = null;
+  stableTimer = null;
+  url;
+  connCount = 0;
+  debug(msg) {
+    this.opts.onDebug?.(msg);
+  }
+  start() {
+    this.connect();
+  }
+  stop() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.stableTimer) {
+      clearTimeout(this.stableTimer);
+      this.stableTimer = null;
+    }
+    this.stopped = true;
+    this.setState("closed");
+    this.ws?.close();
+    for (const s of this.sockets.values()) s.destroy();
+    this.sockets.clear();
+  }
+  setState(s) {
+    this.opts.onState?.(s);
+  }
+  connect() {
+    if (this.stopped) return;
+    this.setState("connecting");
+    const conn = ++this.connCount;
+    const openedAt = Date.now();
+    this.debug(`ws#${conn} connecting url=${this.url}`);
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    ws.on("open", () => {
+      this.backoffMs = 1e3;
+      this.debug(`ws#${conn} open`);
+      this.stableTimer = setTimeout(() => {
+        this.stableTimer = null;
+        if (this.ws === ws && !this.stopped) this.setState("connected");
+      }, STABLE_MS);
+    });
+    ws.on("message", (data) => this.onFrame(data));
+    ws.on("error", (err) => {
+      this.debug(`ws#${conn} error: ${err.message}`);
+    });
+    ws.on("close", (code, reason) => {
+      if (this.ws !== ws) this.debug(`ws#${conn} close code=${code} \u2014 SUPERSEDED socket`);
+      const heldMs = Date.now() - openedAt;
+      const why = reason?.length ? ` reason="${reason.toString()}"` : "";
+      this.debug(`ws#${conn} close code=${code}${why} heldMs=${heldMs}`);
+      if (this.stableTimer) {
+        clearTimeout(this.stableTimer);
+        this.stableTimer = null;
+      }
+      for (const s of this.sockets.values()) s.destroy();
+      this.sockets.clear();
+      if (this.stopped || FATAL_CLOSE_CODES.has(code)) {
+        this.stopped = true;
+        this.setState("closed");
+        return;
+      }
+      this.setState("reconnecting");
+      const delay = this.backoffMs;
+      this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);
+      this.debug(`ws#${conn} scheduling reconnect in ${delay}ms`);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        void this.reconnect();
+      }, delay);
+    });
+  }
+  async reconnect() {
+    if (this.stopped) return;
+    if (this.opts.refreshUrl) {
+      let fresh;
+      try {
+        fresh = await this.opts.refreshUrl();
+      } catch (err) {
+        this.debug(`refreshUrl threw: ${err.message}`);
+        fresh = null;
+      }
+      if (this.stopped) return;
+      if (!fresh) {
+        this.debug("refreshUrl returned null \u2014 session gone, closing");
+        this.stopped = true;
+        this.setState("closed");
+        return;
+      }
+      this.debug("refreshUrl ok \u2014 reconnecting with fresh url");
+      this.url = fresh;
+    }
+    this.connect();
+  }
+  onFrame(data) {
+    let frame;
+    try {
+      frame = decodeFrame(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    } catch {
+      return;
+    }
+    if (frame.type === FRAME_OPEN) return this.openStream(frame.streamId);
+    const sock = this.sockets.get(frame.streamId);
+    if (!sock) return;
+    if (frame.type === FRAME_DATA) sock.write(frame.payload);
+    else if (frame.type === FRAME_CLOSE) sock.destroy();
+  }
+  openStream(id) {
+    const sock = net.createConnection({ port: this.opts.metroPort, host: "127.0.0.1" });
+    this.sockets.set(id, sock);
+    sock.on("data", (chunk) => this.ws?.send(encodeFrame(FRAME_DATA, id, chunk)));
+    sock.on("error", () => {
+      if (!this.metroWarned) {
+        this.metroWarned = true;
+        this.setState("metro-unreachable");
+      }
+    });
+    sock.on("close", () => {
+      if (this.sockets.delete(id) && this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(encodeFrame(FRAME_CLOSE, id));
+      }
+    });
+  }
+};
+
+// src/lib/metro-check.ts
+async function checkMetro(port, timeoutMs = 1500) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/status`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const body = await res.text().catch(() => "");
+    return body.includes("packager-status:running") ? "running" : "listening";
+  } catch {
+    return "down";
+  }
+}
+
+// src/lib/dev-config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var DEV_PLATFORMS = ["ios", "android", "tvos", "androidtv"];
+var FILE = "vibeview.json";
+function isDevPlatform(p) {
+  return typeof p === "string" && DEV_PLATFORMS.includes(p);
+}
+function loadDevConfig(cwd) {
+  let raw;
+  try {
+    raw = readFileSync4(join2(cwd, FILE), "utf-8");
+  } catch {
+    return null;
+  }
+  const parsed = JSON.parse(raw);
+  if (!("platforms" in parsed) && typeof parsed.platform === "string") {
+    const legacy = parsed;
+    if (!isDevPlatform(legacy.platform)) {
+      throw new Error(
+        `vibeview.json: "platform" must be one of ${DEV_PLATFORMS.join(", ")}, got "${legacy.platform}"`
+      );
+    }
+    if (!legacy.appId || typeof legacy.appId !== "string") {
+      throw new Error('vibeview.json: "appId" is required \u2014 run `vibeview dev` to set it up');
+    }
+    return {
+      defaultPlatform: legacy.platform,
+      metroPort: legacy.metroPort,
+      platforms: {
+        [legacy.platform]: { appId: legacy.appId, deviceCategory: legacy.deviceCategory }
+      }
+    };
+  }
+  const cfg = parsed;
+  if (!isDevPlatform(cfg.defaultPlatform)) {
+    throw new Error(
+      `vibeview.json: "defaultPlatform" must be one of ${DEV_PLATFORMS.join(", ")}, got "${String(cfg.defaultPlatform)}"`
+    );
+  }
+  if (!cfg.platforms || typeof cfg.platforms !== "object") {
+    throw new Error(
+      'vibeview.json: "platforms" object is required \u2014 run `vibeview dev` to set it up'
+    );
+  }
+  for (const [key, entry] of Object.entries(cfg.platforms)) {
+    if (!isDevPlatform(key)) {
+      throw new Error(
+        `vibeview.json: unknown platform "${key}" (expected one of ${DEV_PLATFORMS.join(", ")})`
+      );
+    }
+    if (!entry || typeof entry.appId !== "string" || !entry.appId) {
+      throw new Error(`vibeview.json: platforms.${key}.appId is required`);
+    }
+  }
+  return cfg;
+}
+function saveDevConfig(cwd, cfg) {
+  writeFileSync2(join2(cwd, FILE), JSON.stringify(cfg, null, 2) + "\n");
+}
+
+// src/commands/dev.ts
+function findBlockingWarning(info) {
+  return (info.warnings ?? []).find((w) => w.includes("No debug build"));
+}
+async function pollUntilTunnelReady(api, sessionId, timeoutMs, intervalMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const info = await api.getSession(sessionId);
+    const blocking = findBlockingWarning(info);
+    if (blocking) throw new Error(blocking);
+    if (info.tunnel_url) return info;
+    if (info.status === "stopped" || info.status === "failed") {
+      throw new Error(`session ${info.status} before the tunnel came up`);
+    }
+    if (Date.now() > deadline) throw new Error("timed out waiting for the device to start");
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+var PLATFORM_DEVICE = {
+  ios: { deviceType: "ios", tv: false },
+  android: { deviceType: "android", tv: false },
+  tvos: { deviceType: "ios", tv: true },
+  androidtv: { deviceType: "android", tv: true }
+};
+function appsForPlatform(apps, platform) {
+  return apps.filter((a) => a.platform === platform);
+}
+async function ensureConfig(api, opts) {
+  const existing = loadDevConfig(process.cwd());
+  if (opts.platform && !isDevPlatform(opts.platform)) {
+    console.error(chalk10.red(`error: --platform must be one of ios, android, tvos, androidtv`));
+    process.exit(2);
+  }
+  const platform = opts.platform || existing?.defaultPlatform || await select({
+    message: "Platform to run on",
+    choices: [
+      { value: "ios", name: "iOS simulator" },
+      { value: "android", name: "Android emulator" },
+      { value: "tvos", name: "Apple TV simulator" },
+      { value: "androidtv", name: "Android TV emulator" }
+    ]
+  });
+  const isTv = PLATFORM_DEVICE[platform].tv;
+  if (isTv && opts.deviceCategory) {
+    console.error(
+      chalk10.red(`error: --device-category does not apply to ${platform} (always a tv device)`)
+    );
+    process.exit(2);
+  }
+  if (!isTv && opts.deviceCategory === "tv") {
+    console.error(chalk10.red(`error: use --platform tvos or --platform androidtv for TV devices`));
+    process.exit(2);
+  }
+  const entry = existing?.platforms?.[platform];
+  let appId = opts.app || entry?.appId;
+  if (!appId) {
+    const apps = appsForPlatform(await api.listApps(), platform);
+    if (apps.length === 0) {
+      console.error(
+        chalk10.red(`No ${platform} apps found \u2014 upload a debug build with \`vibeview upload-app\``)
+      );
+      process.exit(1);
+    }
+    appId = await select({
+      message: "Which uploaded app is your debug build? (upload one with `vibeview upload-app`)",
+      // Platform suffix dropped: the picker is already filtered to one platform
+      // (appsForPlatform), so `(ios)` on every row is redundant noise.
+      choices: apps.map((a) => ({ value: a.public_id, name: a.name }))
+    });
+  }
+  const deviceCategory = isTv ? "tv" : opts.deviceCategory || entry?.deviceCategory || "phone";
+  const metroPort = opts.metroPort ? parseInt(opts.metroPort, 10) : existing?.metroPort ?? 8081;
+  const cfg = {
+    defaultPlatform: platform,
+    metroPort,
+    platforms: {
+      ...existing?.platforms,
+      [platform]: { appId, deviceCategory: isTv ? void 0 : deviceCategory }
+    }
+  };
+  saveDevConfig(process.cwd(), cfg);
+  return { platform, appId, deviceCategory, metroPort };
+}
+async function dev(opts) {
+  const { token, baseUrl } = resolveAuth(opts);
+  console.error(chalk10.dim(`Using ${baseUrl}`));
+  const api = new ApiClient(baseUrl, token);
+  const cfg = await ensureConfig(api, opts);
+  const metroPort = cfg.metroPort ?? 8081;
+  const metro = await checkMetro(metroPort);
+  if (metro === "down") {
+    console.error(
+      chalk10.red(`error: Metro isn't running on localhost:${metroPort}.`) + `
+Start it in your project first (yarn start), then re-run vibeview dev.
+If Metro uses another port, pass --metro-port <port>.`
+    );
+    process.exit(1);
+  }
+  if (metro === "listening") {
+    console.error(
+      chalk10.yellow(
+        `\u26A0 something is listening on localhost:${metroPort} but it doesn't look like Metro \u2014 continuing anyway`
+      )
+    );
+  }
+  console.error(chalk10.dim(`Starting a ${cfg.platform} dev session for ${cfg.appId}...`));
+  const created = await api.createSession({
+    device_type: PLATFORM_DEVICE[cfg.platform].deviceType,
+    device_category: cfg.deviceCategory,
+    app_id: cfg.appId,
+    tunnel: true
+  });
+  const sessionId = created.session_id;
+  let stopping = false;
+  const stopSession = async (code) => {
+    if (stopping) return;
+    stopping = true;
+    tunnel?.stop();
+    console.error(chalk10.dim("\nStopping session..."));
+    await api.stopSession(sessionId).catch(() => {
+    });
+    process.exit(code);
+  };
+  process.on("SIGINT", () => void stopSession(0));
+  process.on("SIGTERM", () => void stopSession(0));
+  let tunnel = null;
+  try {
+    await api.startSession(sessionId);
+    const ready = await pollUntilTunnelReady(api, sessionId, 18e4);
+    for (const w of ready.warnings ?? []) {
+      console.error(chalk10.yellow(`\u26A0 ${w}`));
+    }
+    let everConnected = false;
+    let waitingPrinted = false;
+    tunnel = new TunnelClient({
+      url: ready.tunnel_url,
+      metroPort: cfg.metroPort ?? 8081,
+      // Re-mint the URL on each reconnect: the tunnel token has a ~1h TTL and
+      // a worker restart drops the proxy registration, so the original URL
+      // eventually goes stale. Every authorized GET /sessions/{id} re-signs a
+      // fresh tunnel token. Null (session stopped/failed) ends the tunnel.
+      refreshUrl: async () => {
+        const info = await api.getSession(sessionId);
+        if (info.status === "stopped" || info.status === "failed") return null;
+        return info.tunnel_url ?? null;
+      },
+      // --debug: dump raw tunnel lifecycle (close codes/reasons, reconnect
+      // scheduling, url refresh) to diagnose flapping. Timestamped so the
+      // drop→reconnect cadence is visible.
+      onDebug: opts.debug ? (msg) => console.error(chalk10.dim(`[tunnel ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`)) : void 0,
+      onState: (s) => {
+        if (s === "connected") {
+          everConnected = true;
+          console.error(chalk10.green("\u2713 tunnel connected \u2014 edit away, Fast Refresh is live"));
+        } else if (s === "reconnecting") {
+          if (!everConnected) {
+            if (!waitingPrinted) {
+              waitingPrinted = true;
+              console.error(
+                chalk10.dim("\u2026 waiting for the device to come up (tunnel not ready yet)")
+              );
+            }
+            return;
+          }
+          console.error(chalk10.yellow("\u2026 tunnel dropped, reconnecting"));
+        } else if (s === "metro-unreachable")
+          console.error(
+            chalk10.red(
+              `\u2717 can't reach Metro on localhost:${cfg.metroPort ?? 8081} \u2014 is it running? (yarn start)`
+            )
+          );
+        else if (s === "closed" && !stopping) {
+          console.error(chalk10.red("tunnel closed by server \u2014 session ended"));
+          void stopSession(1);
+        }
+      }
+    });
+    tunnel.start();
+    const webBase = opts.webUrl || process.env.VIBEVIEW_WEB_URL || baseUrl;
+    const pageUrl = `${webBase}/sandbox/${sessionId}`;
+    console.error(`
+  Watch and interact: ${chalk10.cyan(pageUrl)}
+  Ctrl-C to end the session.
+`);
+    if (opts.open !== false) await openBrowser(pageUrl).catch(() => {
+    });
+  } catch (err) {
+    console.error(chalk10.red(`error: ${err.message}`));
+    await stopSession(1);
+  }
+}
+
+// src/lib/formatters/devices.ts
+import chalk11 from "chalk";
+var HEADERS = ["DEVICE_ID", "NAME", "TYPE", "CATEGORY", "OS", "STATUS"];
+function formatDevicesHuman(devices) {
+  if (devices.length === 0) {
+    return "No devices registered.\n";
+  }
+  const rows = devices.map((d) => [
+    d.device_id,
+    d.name,
+    d.type,
+    d.category,
+    d.os_version,
+    d.status
+  ]);
+  const widths = HEADERS.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const fmt = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ").trimEnd();
+  const lines = [chalk11.bold(fmt(HEADERS))];
+  for (const row of rows.sort(rowSort)) {
+    const statusColored = row[5] === "available" ? chalk11.green(row[5]) : row[5] === "busy" ? chalk11.yellow(row[5]) : chalk11.dim(row[5]);
+    lines.push(fmt([row[0], row[1], row[2], row[3], row[4], statusColored]));
+  }
+  return lines.join("\n") + "\n";
+}
+function rowSort(a, b) {
+  return a[2].localeCompare(b[2]) || a[3].localeCompare(b[3]) || a[0].localeCompare(b[0]);
+}
+
+// src/commands/list-devices.ts
+async function listDevicesCommand(options) {
+  const { token, baseUrl } = resolveAuth(options);
+  const client = new ApiClient(baseUrl, token);
+  try {
+    const devices = await client.listDevices({
+      type: options.type,
+      category: options.category,
+      status: options.status
+    });
+    if (options.output === "json") {
+      process.stdout.write(JSON.stringify(devices, null, 2) + "\n");
+    } else {
+      process.stdout.write(formatDevicesHuman(devices));
+    }
+    process.exit(EXIT_PASS);
+  } catch (err) {
+    process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(EXIT_INFRA_ERROR);
+  }
+}
+
+// src/lib/metadata.ts
+import { readFileSync as readFileSync5 } from "fs";
+var MAX_METADATA_BYTES = 16384;
+var MAX_METADATA_DEPTH = 4;
+function measureDepth(value, current = 1) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) return current;
+    return Math.max(...value.map((v) => measureDepth(v, current + 1)));
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.values(value);
+    if (entries.length === 0) return current;
+    return Math.max(...entries.map((v) => measureDepth(v, current + 1)));
+  }
+  return current - 1;
+}
+function parseMetadata(raw) {
+  if (raw === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`failed to parse --metadata JSON: ${e.message}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("metadata must be a JSON object at the top level");
+  }
+  const serialized = JSON.stringify(parsed);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_METADATA_BYTES) {
+    throw new Error(`metadata exceeds max size of ${MAX_METADATA_BYTES} bytes`);
+  }
+  const depth = measureDepth(parsed);
+  if (depth > MAX_METADATA_DEPTH) {
+    throw new Error(`metadata nesting depth ${depth} exceeds max of ${MAX_METADATA_DEPTH}`);
+  }
+  return parsed;
+}
+function readMetadataFile(path) {
+  let raw;
+  try {
+    raw = readFileSync5(path, "utf8");
+  } catch (e) {
+    throw new Error(`failed to read --metadata-file ${path}: ${e.message}`);
+  }
+  const parsed = parseMetadata(raw);
+  if (parsed === void 0) {
+    throw new Error(`--metadata-file ${path} is empty`);
+  }
+  return parsed;
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+process.on("unhandledRejection", (reason) => {
+  if (reason instanceof Error && reason.name === "ExitPromptError") {
+    process.exit(130);
+  }
+  throw reason;
+});
+var DEVICE_CATEGORIES = ["phone", "tablet", "tv"];
+function parseDeviceCategory(value) {
+  if (DEVICE_CATEGORIES.includes(value)) {
+    return value;
+  }
+  process.stderr.write(
+    `error: --device-category must be one of: ${DEVICE_CATEGORIES.join(", ")} (got "${value}")
+`
+  );
+  process.exit(2);
+}
+function resolveMetadata(opts) {
+  if (opts.metadata && opts.metadataFile) {
+    process.stderr.write("error: --metadata cannot be combined with --metadata-file\n");
+    process.exit(2);
+  }
+  try {
+    if (opts.metadataFile) {
+      return readMetadataFile(opts.metadataFile);
+    }
+    if (opts.metadata) {
+      return parseMetadata(opts.metadata);
+    }
+    return void 0;
+  } catch (e) {
+    process.stderr.write(`error: ${e.message}
+`);
+    process.exit(2);
+  }
+}
+var program = new Command();
+program.name("vibeview").description("VibeView CLI -- run mobile tests from CI/CD pipelines").version(pkg.version);
+program.command("run-suite <suite-id>").description("Run all test cases in a suite").option("--token <token>", "API token (or set VIBEVIEW_API_TOKEN)").option("--base-url <url>", "VibeView server URL (or set VIBEVIEW_BASE_URL)").option("--output <format>", "Output format: human, json, junit", "human").option("--verbose", "Show per-case breakdown", false).option("--timeout <seconds>", "Max wait time in seconds", "300").option("--commit-sha <sha>", "Git commit SHA for GitHub status checks").option("--model <model>", "AI model to use").option("--provider <provider>", "AI provider").option("--mode <mode>", "Execution mode: hybrid, ai, replay").option(
+  "--device-category <category>",
+  "Device category: phone, tablet, tv (default: phone when --device is not set)",
+  parseDeviceCategory
+).option(
+  "--device <device_id>",
+  "Pin run to a specific device (use `vibeview list-devices` to find one). Conflicts with --device-category."
+).option("--build <id>", "Specific AppBuild id to run against (defaults to latest)").option("--metadata <json>", "JSON object passed through to webhooks (e.g. PR context)").option("--metadata-file <path>", "Read JSON object from a file (use for nested JSON in CI)").action((suiteId, opts) => {
+  if (opts.device && opts.deviceCategory) {
+    process.stderr.write("error: --device cannot be combined with --device-category\n");
+    process.exit(2);
+  }
+  const metadata = resolveMetadata(opts);
+  return runSuite(suiteId, {
+    ...opts,
+    metadata,
+    timeout: parseInt(opts.timeout, 10),
+    build: opts.build ? parseInt(opts.build, 10) : void 0
+  });
+});
+program.command("run-suites").description("Run all suites matching a tag filter").requiredOption(
+  "--tag <tag>",
+  "Tag to filter by (repeatable)",
+  (val, prev = []) => [...prev, val],
+  []
+).option("--match <mode>", "any (default) or all", "any").option(
+  "--platform <platform>",
+  "Filter matched suites to one platform: ios, android, tvos, androidtv (default: no filter)"
+).option("--token <token>", "API token (or set VIBEVIEW_API_TOKEN)").option("--base-url <url>", "VibeView server URL (or set VIBEVIEW_BASE_URL)").option("--output <format>", "Output format: human, json, junit", "human").option("--verbose", "Show per-suite progress", false).option("--timeout <seconds>", "Per-suite timeout, capped at 2 hours total", "300").option("--commit-sha <sha>", "Git commit SHA propagated to every SuiteRun").option("--model <model>", "AI model").option("--provider <provider>", "AI provider").option("--mode <mode>", "Execution mode: hybrid, ai, replay").option(
+  "--device-category <category>",
+  "Device category: phone, tablet, tv (default: phone when --device is not set)",
+  parseDeviceCategory
+).option(
+  "--device <device_id>",
+  "Pin run to a specific device (use `vibeview list-devices` to find one). Conflicts with --device-category."
+).option("--build <id>", "AppBuild id (validated against every matched suite)").option("--metadata <json>", "JSON object passed through to webhooks (e.g. PR context)").option("--metadata-file <path>", "Read JSON object from a file (use for nested JSON in CI)").action((opts) => {
+  if (opts.device && opts.deviceCategory) {
+    process.stderr.write("error: --device cannot be combined with --device-category\n");
+    process.exit(2);
+  }
+  const metadata = resolveMetadata(opts);
+  return runSuites({
+    ...opts,
+    metadata,
+    timeout: parseInt(opts.timeout, 10),
+    build: opts.build ? parseInt(opts.build, 10) : void 0
+  });
+});
+program.command("run-test <test-id>").description("Run a single test case").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json, junit", "human").option("--verbose", "Show step details", false).option("--timeout <seconds>", "Max wait time in seconds", "300").option("--commit-sha <sha>", "Git commit SHA for GitHub status checks").option("--model <model>", "AI model to use").option("--provider <provider>", "AI provider").option("--mode <mode>", "Execution mode: hybrid, ai, replay").option(
+  "--device-category <category>",
+  "Device category: phone, tablet, tv (default: phone when --device is not set)",
+  parseDeviceCategory
+).option(
+  "--device <device_id>",
+  "Pin run to a specific device (use `vibeview list-devices` to find one). Conflicts with --device-category."
+).option("--build <id>", "Specific AppBuild id to run against (defaults to latest)").option("--metadata <json>", "JSON object passed through to webhooks (e.g. PR context)").option("--metadata-file <path>", "Read JSON object from a file (use for nested JSON in CI)").action((testId, opts) => {
+  if (opts.device && opts.deviceCategory) {
+    process.stderr.write("error: --device cannot be combined with --device-category\n");
+    process.exit(2);
+  }
+  const metadata = resolveMetadata(opts);
+  return runTest(testId, {
+    ...opts,
+    metadata,
+    timeout: parseInt(opts.timeout, 10),
+    build: opts.build ? parseInt(opts.build, 10) : void 0
+  });
+});
+program.command("list-suites").description("List available test suites").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json", "human").option(
+  "--tag <tag>",
+  "Filter suites by tag (repeatable)",
+  (val, prev = []) => [...prev, val],
+  []
+).option("--match <mode>", "When multiple --tag flags: any (default) or all", "any").action((opts) => listSuites(opts));
+program.command("list-apps").description("List apps in your organization").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json", "human").action((opts) => listApps(opts));
+program.command("list-devices").description("List devices registered with the platform (filterable by type and category)").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json", "human").option("--type <type>", "Filter by device type: ios, android").option("--category <category>", "Filter by category: phone, tablet, tv").option("--status <status>", "Filter by status: available, busy, offline").action((opts) => listDevicesCommand(opts));
+program.command("upload-app <file>").description("Upload an app build (zipped simulator .app for iOS, .apk for Android)").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json", "human").option("--name <name>", "App name (auto-detected if not provided)").action((file, opts) => uploadApp(file, opts));
+program.command("create-test [name]").description("Create a standalone AI test case").option("--token <token>", "API token").option("--base-url <url>", "VibeView server URL").option("--output <format>", "Output format: human, json", "human").option("--app <app>", "App ID (public_id) or package name (requires --platform)").option("--platform <platform>", "Platform (ios, android) when using package name for --app").option("--steps <json>", "Test steps as inline JSON array").option("--steps-file <path>", "Path to JSON file containing test steps").option("--context <text>", "Additional context for AI test execution").option("--test-name <name>", "Test case name (alternative to positional arg)").action((name, opts) => createTest({ ...opts, testName: name || opts.testName || "CLI Test" }));
+program.command("login").description("Log in to VibeView (interactive)").option("--base-url <url>", "VibeView server URL").action((opts) => login(opts));
+program.command("dev").description("Stream your app from the fleet with live Metro hot-reload (RN debug builds)").option("--token <token>", "API token (or set VIBEVIEW_API_TOKEN)").option("--base-url <url>", "VibeView server URL (or set VIBEVIEW_BASE_URL)").option("--web-url <url>", "Dashboard URL if different from --base-url (local dev)").option(
+  "--platform <platform>",
+  "ios, android, tvos, or androidtv (first run is interactive otherwise)"
+).option("--app <app_id>", "Uploaded debug build to run (see `vibeview list-apps`)").option("--metro-port <port>", "Local Metro port (default: 8081, remembered in vibeview.json)").option(
+  "--device-category <category>",
+  "phone or tablet (default: phone; TV platforms always use tv)",
+  parseDeviceCategory
+).option("--no-open", "Do not open the browser automatically").option("--debug", "Log raw tunnel lifecycle events (close codes, reconnects) for diagnostics").action((opts) => dev(opts));
+program.parse();
+//# sourceMappingURL=cli.js.map