vibeview 0.11.0 → 0.12.1

package/dist/{chunk-4UGLSIZM.js → chunk-NFFLJNUI.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
   ApiClient,
+  createSpinner,
   loadConfig,
   resolveAuth,
   uploadAppBuild
-} from "./chunk-AG3RZCPW.js";
+} from "./chunk-OHRTLUBD.js";
 
 // src/lib/dev-state.ts
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
@@ -72,6 +73,7 @@ function clearDevState(cwd) {
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2 } from "path";
 var DEV_PLATFORMS = ["ios", "android", "tvos", "androidtv", "roku"];
+var ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var PLATFORM_NEEDS_METRO = {
   ios: true,
   android: true,
@@ -165,6 +167,26 @@ function loadDevConfig(cwd) {
   }
   return cfg;
 }
+function validateBuildEnv(env, platformKey) {
+  if (env === void 0) return;
+  if (typeof env !== "object" || env === null || Array.isArray(env)) {
+    throw new Error(
+      `vibeview.json: platforms.${platformKey}.build.env must be an object of string values`
+    );
+  }
+  for (const [envKey, envValue] of Object.entries(env)) {
+    if (typeof envValue !== "string") {
+      throw new Error(
+        `vibeview.json: platforms.${platformKey}.build.env must be an object of string values`
+      );
+    }
+    if (!ENV_KEY_RE.test(envKey)) {
+      throw new Error(
+        `vibeview.json: platforms.${platformKey}.build.env key "${envKey}" is not a valid environment variable name (must match ${ENV_KEY_RE})`
+      );
+    }
+  }
+}
 function saveDevConfig(cwd, cfg) {
   writeFileSync2(join2(cwd, FILE), JSON.stringify(cfg, null, 2) + "\n");
 }
@@ -198,7 +220,7 @@ function buildSavedConfig(input2) {
       [platform]: {
         appId,
         deviceCategory: isTv ? void 0 : deviceCategory,
-        ...existing?.platforms?.[platform]?.build ? { build: existing.platforms[platform].build } : {},
+        ...existing?.platforms?.[platform]?.build ? { build: { ...existing.platforms[platform].build } } : {},
         ...isFirstRun && firstRunBuild ? { build: firstRunBuild } : {},
         // Never invented — absent means "no extra ignores", and first-run
         // setup does not ask for it. Only ever carried forward.
@@ -224,7 +246,7 @@ async function checkMetro(port, timeoutMs = 1500) {
 }
 
 // src/commands/build.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createInterface } from "readline";
 import { select as select2 } from "@inquirer/prompts";
 import chalk from "chalk";
@@ -436,7 +458,187 @@ async function promptMetroCommand(cwd, platform) {
   return input({ message: "Metro command", required: true });
 }
 
+// src/lib/source-pack.ts
+import { execFile, spawn } from "child_process";
+import { lstatSync, mkdtempSync as mkdtempSync2, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+import ignore from "ignore";
+var NotAGitRepoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotAGitRepoError";
+  }
+};
+var SourceTooLargeError = class extends Error {
+  constructor(message, largest) {
+    super(message);
+    this.largest = largest;
+    this.name = "SourceTooLargeError";
+  }
+};
+var FORCE_EXCLUDE_PREFIXES = ["node_modules/", "ios/Pods/", ".git/"];
+function isForceExcluded(relPath) {
+  for (const prefix of FORCE_EXCLUDE_PREFIXES) {
+    if (relPath.startsWith(prefix) || relPath.includes(`/${prefix}`)) return true;
+  }
+  return false;
+}
+async function listSourceFiles(projectRoot) {
+  const stdout = await runGitLsFiles(projectRoot);
+  const rawPaths = stdout.length ? stdout.split("\0").filter((p) => p.length > 0) : [];
+  let filtered = rawPaths;
+  const vvignorePath = join5(projectRoot, ".vvignore");
+  if (statOrNull(vvignorePath)?.isFile()) {
+    const ig = ignore().add(readFileSync4(vvignorePath, "utf-8"));
+    filtered = filtered.filter((p) => !ig.ignores(p));
+  }
+  const result = [];
+  for (const relPath of filtered) {
+    if (isForceExcluded(relPath)) continue;
+    const st = statOrNull(join5(projectRoot, relPath));
+    if (!st) continue;
+    result.push(relPath);
+  }
+  return result;
+}
+function statOrNull(path) {
+  try {
+    return lstatSync(path);
+  } catch {
+    return null;
+  }
+}
+function runGitLsFiles(projectRoot) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (c) => stdoutChunks.push(c));
+    child.stderr.on("data", (c) => stderrChunks.push(c));
+    child.on("error", (err) => {
+      reject(
+        new NotAGitRepoError(
+          `failed to run git in ${projectRoot}: ${err.message} \u2014 is git installed and on PATH?`
+        )
+      );
+    });
+    child.on("close", (code) => {
+      const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+      if (code !== 0) {
+        if (/not a git repository/i.test(stderr)) {
+          reject(new NotAGitRepoError(`${projectRoot} is not a git repository`));
+          return;
+        }
+        reject(new Error(`git ls-files failed (exit ${code}) in ${projectRoot}: ${stderr.trim()}`));
+        return;
+      }
+      resolve(Buffer.concat(stdoutChunks).toString("utf-8"));
+    });
+  });
+}
+var DEFAULT_CAP_BYTES = 2 * 1024 * 1024 * 1024;
+async function packSource(projectRoot, files, opts = {}) {
+  const capBytes = opts.capBytes ?? DEFAULT_CAP_BYTES;
+  let totalBytes = 0;
+  const sized = [];
+  for (const relPath of files) {
+    const bytes = lstatSync(join5(projectRoot, relPath)).size;
+    totalBytes += bytes;
+    sized.push({ path: relPath, bytes });
+  }
+  if (totalBytes > capBytes) {
+    const largest = sized.slice().sort((a, b) => b.bytes - a.bytes).slice(0, 5);
+    throw new SourceTooLargeError(
+      `source exceeds the ${formatBytes(capBytes)} pack limit (${formatBytes(totalBytes)} across ${files.length} files)`,
+      largest
+    );
+  }
+  const tmpDir = mkdtempSync2(join5(tmpdir2(), "vibeview-source-pack-"));
+  const cleanup = () => rmSync3(tmpDir, { recursive: true, force: true });
+  try {
+    const supportsNull = await probeTarNullSupport();
+    const tarPath = join5(tmpDir, "source.tgz");
+    if (supportsNull) {
+      const listPath = join5(tmpDir, "files.list");
+      writeFileSync3(listPath, files.map((f) => `${f}\0`).join(""));
+      await runTar(["-czf", tarPath, "-C", projectRoot, "--null", "-T", listPath]);
+    } else {
+      const badName = files.find((f) => f.includes("\n"));
+      if (badName) {
+        throw new Error(
+          `cannot pack source: filename contains a newline (${JSON.stringify(badName)}) and the installed tar doesn't support --null -T; rename the file or install a tar that supports --null`
+        );
+      }
+      const listPath = join5(tmpDir, "files.list");
+      writeFileSync3(listPath, files.map((f) => `${f}
+`).join(""));
+      await runTar(["-czf", tarPath, "-C", projectRoot, "-T", listPath]);
+    }
+    const sizeBytes = statSync3(tarPath).size;
+    return { tarPath, sizeBytes, cleanup };
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+}
+function formatBytes(bytes) {
+  const mb = bytes / (1024 * 1024);
+  if (mb >= 1024) return `${(mb / 1024).toFixed(2)} GiB`;
+  return `${mb.toFixed(1)} MiB`;
+}
+var nullSupportCache = null;
+function probeTarNullSupport() {
+  if (!nullSupportCache) {
+    nullSupportCache = new Promise((resolve) => {
+      const tmp = mkdtempSync2(join5(tmpdir2(), "vibeview-tar-probe-"));
+      const listPath = join5(tmp, "empty.list");
+      writeFileSync3(listPath, "");
+      const out = join5(tmp, "probe.tgz");
+      execFile("tar", ["-czf", out, "-C", tmp, "--null", "-T", listPath], (err) => {
+        rmSync3(tmp, { recursive: true, force: true });
+        resolve(!err);
+      });
+    });
+  }
+  return nullSupportCache;
+}
+function runTar(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("tar", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, COPYFILE_DISABLE: "1" }
+    });
+    const stderrChunks = [];
+    child.stderr.on("data", (c) => stderrChunks.push(c));
+    child.on("error", (err) => {
+      reject(new Error(`failed to run tar: ${err.message} \u2014 is tar installed and on PATH?`));
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        reject(new Error(`tar failed (exit ${code}): ${stderr}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
 // src/commands/build.ts
+var CLOUD_PLATFORMS = ["ios", "android", "tvos", "androidtv"];
+function isCloudPlatform(p) {
+  return CLOUD_PLATFORMS.includes(p);
+}
+var BuildFailError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BuildFailError";
+  }
+};
 var TAIL_LINES = 30;
 async function runBuildForPlatform(cwd, platform, build, opts, log, deps = { upload: uploadAppBuild }) {
   const tail = await runShell(build.command, cwd, log);
@@ -463,7 +665,7 @@ async function runBuildForPlatform(cwd, platform, build, opts, log, deps = { upl
 }
 function runShell(command, cwd, log) {
   return new Promise((resolve) => {
-    const child = spawn(command, { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn2(command, { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
     const lines = [];
     const onLine = (line) => {
       lines.push(line);
@@ -476,9 +678,7 @@ function runShell(command, cwd, log) {
     child.on("error", () => resolve({ code: 127, lines }));
   });
 }
-async function buildCommand(opts) {
-  const cwd = process.cwd();
-  const cfg = loadDevConfig(cwd);
+async function resolveBarePlatform(cwd, cfg, opts) {
   if (opts.platform && !isDevPlatform(opts.platform)) {
     console.error(chalk.red(`error: --platform must be one of ${DEV_PLATFORMS.join(", ")}`));
     process.exit(2);
@@ -491,35 +691,42 @@ async function buildCommand(opts) {
         "no platform: pass --platform or run `vibeview dev` once to set up vibeview.json",
         "config_required"
       );
-      return;
     }
     platform = await select2({
       message: "Platform to run on",
       choices: platformChoices(cwd)
     });
   }
-  let build = cfg?.platforms?.[platform]?.build;
-  if (!build) {
-    if (opts.json || !process.stdin.isTTY) {
-      fail(
-        opts,
-        `no build config for ${platform}: add platforms.${platform}.build {command, artifact} to vibeview.json`,
-        "config_required"
-      );
-      return;
-    }
-    const answered = await promptBuildConfig(cwd, platform);
-    if (!answered) {
-      fail(opts, "build config is required to run vibeview build", "config_required");
+  return platform;
+}
+async function buildCommand(opts, cloudDeps) {
+  const cwd = process.cwd();
+  const cfg = loadDevConfig(cwd);
+  try {
+    if (opts.cloud) {
+      await runCloudBuildCommand(cwd, cfg, opts, cloudDeps);
       return;
     }
-    build = answered;
-    if (cfg?.platforms?.[platform]) {
-      cfg.platforms[platform].build = build;
-      saveDevConfig(cwd, cfg);
+    const platform = await resolveBarePlatform(cwd, cfg, opts);
+    let build = cfg?.platforms?.[platform]?.build;
+    if (!build) {
+      if (opts.json || !process.stdin.isTTY) {
+        fail(
+          opts,
+          `no build config for ${platform}: add platforms.${platform}.build {command, artifact} to vibeview.json`,
+          "config_required"
+        );
+      }
+      const answered = await promptBuildConfig(cwd, platform);
+      if (!answered) {
+        fail(opts, "build config is required to run vibeview build", "config_required");
+      }
+      build = answered;
+      if (cfg?.platforms?.[platform]) {
+        cfg.platforms[platform].build = build;
+        saveDevConfig(cwd, cfg);
+      }
     }
-  }
-  try {
     const result = await runBuildForPlatform(
       cwd,
       platform,
@@ -549,17 +756,474 @@ async function buildCommand(opts) {
       );
     }
   } catch (err) {
-    fail(opts, err instanceof Error ? err.message : String(err));
+    if (!(err instanceof BuildFailError)) {
+      printFailure(opts, err instanceof Error ? err.message : String(err));
+    }
+    process.exitCode = 1;
   }
 }
-function fail(opts, message, code) {
+function printFailure(opts, message, code) {
   if (opts.json) console.log(JSON.stringify({ event: "error", code, message }));
   console.error(chalk.red(`error: ${message}`));
-  process.exit(1);
+}
+function fail(opts, message, code) {
+  printFailure(opts, message, code);
+  throw new BuildFailError(message);
+}
+function emitCloud(json, evt) {
+  if (json) console.log(JSON.stringify(evt));
+}
+async function resolveCloudPlatforms(cwd, cfg, opts) {
+  if (opts.platform === "all") {
+    const configured = Object.entries(cfg?.platforms ?? {});
+    const withBuild = configured.filter(([p, entry]) => isCloudPlatform(p) && entry?.build);
+    if (withBuild.length === 0) {
+      fail(
+        opts,
+        `--platform all: ${describeAllExclusions(configured)} \u2014 add platforms.<platform>.build {command, artifact} to vibeview.json`,
+        "config_required"
+      );
+    }
+    return withBuild.map(([p]) => p);
+  }
+  const platform = opts.platform ? validateExplicitPlatform(opts.platform) : await resolveBarePlatform(cwd, cfg, opts);
+  requireCloudCapable(opts, platform);
+  requireBuildBlock(opts, cfg, platform);
+  return [platform];
+}
+function validateExplicitPlatform(raw) {
+  if (!isDevPlatform(raw)) {
+    console.error(
+      chalk.red(`error: --platform must be one of ${DEV_PLATFORMS.join(", ")}, or "all"`)
+    );
+    process.exit(2);
+  }
+  return raw;
+}
+function requireCloudCapable(opts, platform) {
+  if (!isCloudPlatform(platform)) {
+    fail(
+      opts,
+      `cloud builds don't support ${platform} \u2014 pass one of ${CLOUD_PLATFORMS.join(", ")}`
+    );
+  }
+}
+function requireBuildBlock(opts, cfg, platform) {
+  if (!cfg?.platforms?.[platform]?.build) {
+    fail(
+      opts,
+      `no build config for ${platform}: add platforms.${platform}.build {command, artifact} to vibeview.json`,
+      "config_required"
+    );
+  }
+}
+function describeAllExclusions(configured) {
+  if (configured.length === 0) return "no platforms are configured";
+  const unsupported = configured.filter(([p]) => !isCloudPlatform(p)).map(([p]) => p);
+  const missingBuild = configured.filter(([p, entry]) => isCloudPlatform(p) && !entry?.build).map(([p]) => p);
+  const parts = [];
+  if (unsupported.length > 0) {
+    parts.push(
+      `${unsupported.join(", ")} ${unsupported.length === 1 ? "isn't" : "aren't"} supported for cloud builds`
+    );
+  }
+  if (missingBuild.length > 0) {
+    parts.push(
+      `${missingBuild.join(", ")} ${missingBuild.length === 1 ? "has" : "have"} no build block`
+    );
+  }
+  return parts.join("; ");
+}
+var POLL_INTERVAL_MS = 2e3;
+var QUEUED_POLL_INTERVAL_MS = 1e4;
+function nextPollDelayMs(pendingStatuses, baseMs, queuedMs) {
+  if (pendingStatuses.length > 0 && pendingStatuses.every((s) => s === "queued")) {
+    return queuedMs;
+  }
+  return baseMs;
+}
+var POLL_SAFETY_MARGIN_MS = 10 * 60 * 1e3;
+function runningCapDeadline(startedAt, timeoutS) {
+  return startedAt + timeoutS * 1e3 + POLL_SAFETY_MARGIN_MS;
+}
+var DEFAULT_QUEUE_WAIT_MS = 30 * 60 * 1e3;
+function queueWaitMs() {
+  const raw = process.env.VIBEVIEW_QUEUE_WAIT_MS;
+  if (!raw) return DEFAULT_QUEUE_WAIT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_QUEUE_WAIT_MS;
+}
+function defaultCloudBuildDeps(client) {
+  return {
+    listSourceFiles,
+    packSource,
+    createCloudBuilds: client.createCloudBuilds.bind(client),
+    getCloudBuildLogs: client.getCloudBuildLogs.bind(client),
+    getCloudBuild: client.getCloudBuild.bind(client),
+    downloadCloudBuildArtifact: client.downloadCloudBuildArtifact.bind(client)
+  };
+}
+function formatMB(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+function formatDuration(startedAt, finishedAt) {
+  if (!startedAt || !finishedAt) return null;
+  const ms = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return null;
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatCost(costMicro) {
+  return `$${(costMicro / 1e6).toFixed(2)}`;
+}
+async function runCloudBuildCommand(cwd, cfg, opts, deps) {
+  const platforms = await resolveCloudPlatforms(cwd, cfg, opts);
+  for (const p of platforms) {
+    try {
+      validateBuildEnv(cfg?.platforms?.[p]?.build?.env, p);
+    } catch (err) {
+      fail(opts, err instanceof Error ? err.message : String(err));
+    }
+  }
+  const { token, baseUrl } = resolveAuth(opts);
+  const client = new ApiClient(baseUrl, token);
+  const d = deps ?? defaultCloudBuildDeps(client);
+  let cleanupTar;
+  try {
+    let files;
+    try {
+      files = await d.listSourceFiles(cwd);
+    } catch (err) {
+      if (err instanceof NotAGitRepoError) {
+        fail(
+          opts,
+          `${err.message} \u2014 cloud builds pack your project source via git; run this from inside a git repository`
+        );
+      }
+      throw err;
+    }
+    const packSpinner = !opts.json ? createSpinner(`packing source (${files.length} files)`) : null;
+    packSpinner?.start();
+    let tarPath;
+    let sizeBytes;
+    try {
+      const packed = await d.packSource(cwd, files);
+      tarPath = packed.tarPath;
+      sizeBytes = packed.sizeBytes;
+      cleanupTar = packed.cleanup;
+    } catch (err) {
+      packSpinner?.stop();
+      if (err instanceof SourceTooLargeError) {
+        const offenders = err.largest.map((f) => `  ${f.path} (${formatMB(f.bytes)} MB)`).join("\n");
+        fail(opts, `${err.message}
+Largest files:
+${offenders}`);
+      }
+      throw err;
+    }
+    packSpinner?.succeed(`packed source (${files.length} files, ${formatMB(sizeBytes)} MB)`);
+    const manifestEntries = platforms.map((p) => {
+      const entry = cfg.platforms[p];
+      const build = entry.build;
+      return {
+        platform: p,
+        app_public_id: entry.appId,
+        command: build.command,
+        artifact_path: build.artifact,
+        ...build.env ? { env: build.env } : {}
+      };
+    });
+    const uploadSpinner = !opts.json ? createSpinner("uploading source...") : null;
+    uploadSpinner?.start();
+    let created;
+    try {
+      const resp = await d.createCloudBuilds({ builds: manifestEntries }, tarPath);
+      created = resp.builds;
+    } catch (err) {
+      uploadSpinner?.stop();
+      const message = err instanceof Error ? err.message : String(err);
+      fail(opts, message);
+    }
+    uploadSpinner?.succeed(`uploaded \u2014 ${created.length} build(s) submitted`);
+    for (const b of created) {
+      emitCloud(opts.json, { event: "build_created", id: b.id, platform: b.platform });
+    }
+    if (!opts.json) {
+      for (const b of created) {
+        console.error(`  ${chalk.cyan(b.id)}  ${chalk.dim(`[${b.platform}]`)}`);
+      }
+    }
+    const shouldWait = opts.wait !== false || opts.download;
+    if (!shouldWait) {
+      process.exitCode = 0;
+      return;
+    }
+    const finished = await waitForCloudBuilds(created, opts, d);
+    let downloadFailed = false;
+    if (opts.download) {
+      for (const b of finished.values()) {
+        if (b.status !== "succeeded") continue;
+        try {
+          const result = await d.downloadCloudBuildArtifact(b.id, cwd);
+          emitCloud(opts.json, {
+            event: "artifact_saved",
+            id: b.id,
+            filename: result.filename,
+            path: result.path
+          });
+          if (!opts.json) {
+            console.error(chalk.green(`\u2713 saved ${result.filename}`));
+          }
+        } catch (err) {
+          downloadFailed = true;
+          const message = err instanceof Error ? err.message : String(err);
+          emitCloud(opts.json, {
+            event: "error",
+            message: `error downloading ${b.id}: ${message}`
+          });
+          if (!opts.json) console.error(chalk.red(`error downloading ${b.id}: ${message}`));
+        }
+      }
+    }
+    const allSucceeded = Array.from(finished.values()).every((b) => b.status === "succeeded");
+    process.exitCode = allSucceeded && !downloadFailed ? 0 : 1;
+  } finally {
+    cleanupTar?.();
+  }
+}
+var BUILD_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "canceled",
+  "timed_out",
+  "infra_failed"
+]);
+var MAX_CONSECUTIVE_POLL_FAILURES = 5;
+async function waitForCloudBuilds(builds, opts, deps) {
+  const now = deps.now ?? Date.now;
+  const pollIntervalMs = deps.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const queuedPollIntervalMs = deps.queuedPollIntervalMs ?? (deps.pollIntervalMs !== void 0 ? pollIntervalMs : QUEUED_POLL_INTERVAL_MS);
+  const multi = builds.length > 1;
+  const state = new Map(builds.map((b) => [b.id, b]));
+  const offsets = new Map(builds.map((b) => [b.id, 0]));
+  const failures = new Map(builds.map((b) => [b.id, 0]));
+  const finalized = /* @__PURE__ */ new Set();
+  const abandoned = /* @__PURE__ */ new Set();
+  const pollAbandoned = /* @__PURE__ */ new Set();
+  const transitions = new Map(
+    builds.map((b) => [b.id, newTransitionState()])
+  );
+  let lastError;
+  const runningStartedAt = /* @__PURE__ */ new Map();
+  const queueStartedAt = new Map(builds.map((b) => [b.id, now()]));
+  const queueCapMs = queueWaitMs();
+  const waitStartedAt = now();
+  const maxTimeoutMs = Math.max(0, ...builds.map((b) => b.timeout_s * 1e3));
+  const initialBackstopDeadline = waitStartedAt + queueCapMs + maxTimeoutMs + POLL_SAFETY_MARGIN_MS;
+  const backstopDeadlineFor = (id, timeoutS) => {
+    const startedAt = runningStartedAt.get(id);
+    if (startedAt === void 0) return initialBackstopDeadline;
+    return Math.max(initialBackstopDeadline, runningCapDeadline(startedAt, timeoutS));
+  };
+  const printLine = (id, platform, line) => {
+    const prefix = multi ? `[${platform}] ` : "";
+    if (!opts.json) console.error(prefix + line);
+  };
+  const stillWaiting = () => Array.from(state.values()).some((b) => !finalized.has(b.id) && !abandoned.has(b.id));
+  const buildDeadline = (build) => {
+    const startedAt = runningStartedAt.get(build.id);
+    if (startedAt === void 0) return null;
+    return runningCapDeadline(startedAt, build.timeout_s);
+  };
+  const giveUpLocally = (id, message) => {
+    abandoned.add(id);
+    emitCloud(opts.json, { event: "error", message });
+    if (!opts.json) console.error(chalk.red(message));
+  };
+  const pollAndProcess = async (build) => {
+    const offset = offsets.get(build.id) ?? 0;
+    const logs = await deps.getCloudBuildLogs(build.id, offset);
+    const updated = { ...build, status: logs.status };
+    state.set(build.id, updated);
+    if (logs.status === "running" && !runningStartedAt.has(build.id)) {
+      runningStartedAt.set(build.id, now());
+    }
+    offsets.set(build.id, logs.offset);
+    const transitionState = transitions.get(build.id);
+    printTransition(build.id, build.platform, logs.status, transitionState, opts.json, printLine);
+    if (logs.content) {
+      emitCloud(opts.json, { event: "build_log", id: build.id, content: logs.content });
+      for (const line of logs.content.split("\n")) {
+        if (line.length === 0) continue;
+        printLine(build.id, build.platform, line);
+      }
+    }
+    if (BUILD_TERMINAL_STATUSES.has(logs.status)) {
+      const final = await fetchFinalSummary(build.id, updated, deps);
+      state.set(build.id, final);
+      if (!opts.json) {
+        printOutcomeLine(final, multi);
+      }
+      emitCloud(opts.json, {
+        event: "build_finished",
+        id: final.id,
+        status: final.status,
+        cost_micro: final.cost_micro,
+        error_summary: final.error_summary
+      });
+      finalized.add(build.id);
+    }
+    failures.set(build.id, 0);
+    return logs.status;
+  };
+  const finalPollBeforeGivingUp = async (build) => {
+    try {
+      const status = await pollAndProcess(build);
+      return BUILD_TERMINAL_STATUSES.has(status) ? "terminal" : "nonterminal";
+    } catch {
+      return "poll_failed";
+    }
+  };
+  while (stillWaiting()) {
+    for (const build of state.values()) {
+      if (abandoned.has(build.id)) continue;
+      if (finalized.has(build.id)) continue;
+      if (BUILD_TERMINAL_STATUSES.has(build.status)) {
+        try {
+          await pollAndProcess(build);
+        } catch (err) {
+          lastError = err;
+          const count = (failures.get(build.id) ?? 0) + 1;
+          failures.set(build.id, count);
+          if (count >= MAX_CONSECUTIVE_POLL_FAILURES) {
+            pollAbandoned.add(build.id);
+            const message = err instanceof Error ? err.message : String(err);
+            giveUpLocally(
+              build.id,
+              `giving up finishing ${build.id} after ${count} consecutive failures: ${message} \u2014 the build likely finished server-side; check its outcome with \`vibeview builds logs ${build.id}\``
+            );
+          }
+        }
+        continue;
+      }
+      if (build.status === "queued") {
+        const queuedSince = queueStartedAt.get(build.id) ?? now();
+        if (now() - queuedSince > queueCapMs) {
+          const rescue = await finalPollBeforeGivingUp(build);
+          if (state.get(build.id).status !== "queued") continue;
+          giveUpLocally(
+            build.id,
+            rescue === "poll_failed" ? (
+              // PR-445 review F6: the rescue poll failed, so "queued" is the
+              // last status observed BEFORE the gap — not verified server
+              // truth. Say so instead of asserting the build stayed queued.
+              `${build.id} still queued after ${Math.round(queueCapMs / 6e4)}m \u2014 builders busy; giving up waiting on it. Could not re-check its final status (the last poll failed) \u2014 it may have started or finished; check on it with \`vibeview builds\``
+            ) : `${build.id} still queued after ${Math.round(queueCapMs / 6e4)}m \u2014 builders busy; giving up waiting on it. The build stays queued server-side \u2014 check on it later with \`vibeview builds\``
+          );
+          continue;
+        }
+      } else {
+        const deadline = buildDeadline(build);
+        if (deadline !== null && now() > deadline) {
+          if (await finalPollBeforeGivingUp(build) === "terminal") continue;
+          giveUpLocally(
+            build.id,
+            `${build.id} exceeded its ${Math.round((build.timeout_s * 1e3 + POLL_SAFETY_MARGIN_MS) / 1e3)}s time limit client-side \u2014 giving up waiting on it. The build may still be running server-side \u2014 check its outcome with \`vibeview builds logs ${build.id}\``
+          );
+          continue;
+        }
+      }
+      try {
+        await pollAndProcess(build);
+      } catch (err) {
+        lastError = err;
+        const count = (failures.get(build.id) ?? 0) + 1;
+        failures.set(build.id, count);
+        if (count >= MAX_CONSECUTIVE_POLL_FAILURES) {
+          pollAbandoned.add(build.id);
+          const message = err instanceof Error ? err.message : String(err);
+          giveUpLocally(
+            build.id,
+            `giving up polling ${build.id} after ${count} consecutive failures: ${message} \u2014 the build may still be running server-side; resume watching it with \`vibeview builds logs ${build.id} --follow\``
+          );
+        }
+      }
+    }
+    if (stillWaiting()) {
+      for (const build of state.values()) {
+        if (BUILD_TERMINAL_STATUSES.has(build.status) || abandoned.has(build.id)) continue;
+        const deadline = backstopDeadlineFor(build.id, build.timeout_s);
+        if (now() <= deadline) continue;
+        if (await finalPollBeforeGivingUp(build) === "terminal") continue;
+        const postRescueDeadline = backstopDeadlineFor(build.id, build.timeout_s);
+        if (now() <= postRescueDeadline) continue;
+        const fresh = state.get(build.id);
+        const capMinutes = Math.round((postRescueDeadline - waitStartedAt) / 6e4);
+        giveUpLocally(
+          build.id,
+          `giving up waiting on ${build.id}: still \`${fresh.status}\` with no terminal status after the overall ${capMinutes}m safety limit \u2014 the backend never reported the build finished; check on it later with \`vibeview builds\``
+        );
+      }
+    }
+    if (stillWaiting()) {
+      const pendingStatuses = Array.from(state.values()).filter(
+        (b) => !abandoned.has(b.id) && !finalized.has(b.id) && !BUILD_TERMINAL_STATUSES.has(b.status)
+      ).map((b) => b.status);
+      await new Promise(
+        (r) => setTimeout(r, nextPollDelayMs(pendingStatuses, pollIntervalMs, queuedPollIntervalMs))
+      );
+    }
+  }
+  if (pollAbandoned.size > 0 && pollAbandoned.size === abandoned.size && !Array.from(state.values()).some((b) => BUILD_TERMINAL_STATUSES.has(b.status))) {
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(
+      `cloud build poll failed ${MAX_CONSECUTIVE_POLL_FAILURES} times in a row, giving up: ${message}
+The build may still be running server-side \u2014 resume watching it with \`vibeview builds logs <id> --follow\`.`
+    );
+  }
+  return state;
+}
+async function fetchFinalSummary(id, fallback, deps) {
+  try {
+    return await deps.getCloudBuild(id);
+  } catch {
+    return fallback;
+  }
+}
+function newTransitionState() {
+  return { printedQueued: false, printedRunning: false };
+}
+function printTransition(id, platform, status, state, json, printLine) {
+  if (status === "queued" && !state.printedQueued) {
+    state.printedQueued = true;
+    if (json) {
+      emitCloud(json, { event: "status", id, status: "queued" });
+    } else {
+      printLine(id, platform, chalk.dim("\u23F3 queued \u2014 waiting for a build slot"));
+    }
+  } else if (status === "running" && !state.printedRunning) {
+    state.printedRunning = true;
+    if (json) {
+      emitCloud(json, { event: "status", id, status: "running" });
+    } else {
+      printLine(id, platform, `${chalk.cyan("\u25B6")} building`);
+    }
+  }
+}
+function printOutcomeLine(build, multi) {
+  const prefix = multi ? `[${build.platform}] ` : "";
+  const ok = build.status === "succeeded";
+  const mark = ok ? chalk.green("\u2713") : chalk.red("\u2717");
+  const duration = formatDuration(build.started_at, build.finished_at);
+  let line = `${prefix}${mark} ${build.status}`;
+  if (duration) line += ` (${duration})`;
+  if (build.error_summary) line += ` \u2014 ${build.error_summary}`;
+  if (build.cost_micro > 0) line += ` \u2014 cost: ${formatCost(build.cost_micro)} usage credit`;
+  console.error(line);
 }
 
 // src/commands/dev.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname5 } from "path";
 import { createInterface as createInterface3 } from "readline";
@@ -732,19 +1396,19 @@ var TunnelClient = class {
 };
 
 // src/lib/metro-manager.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 
 // src/lib/metro-state.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 var STATE_DIR2 = ".vibeview";
 var STATE_FILE2 = "metro-state.json";
 function statePath2(cwd) {
-  return join5(cwd, STATE_DIR2, STATE_FILE2);
+  return join6(cwd, STATE_DIR2, STATE_FILE2);
 }
 function metroLogPath(cwd) {
-  return join5(cwd, STATE_DIR2, "metro.log");
+  return join6(cwd, STATE_DIR2, "metro.log");
 }
 function isPidAlive2(pid) {
   try {
@@ -757,12 +1421,12 @@ function isPidAlive2(pid) {
 function writeMetroState(cwd, state) {
   const path = statePath2(cwd);
   mkdirSync2(dirname3(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(state, null, 2) + "\n");
+  writeFileSync4(path, JSON.stringify(state, null, 2) + "\n");
 }
 function readMetroState(cwd) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(statePath2(cwd), "utf-8"));
+    parsed = JSON.parse(readFileSync5(statePath2(cwd), "utf-8"));
   } catch {
     return null;
   }
@@ -774,7 +1438,7 @@ function readMetroState(cwd) {
 }
 function clearMetroState(cwd) {
   const path = statePath2(cwd);
-  if (existsSync4(path)) rmSync3(path, { force: true });
+  if (existsSync4(path)) rmSync4(path, { force: true });
 }
 function killOwnedMetro(cwd) {
   const state = readMetroState(cwd);
@@ -832,7 +1496,7 @@ If Metro uses another port, pass --metro-port <port>.`
   return { status: "spawned", warnings };
 }
 async function spawnMetro(cwd, command, port, log, timeoutMs) {
-  const child = spawn2(command, {
+  const child = spawn3(command, {
     cwd,
     shell: true,
     detached: true,
@@ -1157,6 +1821,10 @@ function lateWarningVerdict(info, reportedWarnings) {
   return { toReport, blocking };
 }
 var ROKU_LIVENESS_INTERVAL_MS = 1e4;
+var ROKU_INSTALL_PENDING_INTERVAL_MS = 2e3;
+function rokuLivenessDelayMs(info) {
+  return info?.app_install_pending ? ROKU_INSTALL_PENDING_INTERVAL_MS : ROKU_LIVENESS_INTERVAL_MS;
+}
 function rokuKeyAction(char) {
   if (char === "") return "interrupt";
   switch (char.toLowerCase()) {
@@ -1619,36 +2287,42 @@ async function runDevInProcess(opts) {
       }
       const sessionId = handle.sessionId;
       const reportedWarnings = handle.reportedWarnings;
-      const keepAlive = setInterval(() => {
-        void (async () => {
-          if (stopping) return;
-          let info = null;
-          try {
-            info = await api.getSession(sessionId);
-          } catch {
-          }
-          const verdict = sessionLivenessVerdict(info);
-          if (verdict.end && !stopping) {
-            console.error(chalk2.red(verdict.message));
-            emit(opts.json, { event: "session_ended", session_id: sessionId, code: 1 });
-            endedEmitted = true;
-            await stopSession(1);
-            return;
-          }
-          const warningVerdict = lateWarningVerdict(info, reportedWarnings);
-          for (const w of warningVerdict.toReport) {
-            reportedWarnings.add(w);
-            console.error(chalk2.yellow(`\u26A0 ${w}`));
-            emit(opts.json, { event: "warning", message: w });
-          }
-          if (warningVerdict.blocking && !stopping) {
-            emit(opts.json, { event: "session_ended", session_id: sessionId, code: 1 });
-            endedEmitted = true;
-            await stopSession(1);
-          }
-        })();
-      }, ROKU_LIVENESS_INTERVAL_MS);
-      process.on("exit", () => clearInterval(keepAlive));
+      let keepAlive;
+      const scheduleLiveness = (delayMs) => {
+        keepAlive = setTimeout(() => {
+          void (async () => {
+            if (stopping) return;
+            let info = null;
+            try {
+              info = await api.getSession(sessionId);
+            } catch {
+            }
+            const verdict = sessionLivenessVerdict(info);
+            if (verdict.end && !stopping) {
+              console.error(chalk2.red(verdict.message));
+              emit(opts.json, { event: "session_ended", session_id: sessionId, code: 1 });
+              endedEmitted = true;
+              await stopSession(1);
+              return;
+            }
+            const warningVerdict = lateWarningVerdict(info, reportedWarnings);
+            for (const w of warningVerdict.toReport) {
+              reportedWarnings.add(w);
+              console.error(chalk2.yellow(`\u26A0 ${w}`));
+              emit(opts.json, { event: "warning", message: w });
+            }
+            if (warningVerdict.blocking && !stopping) {
+              emit(opts.json, { event: "session_ended", session_id: sessionId, code: 1 });
+              endedEmitted = true;
+              await stopSession(1);
+              return;
+            }
+            if (!stopping) scheduleLiveness(rokuLivenessDelayMs(info));
+          })();
+        }, delayMs);
+      };
+      scheduleLiveness(ROKU_INSTALL_PENDING_INTERVAL_MS);
+      process.on("exit", () => clearTimeout(keepAlive));
     }
   } catch (err) {
     const message = err.message;
@@ -1662,7 +2336,7 @@ async function dev(opts) {
     return runDevInProcess(opts);
   }
   const rawArgs = process.argv.slice(2).filter((a) => a !== "--detach");
-  const child = spawn3(process.execPath, [process.argv[1], ...rawArgs, "--json", "--no-open"], {
+  const child = spawn4(process.execPath, [process.argv[1], ...rawArgs, "--json", "--no-open"], {
     detached: true,
     stdio: ["ignore", "pipe", "ignore"]
   });
@@ -2194,7 +2868,7 @@ function agentExitCode(env) {
 }
 
 // src/commands/agent.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 var REF_RE = /^@?(e\d+)$/;
 var COORDS_RE = /^(-?\d+),\s*(-?\d+)$/;
 var FlagError = class extends Error {
@@ -2395,7 +3069,7 @@ async function runAgentVerb(cmd, positionals, opts) {
 `);
       process.exit(1);
     }
-    writeFileSync4(outPath, imageBytes);
+    writeFileSync5(outPath, imageBytes);
     if (opts.json) {
       console.log(JSON.stringify(envelope));
     } else {
@@ -2423,6 +3097,11 @@ export {
   readMetroState,
   killOwnedMetro,
   buildCommand,
+  BUILD_TERMINAL_STATUSES,
+  fetchFinalSummary,
+  newTransitionState,
+  printTransition,
+  printOutcomeLine,
   startDevSession,
   PLATFORM_DEVICE,
   dev,