vibeview 0.10.1 → 0.12.0

package/dist/{chunk-NA3JOV5Z.js → chunk-NJU4AKHN.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
   ApiClient,
+  createSpinner,
   loadConfig,
   resolveAuth,
   uploadAppBuild
-} from "./chunk-YD2X6TQV.js";
+} from "./chunk-OHRTLUBD.js";
 
 // src/lib/dev-state.ts
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
@@ -71,7 +72,15 @@ function clearDevState(cwd) {
 // src/lib/dev-config.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2 } from "path";
-var DEV_PLATFORMS = ["ios", "android", "tvos", "androidtv"];
+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,
+  tvos: true,
+  androidtv: true,
+  roku: false
+};
 var FILE = "vibeview.json";
 function isDevPlatform(p) {
   return typeof p === "string" && DEV_PLATFORMS.includes(p);
@@ -137,6 +146,18 @@ function loadDevConfig(cwd) {
         );
       }
     }
+    if (entry.watchIgnore !== void 0) {
+      if (!Array.isArray(entry.watchIgnore)) {
+        throw new Error(
+          `vibeview.json: platforms.${key}.watchIgnore must be an array of paths to ignore while watching`
+        );
+      }
+      if (entry.watchIgnore.some((p) => typeof p !== "string" || !p)) {
+        throw new Error(
+          `vibeview.json: platforms.${key}.watchIgnore entries must be non-empty strings`
+        );
+      }
+    }
     if (entry.metroCommand !== void 0 && (typeof entry.metroCommand !== "string" || !entry.metroCommand)) {
       throw new Error(`vibeview.json: platforms.${key}.metroCommand must be a non-empty string`);
     }
@@ -146,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");
 }
@@ -169,18 +210,21 @@ function buildSavedConfig(input2) {
     firstRunMetro,
     firstRunBuild
   } = input2;
-  const topLevelMetroPort = metroPortFlag ? parseInt(metroPortFlag, 10) : existing?.metroPort ?? 8081;
+  const topLevelMetroPort = metroPortFlag ? parseInt(metroPortFlag, 10) : existing?.metroPort ?? (PLATFORM_NEEDS_METRO[platform] ? 8081 : void 0);
   return {
     defaultPlatform: platform,
-    metroPort: topLevelMetroPort,
+    ...topLevelMetroPort !== void 0 ? { metroPort: topLevelMetroPort } : {},
     ...isFirstRun && firstRunMetro ? { metroCommand: firstRunMetro } : existing?.metroCommand ? { metroCommand: existing.metroCommand } : {},
     platforms: {
       ...existing?.platforms,
       [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.
+        ...existing?.platforms?.[platform]?.watchIgnore ? { watchIgnore: existing.platforms[platform].watchIgnore } : {},
         ...existing?.platforms?.[platform]?.metroCommand ? { metroCommand: existing.platforms[platform].metroCommand } : {},
         ...existing?.platforms?.[platform]?.metroPort !== void 0 ? { metroPort: existing.platforms[platform].metroPort } : {}
       }
@@ -202,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";
@@ -268,8 +312,22 @@ function prepareUploadArtifact(path) {
 import { input, select } from "@inquirer/prompts";
 
 // src/lib/project-detect.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join4 } from "path";
+function readJson(cwd, name) {
+  try {
+    return JSON.parse(readFileSync3(join4(cwd, name), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isFile(path) {
+  try {
+    return statSync2(path).isFile();
+  } catch {
+    return false;
+  }
+}
 function detectFlavor(cwd) {
   let deps = {};
   try {
@@ -279,6 +337,7 @@ function detectFlavor(cwd) {
   }
   if ("expo" in deps) return "expo";
   if (existsSync3(join4(cwd, "android", "gradlew")) || iosWorkspaceName(cwd)) return "bare-rn";
+  if (isFile(join4(cwd, "manifest"))) return "roku";
   return "unknown";
 }
 function iosWorkspaceName(cwd) {
@@ -291,9 +350,32 @@ function iosWorkspaceName(cwd) {
 }
 var IOS_ARTIFACT = "ios/build/Build/Products/Debug-iphonesimulator/*.app";
 var ANDROID_ARTIFACT = "android/app/build/outputs/apk/debug/*.apk";
+var ROKU_DEFAULT_ARTIFACT = "out/channel.zip";
+var ROKU_ZIP_COMMAND = "zip -r out/channel.zip manifest source components images -x '*.DS_Store'";
+function rokuDefaults(cwd) {
+  const pkg = readJson(cwd, "package.json");
+  const scripts = pkg?.scripts ?? {};
+  const runner = existsSync3(join4(cwd, "yarn.lock")) ? "yarn" : "npm run";
+  const packageScript = Object.entries(scripts).find(
+    ([name, body]) => !name.startsWith("deploy") && (name.startsWith("package") || body.includes("--package-only") || body.includes("zipPackage"))
+  );
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  let artifact = ROKU_DEFAULT_ARTIFACT;
+  if ("roku-deploy" in deps) {
+    const rd = readJson(cwd, "rokudeploy.json");
+    const outDir = rd?.outDir ?? "out";
+    const outFile = rd?.outFile ?? "roku-deploy.zip";
+    artifact = `${outDir}/${outFile}`;
+  }
+  if (packageScript) {
+    return { buildCommand: `${runner} ${packageScript[0]}`, artifact };
+  }
+  return { buildCommand: ROKU_ZIP_COMMAND, artifact };
+}
 function defaultsFor(cwd, platform) {
   const flavor = detectFlavor(cwd);
-  if (flavor === "unknown") return {};
+  if (platform === "roku") return flavor === "roku" ? rokuDefaults(cwd) : {};
+  if (flavor === "unknown" || flavor === "roku") return {};
   const metroCommand = flavor === "expo" ? "npx expo start" : "yarn start";
   if (platform === "tvos" || platform === "androidtv") return { metroCommand };
   if (platform === "android") {
@@ -319,6 +401,16 @@ function defaultsFor(cwd, platform) {
 }
 
 // src/lib/dev-setup.ts
+function platformChoices(cwd) {
+  const choices = [
+    { value: "ios", name: "iOS simulator" },
+    { value: "android", name: "Android emulator" },
+    { value: "tvos", name: "Apple TV simulator" },
+    { value: "androidtv", name: "Android TV emulator" }
+  ];
+  if (detectFlavor(cwd) === "roku") choices.unshift({ value: "roku", name: "Roku (beta)" });
+  return choices;
+}
 function firstRunAppStrategy(apps, buildConfigured) {
   if (!buildConfigured) return "picker";
   return apps.length === 0 ? "build_now" : "ask";
@@ -352,7 +444,7 @@ async function promptBuildConfig(cwd, platform) {
   }
   const command = await input({ message: `Build command for ${platform}`, required: true });
   const artifact = await input({
-    message: "Path to the built app it produces (.apk, or .app dir; * allowed)",
+    message: platform === "roku" ? "Path to the channel zip it produces (* allowed)" : "Path to the built app it produces (.apk, or .app dir; * allowed)",
     default: defaults.artifact,
     required: true
   });
@@ -366,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);
@@ -393,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);
@@ -406,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);
@@ -421,40 +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: [
-        { value: "ios", name: "iOS simulator" },
-        { value: "android", name: "Android emulator" },
-        { value: "tvos", name: "Apple TV simulator" },
-        { value: "androidtv", name: "Android TV emulator" }
-      ]
+      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,
@@ -484,19 +756,335 @@ 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 POLL_SAFETY_MARGIN_MS = 10 * 60 * 1e3;
+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) started`);
+    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 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 abandoned = /* @__PURE__ */ new Set();
+  let lastError;
+  const maxTimeoutS = Math.max(...builds.map((b) => b.timeout_s), 0);
+  const deadline = now() + maxTimeoutS * 1e3 + POLL_SAFETY_MARGIN_MS;
+  const printLine = (id, platform, line) => {
+    const prefix = multi ? `[${platform}] ` : "";
+    if (!opts.json) console.error(prefix + line);
+  };
+  const stillWaiting = () => Array.from(state.values()).some(
+    (b) => !BUILD_TERMINAL_STATUSES.has(b.status) && !abandoned.has(b.id)
+  );
+  while (stillWaiting()) {
+    if (now() > deadline) {
+      throw new Error(
+        `cloud build poll timed out after exceeding the ${Math.round((maxTimeoutS * 1e3 + POLL_SAFETY_MARGIN_MS) / 1e3)}s safety limit \u2014 the backend never reported a terminal status`
+      );
+    }
+    for (const build of state.values()) {
+      if (BUILD_TERMINAL_STATUSES.has(build.status) || abandoned.has(build.id)) continue;
+      try {
+        const offset = offsets.get(build.id) ?? 0;
+        const logs = await deps.getCloudBuildLogs(build.id, offset);
+        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);
+          }
+        }
+        offsets.set(build.id, logs.offset);
+        const updated = { ...build, status: logs.status };
+        state.set(build.id, updated);
+        failures.set(build.id, 0);
+        if (BUILD_TERMINAL_STATUSES.has(logs.status)) {
+          const final = await fetchFinalSummary(build.id, updated, deps);
+          state.set(build.id, final);
+          emitCloud(opts.json, {
+            event: "build_finished",
+            id: final.id,
+            status: final.status,
+            cost_micro: final.cost_micro,
+            error_summary: final.error_summary
+          });
+          if (!opts.json) {
+            printOutcomeLine(final, multi);
+          }
+        }
+      } catch (err) {
+        lastError = err;
+        const count = (failures.get(build.id) ?? 0) + 1;
+        failures.set(build.id, count);
+        if (count >= MAX_CONSECUTIVE_POLL_FAILURES) {
+          abandoned.add(build.id);
+          const message = err instanceof Error ? err.message : String(err);
+          const giveUp = `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\``;
+          emitCloud(opts.json, { event: "error", message: giveUp });
+          if (!opts.json) console.error(chalk.red(giveUp));
+        }
+      }
+    }
+    if (stillWaiting()) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+  }
+  if (abandoned.size > 0 && !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 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 dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { select as select3 } from "@inquirer/prompts";
 import chalk2 from "chalk";
@@ -667,19 +1255,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 {
@@ -692,12 +1280,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;
   }
@@ -709,7 +1297,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);
@@ -767,7 +1355,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,
@@ -815,19 +1403,163 @@ async function waitFor(cond, timeoutMs, everyMs) {
   }
 }
 
+// src/lib/reload-loop.ts
+import { watch } from "fs";
+import { basename as basename2, dirname as dirname4 } from "path";
+function createReloadLoop(deps) {
+  let inFlight = null;
+  let pendingFollowUp = false;
+  let debounceTimer = null;
+  let stopWatch = null;
+  let stopped = false;
+  async function run() {
+    inFlight = (async () => {
+      try {
+        await deps.push();
+      } catch (err) {
+        (deps.logError ?? deps.log)(err.message);
+      }
+    })();
+    try {
+      await inFlight;
+    } finally {
+      inFlight = null;
+    }
+    if (pendingFollowUp && !stopped) {
+      pendingFollowUp = false;
+      await run();
+    }
+  }
+  async function trigger() {
+    if (stopped) return;
+    if (inFlight) {
+      deps.log("already reloading \u2014 ignoring");
+      return;
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    await run();
+  }
+  function onChange() {
+    if (stopped) return;
+    if (inFlight) {
+      pendingFollowUp = true;
+      return;
+    }
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(
+      () => {
+        debounceTimer = null;
+        void trigger();
+      },
+      (deps.watchSeconds ?? 2) * 1e3
+    );
+  }
+  if (deps.watch && deps.watchSeconds !== void 0) {
+    stopWatch = deps.watch(onChange);
+  }
+  return {
+    trigger,
+    stop() {
+      stopped = true;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      stopWatch?.();
+    }
+  };
+}
+var IGNORED_SEGMENTS = ["node_modules", ".git", ".vibeview"];
+var IGNORED_FILES = ["vibeview.json"];
+function isUnderPath(rel, entry) {
+  const norm = normalizeRel(entry).replace(/\/+$/, "");
+  if (!norm) return false;
+  return rel === norm || rel.startsWith(`${norm}/`);
+}
+function normalizeRel(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isIgnoredWatchPath(relPath, artifact, userIgnore = []) {
+  const rel = normalizeRel(relPath);
+  const segments = rel.split("/");
+  if (segments.some((s) => IGNORED_SEGMENTS.includes(s) || s.includes("staging"))) return true;
+  if (IGNORED_FILES.includes(rel)) return true;
+  if (userIgnore.some((entry) => isUnderPath(rel, entry))) return true;
+  const artifactPattern = artifact.replace(/\\/g, "/").replace(/^\.\//, "");
+  const artifactDir = dirname4(artifactPattern);
+  if (artifactDir !== "." && (rel === artifactDir || rel.startsWith(`${artifactDir}/`))) {
+    return true;
+  }
+  if (dirname4(rel) !== artifactDir) return false;
+  const name = basename2(artifactPattern);
+  const re = new RegExp(`^${name.split("*").map(escapeRegExp2).join(".*")}$`);
+  return re.test(basename2(rel));
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function watchProjectFiles(cwd, artifact, userIgnore = []) {
+  return (onChange) => {
+    const watcher = watch(cwd, { recursive: true }, (_event, filename) => {
+      if (filename !== null && isIgnoredWatchPath(filename.toString(), artifact, userIgnore)) {
+        return;
+      }
+      onChange();
+    });
+    return () => watcher.close();
+  };
+}
+
+// src/lib/roku-push.ts
+function createRokuPush(opts) {
+  const runBuild = opts.runBuild ?? runBuildForPlatform;
+  return async () => {
+    const started = Date.now();
+    let result;
+    try {
+      result = await runBuild(
+        opts.cwd,
+        "roku",
+        opts.build,
+        { token: opts.token, baseUrl: opts.baseUrl },
+        opts.log
+      );
+    } catch (err) {
+      const message = err.message;
+      if (/artifact not found/i.test(message)) {
+        throw new Error(
+          `${message}
+your build command must produce a zip \u2014 use the package/zip step, not deploy`
+        );
+      }
+      throw err;
+    }
+    if (!result.build_id) {
+      throw new Error(`upload returned no build id for ${result.name ?? result.public_id}`);
+    }
+    await opts.api.installBuild(opts.sessionId, result.build_id, true);
+    opts.log(`reloaded in ${((Date.now() - started) / 1e3).toFixed(1)}s`);
+  };
+}
+
 // src/commands/dev.ts
+function parseWatchSeconds(flag) {
+  if (flag === void 0 || flag === false) return void 0;
+  if (flag === true) return 2;
+  const seconds = Number(flag);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error(`--watch expects a positive number of seconds, got "${flag}"`);
+  }
+  return seconds;
+}
 function emit(json, evt) {
   if (json) console.log(JSON.stringify(evt));
 }
 async function startDevSession(cfg, onEvent = () => {
 }, onTunnelState) {
   const api = new ApiClient(cfg.baseUrl, cfg.token);
-  const created = await api.createSession({
-    device_type: PLATFORM_DEVICE[cfg.platform].deviceType,
-    device_category: cfg.deviceCategory,
-    app_id: cfg.appId,
-    tunnel: true
-  });
+  const usesTunnel = PLATFORM_NEEDS_METRO[cfg.platform];
+  const created = await api.createSession(devSessionCreateBody(cfg));
   const sessionId = created.session_id;
   let stopping = false;
   let tunnel = null;
@@ -841,52 +1573,66 @@ async function startDevSession(cfg, onEvent = () => {
   };
   try {
     await api.startSession(sessionId);
-    const ready = await pollUntilTunnelReady(api, sessionId, 18e4);
-    for (const w of ready.warnings ?? []) {
-      onEvent({ event: "warning", message: w });
-    }
     const pageUrl = `${cfg.webUrl || cfg.baseUrl}/sandbox/${sessionId}`;
-    tunnel = new TunnelClient({
-      url: ready.tunnel_url,
-      metroPort: cfg.metroPort,
-      // 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;
-      },
-      onDebug: cfg.debug ? (msg) => onEvent({ event: "warning", message: `[tunnel] ${msg}` }) : void 0,
-      onState: (s) => {
-        onTunnelState?.(s);
-        if (s === "connected") {
-          onEvent({ event: "tunnel_connected", session_id: sessionId });
-        } else if (s === "metro-unreachable") {
-          onEvent({
-            event: "warning",
-            message: `can't reach Metro on localhost:${cfg.metroPort} \u2014 is it running? (yarn start)`
-          });
-        } else if (s === "closed" && !stopping) {
-          void stopSession(1);
-        }
+    const reportedWarnings = /* @__PURE__ */ new Set();
+    if (usesTunnel) {
+      const ready = await pollUntilTunnelReady(api, sessionId, 18e4);
+      for (const w of ready.warnings ?? []) {
+        reportedWarnings.add(w);
+        onEvent({ event: "warning", message: w });
       }
-    });
-    tunnel.start();
+      tunnel = new TunnelClient({
+        url: ready.tunnel_url,
+        metroPort: cfg.metroPort,
+        // 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;
+        },
+        onDebug: cfg.debug ? (msg) => onEvent({ event: "warning", message: `[tunnel] ${msg}` }) : void 0,
+        onState: (s) => {
+          onTunnelState?.(s);
+          if (s === "connected") {
+            onEvent({ event: "tunnel_connected", session_id: sessionId });
+          } else if (s === "metro-unreachable") {
+            onEvent({
+              event: "warning",
+              message: `can't reach Metro on localhost:${cfg.metroPort} \u2014 is it running? (yarn start)`
+            });
+          } else if (s === "closed" && !stopping) {
+            void stopSession(1);
+          }
+        }
+      });
+      tunnel.start();
+    }
     if (cfg.open !== false) await openBrowser(pageUrl).catch(() => {
     });
     const active = await pollUntilActive(api, sessionId, 18e4);
-    const seen = new Set(ready.warnings ?? []);
     for (const w of active.warnings ?? []) {
-      if (!seen.has(w)) onEvent({ event: "warning", message: w });
+      if (reportedWarnings.has(w)) continue;
+      reportedWarnings.add(w);
+      onEvent({ event: "warning", message: w });
     }
-    return { sessionId, pageUrl, stop: () => stopSession(0) };
+    return { sessionId, pageUrl, stop: () => stopSession(0), reportedWarnings };
   } catch (err) {
     await stopSession(1);
     throw err;
   }
 }
+function devSessionCreateBody(cfg) {
+  return {
+    device_type: PLATFORM_DEVICE[cfg.platform].deviceType,
+    device_category: cfg.deviceCategory,
+    app_id: cfg.appId,
+    // Roku has no JS bundle to serve, so there is nothing to tunnel.
+    tunnel: PLATFORM_NEEDS_METRO[cfg.platform]
+  };
+}
 var BLOCKING_WARNING_PREFIXES = ["No debug build", "App install failed", "App not found"];
 function findBlockingWarning(info) {
   return (info.warnings ?? []).find((w) => BLOCKING_WARNING_PREFIXES.some((p) => w.includes(p)));
@@ -921,11 +1667,42 @@ async function pollUntilActive(api, sessionId, timeoutMs, intervalMs = 2e3) {
     await new Promise((r) => setTimeout(r, intervalMs));
   }
 }
+function sessionLivenessVerdict(info) {
+  if (info && (info.status === "stopped" || info.status === "failed")) {
+    return { end: true, message: `session ${info.status} \u2014 ending the reload loop` };
+  }
+  return { end: false };
+}
+function lateWarningVerdict(info, reportedWarnings) {
+  if (!info) return { toReport: [], blocking: false };
+  const toReport = (info.warnings ?? []).filter((w) => !reportedWarnings.has(w));
+  const blocking = findBlockingWarning({ warnings: toReport }) !== void 0;
+  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()) {
+    case "r":
+      return "reload";
+    case "q":
+      return "quit";
+    default:
+      return null;
+  }
+}
 var PLATFORM_DEVICE = {
   ios: { deviceType: "ios", tv: false },
   android: { deviceType: "android", tv: false },
   tvos: { deviceType: "ios", tv: true },
-  androidtv: { deviceType: "android", tv: true }
+  androidtv: { deviceType: "android", tv: true },
+  // Roku IS its own device type (unlike tvOS/Android TV, which are the
+  // handheld type plus category tv) — the worker registers it as such.
+  roku: { deviceType: "roku", tv: true }
 };
 function appsForPlatform(apps, platform) {
   return apps.filter((a) => a.platform === platform);
@@ -953,7 +1730,7 @@ function requireNonInteractive(json) {
 async function ensureConfig(api, opts) {
   const existing = loadDevConfig(process.cwd());
   if (opts.platform && !isDevPlatform(opts.platform)) {
-    console.error(chalk2.red(`error: --platform must be one of ios, android, tvos, androidtv`));
+    console.error(chalk2.red(`error: --platform must be one of ${DEV_PLATFORMS.join(", ")}`));
     process.exit(2);
   }
   if (!opts.platform && !existing?.defaultPlatform) {
@@ -961,12 +1738,7 @@ async function ensureConfig(api, opts) {
   }
   const platform = opts.platform || existing?.defaultPlatform || await select3({
     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" }
-    ]
+    choices: platformChoices(process.cwd())
   });
   const isTv = PLATFORM_DEVICE[platform].tv;
   if (isTv && opts.deviceCategory) {
@@ -988,7 +1760,9 @@ async function ensureConfig(api, opts) {
       requireNonInteractive(opts.json);
     } else if (process.stdin.isTTY) {
       firstRunBuild = await promptBuildConfig(process.cwd(), platform);
-      firstRunMetro = await promptMetroCommand(process.cwd(), platform);
+      if (PLATFORM_NEEDS_METRO[platform]) {
+        firstRunMetro = await promptMetroCommand(process.cwd(), platform);
+      }
     }
   }
   const entry = existing?.platforms?.[platform];
@@ -1098,7 +1872,10 @@ Run \`vibeview dev\` without --app to pick from the list.`
   });
   saveDevConfig(process.cwd(), cfg);
   if (isFirstRun) {
-    const hint = fillLaterHint({ build: !firstRunBuild, metro: !firstRunMetro }, platform);
+    const hint = fillLaterHint(
+      { build: !firstRunBuild, metro: PLATFORM_NEEDS_METRO[platform] && !firstRunMetro },
+      platform
+    );
     if (hint) console.error(chalk2.dim(hint));
   }
   const finalMetro = isFirstRun ? resolveMetro(cfg, platform, opts.metroPort ? parseInt(opts.metroPort, 10) : void 0) : metroResolved;
@@ -1113,6 +1890,15 @@ Run \`vibeview dev\` without --app to pick from the list.`
   };
 }
 async function runDevInProcess(opts) {
+  let watchSeconds;
+  try {
+    watchSeconds = parseWatchSeconds(opts.watch);
+  } catch (err) {
+    const message = err.message;
+    console.error(chalk2.red(`error: ${message}`));
+    emit(opts.json, { event: "error", code: "invalid_flag", message });
+    process.exit(2);
+  }
   if (opts.json) {
     const hasToken = !!(opts.token || process.env.VIBEVIEW_API_TOKEN || loadConfig().token);
     if (!hasToken) {
@@ -1158,51 +1944,68 @@ async function runDevInProcess(opts) {
       process.exit(1);
     }
   }
-  const metroPort = cfg.metroPort ?? 8081;
-  let metroResult;
-  try {
-    let metroLogStream = null;
-    const captureMetroLine = (line) => {
-      try {
-        if (!metroLogStream) {
-          mkdirSync3(dirname4(metroLogPath(process.cwd())), { recursive: true });
-          metroLogStream = createWriteStream(metroLogPath(process.cwd()), { flags: "w" });
+  let metroOwnedThisRun = false;
+  let rokuBuild;
+  let watchIgnore = [];
+  if (PLATFORM_NEEDS_METRO[cfg.platform]) {
+    const metroPort = cfg.metroPort ?? 8081;
+    let metroResult;
+    try {
+      let metroLogStream = null;
+      const captureMetroLine = (line) => {
+        try {
+          if (!metroLogStream) {
+            mkdirSync3(dirname5(metroLogPath(process.cwd())), { recursive: true });
+            metroLogStream = createWriteStream(metroLogPath(process.cwd()), { flags: "w" });
+          }
+          metroLogStream.write(line.replace(/^\[metro\] /, "") + "\n");
+        } catch {
         }
-        metroLogStream.write(line.replace(/^\[metro\] /, "") + "\n");
-      } catch {
-      }
-      if (shouldEchoMetroLine(line, opts.debug === true)) console.error(chalk2.dim(line));
-    };
-    metroResult = await ensureMetro(
-      process.cwd(),
-      {
-        command: cfg.metroCommand,
-        port: metroPort,
-        platformHasOverride: cfg.platformHasMetroOverride
-      },
-      captureMetroLine
-    );
-  } catch (err) {
-    const message = err.message;
-    console.error(chalk2.red(`error: ${message}`));
-    emit(opts.json, { event: "error", code: "metro_down", message });
-    process.exit(1);
-  }
-  for (const w of metroResult.warnings) console.error(chalk2.yellow(`\u26A0 ${w}`));
-  if (metroResult.status === "spawned" || metroResult.status === "respawned") {
-    console.error(chalk2.green(`\u2713 started Metro (${cfg.metroCommand})`));
-    console.error(
-      chalk2.dim(`  full Metro output: ${metroLogPath(process.cwd())} (--debug echoes it here)`)
-    );
+        if (shouldEchoMetroLine(line, opts.debug === true)) console.error(chalk2.dim(line));
+      };
+      metroResult = await ensureMetro(
+        process.cwd(),
+        {
+          command: cfg.metroCommand,
+          port: metroPort,
+          platformHasOverride: cfg.platformHasMetroOverride
+        },
+        captureMetroLine
+      );
+    } catch (err) {
+      const message = err.message;
+      console.error(chalk2.red(`error: ${message}`));
+      emit(opts.json, { event: "error", code: "metro_down", message });
+      process.exit(1);
+    }
+    for (const w of metroResult.warnings) console.error(chalk2.yellow(`\u26A0 ${w}`));
+    if (metroResult.status === "spawned" || metroResult.status === "respawned") {
+      console.error(chalk2.green(`\u2713 started Metro (${cfg.metroCommand})`));
+      console.error(
+        chalk2.dim(`  full Metro output: ${metroLogPath(process.cwd())} (--debug echoes it here)`)
+      );
+    }
+    metroOwnedThisRun = metroResult.status === "spawned" || metroResult.status === "respawned";
+  } else {
+    const rokuEntry = loadDevConfig(process.cwd())?.platforms?.[cfg.platform];
+    rokuBuild = rokuEntry?.build;
+    watchIgnore = rokuEntry?.watchIgnore ?? [];
+    if (!rokuBuild) {
+      const message = `no build config for ${cfg.platform} \u2014 run \`vibeview build --platform ${cfg.platform}\` once to set it up`;
+      console.error(chalk2.red(`error: ${message}`));
+      emit(opts.json, { event: "error", code: "config_required", message });
+      process.exit(1);
+    }
   }
-  const metroOwnedThisRun = metroResult.status === "spawned" || metroResult.status === "respawned";
   console.error(chalk2.dim(`Starting a ${cfg.platform} dev session for ${cfg.appId}...`));
   let stopping = false;
   let handle = null;
+  let reloadLoop = null;
   const stopSession = async (code) => {
     if (stopping) return;
     stopping = true;
     console.error(chalk2.dim("\nStopping session..."));
+    reloadLoop?.stop();
     await handle?.stop();
     if (metroOwnedThisRun) killOwnedMetro(process.cwd());
     clearDevState(process.cwd());
@@ -1213,6 +2016,7 @@ async function runDevInProcess(opts) {
   let everConnected = false;
   let waitingPrinted = false;
   let nextWarningIsMetroUnreachable = false;
+  let endedEmitted = false;
   try {
     handle = await startDevSession(
       {
@@ -1243,10 +2047,15 @@ async function runDevInProcess(opts) {
         } else if (evt.event === "session_ended" && !stopping && handle) {
           console.error(chalk2.red("tunnel closed by server \u2014 session ended"));
           stopping = true;
+          endedEmitted = true;
           emit(opts.json, evt);
           clearDevState(process.cwd());
           process.exit(1);
         }
+        if (evt.event === "session_ended") {
+          if (endedEmitted) return;
+          endedEmitted = true;
+        }
         emit(opts.json, evt);
       },
       (s) => {
@@ -1266,12 +2075,11 @@ async function runDevInProcess(opts) {
         }
       }
     );
-    console.error(
-      `
+    const keysLine = rokuBuild ? `Press ${chalk2.bold("r")} to reload the channel, ${chalk2.bold("q")} or Ctrl-C to end the session.` : "Ctrl-C to end the session.";
+    console.error(`
   Watch and interact: ${chalk2.cyan(handle.pageUrl)}
-  Ctrl-C to end the session.
-`
-    );
+  ${keysLine}
+`);
     writeDevState(process.cwd(), {
       pid: process.pid,
       session_id: handle.sessionId,
@@ -1289,6 +2097,92 @@ async function runDevInProcess(opts) {
     });
     if (opts.open !== false) await openBrowser(handle.pageUrl).catch(() => {
     });
+    if (rokuBuild) {
+      reloadLoop = createReloadLoop({
+        push: createRokuPush({
+          cwd: process.cwd(),
+          sessionId: handle.sessionId,
+          build: rokuBuild,
+          token,
+          baseUrl,
+          api,
+          // Build output and loop notices are human output, so they go to
+          // stderr like every other line this command prints — stdout stays
+          // reserved for the `--json` event stream.
+          log: (line) => console.error(chalk2.dim(line))
+        }),
+        log: (line) => console.error(chalk2.yellow(line)),
+        // A failed reload is an error, not a notice — same red as every other
+        // failure this command prints, so it doesn't read like the yellow
+        // "already reloading" line.
+        logError: (line) => console.error(chalk2.red(`\u2717 ${line}`)),
+        ...watchSeconds !== void 0 ? {
+          watchSeconds,
+          watch: watchProjectFiles(process.cwd(), rokuBuild.artifact, watchIgnore)
+        } : {}
+      });
+      if (watchSeconds !== void 0) {
+        console.error(
+          chalk2.dim(`  Watching for changes \u2014 reloading after ${watchSeconds}s of quiet.`)
+        );
+      }
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        const onKeyData = (chunk) => {
+          for (const char of chunk) {
+            const action = rokuKeyAction(char);
+            if (action === "reload") void reloadLoop?.trigger();
+            else if (action === "quit" || action === "interrupt") void stopSession(0);
+          }
+        };
+        process.stdin.on("data", onKeyData);
+        process.on("exit", () => {
+          process.stdin.removeListener("data", onKeyData);
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+          process.stdin.pause();
+        });
+      }
+      const sessionId = handle.sessionId;
+      const reportedWarnings = handle.reportedWarnings;
+      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;
     console.error(chalk2.red(`error: ${message}`));
@@ -1301,7 +2195,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"]
   });
@@ -1833,7 +2727,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 {
@@ -2034,7 +2928,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 {
@@ -2055,12 +2949,16 @@ async function runAgentVerb(cmd, positionals, opts) {
 export {
   readDevState,
   clearDevState,
+  PLATFORM_NEEDS_METRO,
   isDevPlatform,
   loadDevConfig,
   checkMetro,
   readMetroState,
   killOwnedMetro,
   buildCommand,
+  BUILD_TERMINAL_STATUSES,
+  fetchFinalSummary,
+  printOutcomeLine,
   startDevSession,
   PLATFORM_DEVICE,
   dev,