vibeview 0.36.1 → 0.37.1

package/README.md

@@ -34,7 +34,7 @@ vibeview dev
 
 [Live Development docs →](https://vibeview.io/docs/live-development)
 
-## Cloud Builds (beta)
+## Cloud Builds
 
 Build your React Native app on VibeView's build fleet — no Mac, no CI
 pipeline, no local toolchain:

package/dist/{chunk-VFCG4U7V.js → chunk-NJ2IXB5H.js}

@@ -838,10 +838,24 @@ function iosWorkspaceName(cwd) {
 var IOS_ARTIFACT = "ios/build/Build/Products/Debug-iphonesimulator/*.app";
 var ANDROID_ARTIFACT = "android/app/build/outputs/apk/debug/*.apk";
 function installCommand(cwd) {
-  if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn install --immutable";
-  if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync3(join5(cwd, "package-lock.json"))) return "npm ci";
-  return "yarn install --immutable";
+  const hit = JS_LOCKFILE_INSTALLS.find(([lockfile]) => existsSync3(join5(cwd, lockfile)));
+  return hit ? hit[1] : "npm install";
+}
+var JS_LOCKFILE_INSTALLS = [
+  ["yarn.lock", "yarn install --immutable"],
+  ["pnpm-lock.yaml", "pnpm install --frozen-lockfile"],
+  ["package-lock.json", "npm ci"],
+  ["npm-shrinkwrap.json", "npm ci"],
+  ["bun.lock", "npm install"],
+  ["bun.lockb", "npm install"]
+];
+function bareInstallPrefix(cwd, platform) {
+  const legs = [];
+  if (isFile(join5(cwd, "package.json"))) legs.push(installCommand(cwd));
+  if (platform === "ios" && isFile(join5(cwd, "ios", "Podfile"))) {
+    legs.push("cd ios && pod install && cd ..");
+  }
+  return legs.map((l) => `${l} && `).join("");
 }
 function managedExpoAndroidCommand(cwd) {
   return `${installCommand(cwd)} && npx expo prebuild --platform android --no-install && cd android && ./gradlew assembleDebug`;
@@ -871,7 +885,7 @@ function rokuDefaults(cwd) {
   }
   return { buildCommand: ROKU_ZIP_COMMAND, artifact };
 }
-function defaultsFor(cwd, platform) {
+function defaultsFor(cwd, platform, evaluatedIosName) {
   const flavor = detectFlavor(cwd);
   if (platform === "roku") return flavor === "roku" ? rokuDefaults(cwd) : {};
   if (flavor === "unknown" || flavor === "roku") return {};
@@ -880,13 +894,13 @@ function defaultsFor(cwd, platform) {
   if (platform === "android") {
     const managed = isManagedExpo(cwd, "android");
     return {
-      buildCommand: managed ? managedExpoAndroidCommand(cwd) : "cd android && ./gradlew assembleDebug",
+      buildCommand: managed ? managedExpoAndroidCommand(cwd) : `${bareInstallPrefix(cwd, "android")}cd android && ./gradlew assembleDebug`,
       artifact: ANDROID_ARTIFACT,
       metroCommand
     };
   }
   if (isManagedExpo(cwd, "ios")) {
-    const name = managedExpoIosName(cwd);
+    const name = managedExpoIosName(cwd, evaluatedIosName);
     return {
       buildCommand: name ? managedExpoIosCommand(cwd, name) : void 0,
       artifact: IOS_ARTIFACT,
@@ -895,14 +909,14 @@ function defaultsFor(cwd, platform) {
   }
   const ws = iosWorkspaceName(cwd);
   return {
-    buildCommand: ws ? `xcodebuild -workspace ios/${ws}.xcworkspace -scheme ${ws} -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build` : void 0,
+    buildCommand: ws ? `${bareInstallPrefix(cwd, "ios")}xcodebuild -workspace ios/${ws}.xcworkspace -scheme ${ws} -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build CODE_SIGNING_ALLOWED=NO` : void 0,
     artifact: IOS_ARTIFACT,
     metroCommand
   };
 }
 var ANDROID_PRODUCTION_ARTIFACT = "android/app/build/outputs/bundle/release/*.aab";
 function androidProductionCommand(cwd) {
-  return `${installCommand(cwd)} && cd android && ./gradlew bundleRelease`;
+  return `${bareInstallPrefix(cwd, "android")}cd android && ./gradlew bundleRelease`;
 }
 var IOS_PRODUCTION_ARTIFACT = "ios/build/*.ipa";
 function managedExpoAndroidProductionCommand(cwd) {
@@ -911,10 +925,13 @@ function managedExpoAndroidProductionCommand(cwd) {
 function expoSanitizedName(name) {
   return name.replace(/[\W_]+/g, "").normalize("NFD").replace(/[\u0300-\u036f]/g, "");
 }
-function managedExpoIosName(cwd) {
-  if (existsSync3(join5(cwd, "app.config.js")) || existsSync3(join5(cwd, "app.config.ts"))) {
-    return null;
-  }
+var DYNAMIC_EXPO_CONFIGS = ["app.config.ts", "app.config.js", "app.config.mjs", "app.config.cjs"];
+function dynamicExpoConfig(cwd) {
+  return DYNAMIC_EXPO_CONFIGS.find((f) => existsSync3(join5(cwd, f)));
+}
+function managedExpoIosName(cwd, evaluatedName) {
+  if (evaluatedName !== void 0) return expoSanitizedName(evaluatedName) || null;
+  if (dynamicExpoConfig(cwd)) return null;
   const raw = readJson(cwd, "app.config.json") ?? readJson(cwd, "app.json");
   if (!raw) return null;
   const config = "expo" in raw ? raw.expo : raw;
@@ -929,7 +946,10 @@ function iosArchiveExportCommand(ws) {
   const exportCmd = `xcodebuild -exportArchive -archivePath ${archivePath} -exportPath ios/build -exportOptionsPlist "$VIBEVIEW_EXPORT_OPTIONS_PLIST"`;
   return `${archiveCmd} && ${exportCmd}`;
 }
-function productionDefaultsFor(cwd, platform) {
+function managedExpoIosProductionCommand(cwd, name) {
+  return `${installCommand(cwd)} && npx expo prebuild --platform ios && ` + iosArchiveExportCommand(name);
+}
+function productionDefaultsFor(cwd, platform, evaluatedIosName) {
   if (platform === "android" || platform === "androidtv") {
     return {
       buildCommand: isManagedExpo(cwd, "android") ? managedExpoAndroidProductionCommand(cwd) : androidProductionCommand(cwd),
@@ -941,17 +961,17 @@ function productionDefaultsFor(cwd, platform) {
   }
   if (platform === "ios") {
     if (isManagedExpo(cwd, "ios")) {
-      const name = managedExpoIosName(cwd);
+      const name = managedExpoIosName(cwd, evaluatedIosName);
       if (!name) return { artifact: IOS_PRODUCTION_ARTIFACT };
       return {
-        buildCommand: `${installCommand(cwd)} && npx expo prebuild --platform ios && ` + iosArchiveExportCommand(name),
+        buildCommand: managedExpoIosProductionCommand(cwd, name),
         artifact: IOS_PRODUCTION_ARTIFACT
       };
     }
     const ws = iosWorkspaceName(cwd);
     if (!ws) return { artifact: IOS_PRODUCTION_ARTIFACT };
     return {
-      buildCommand: `${installCommand(cwd)} && ${iosArchiveExportCommand(ws)}`,
+      buildCommand: `${bareInstallPrefix(cwd, "ios")}${iosArchiveExportCommand(ws)}`,
       artifact: IOS_PRODUCTION_ARTIFACT
     };
   }
@@ -980,36 +1000,65 @@ function pbxprojText(cwd) {
     return null;
   }
 }
-var readExpoConfig = (cwd) => {
+function parseExpoConfigJson(stdout) {
+  const lines = stdout.trim().split("\n");
+  for (const text of [stdout, lines[lines.length - 1]]) {
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+var EXPO_CONFIG_TIMEOUT_MS = 3e4;
+var readExpoConfig = (cwd, timeoutMs = EXPO_CONFIG_TIMEOUT_MS) => {
   const cli = join5(cwd, "node_modules", "expo", "bin", "cli");
   if (!existsSync3(cli)) {
-    return Promise.reject(new Error("Expo is not installed in this project (node_modules/expo)"));
+    return Promise.reject(
+      new Error("Expo isn't installed in this project yet (run your install command first)")
+    );
   }
   return new Promise((resolve, reject) => {
-    execFile(
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const child = execFile(
       process.execPath,
       [cli, "config", "--json", "--type", "public"],
       {
         cwd,
-        timeout: 3e4,
         maxBuffer: 8 * 1024 * 1024,
         env: { ...process.env, EXPO_NO_TELEMETRY: "1", CI: "1" }
       },
       (err, stdout, stderr) => {
         if (err) {
           const why = String(stderr || err.message).split("\n").map((l) => l.trim()).find((l) => l.length > 0);
-          reject(new Error(`expo config failed${why ? `: ${why}` : ""}`));
+          settle(() => reject(new Error(`expo config failed${why ? `: ${why}` : ""}`)));
           return;
         }
-        try {
-          const parsed = JSON.parse(stdout);
-          if (parsed && typeof parsed === "object") resolve(parsed);
-          else reject(new Error("expo config printed no config"));
-        } catch {
-          reject(new Error("expo config printed something that is not JSON"));
-        }
+        const parsed = parseExpoConfigJson(stdout);
+        settle(
+          () => parsed ? resolve(parsed) : reject(new Error("expo config printed something that is not JSON"))
+        );
       }
     );
+    child.stdin?.end();
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      settle(
+        () => reject(new Error(`expo config timed out after ${Math.round(timeoutMs / 1e3)} s`))
+      );
+    }, timeoutMs);
+    timer.unref();
   });
 };
 async function localAppIdentity(cwd, platform, readConfig = readExpoConfig) {
@@ -1020,9 +1069,7 @@ async function localAppIdentity(cwd, platform, readConfig = readExpoConfig) {
   let version = null;
   let bundleId = null;
   let versionUnreadable = null;
-  const dynamicName = ["app.config.ts", "app.config.js", "app.config.mjs", "app.config.cjs"].find(
-    (f) => existsSync3(join5(cwd, f))
-  );
+  const dynamicName = dynamicExpoConfig(cwd);
   const staticRaw = readJson(cwd, "app.config.json") ?? readJson(cwd, "app.json");
   const isExpo = Boolean(dynamicName) || staticRaw !== null && "expo" in staticRaw || existsSync3(join5(cwd, "node_modules", "expo", "package.json"));
   let expo = null;
@@ -1061,6 +1108,41 @@ async function localAppIdentity(cwd, platform, readConfig = readExpoConfig) {
   }
   return { reactNative, version, bundleId, versionUnreadable: version ? null : versionUnreadable };
 }
+var evaluatedNameCache = /* @__PURE__ */ new Map();
+function evaluatedExpoName(cwd, readConfig, onEvaluate) {
+  const cached = evaluatedNameCache.get(cwd);
+  if (cached) return cached;
+  onEvaluate?.();
+  const pending = Promise.resolve().then(() => readConfig(cwd)).then(
+    (config) => typeof config.name === "string" ? { name: config.name } : { error: "the resolved config has no name" },
+    (err) => ({
+      error: err instanceof Error ? err.message : String(err)
+    })
+  );
+  evaluatedNameCache.set(cwd, pending);
+  return pending;
+}
+async function resolvedDefaultsFor(cwd, platform, opts = {}) {
+  const { production = false, readConfig = (c) => readExpoConfig(c), onEvaluate } = opts;
+  const base = production ? productionDefaultsFor : defaultsFor;
+  const dynamic = dynamicExpoConfig(cwd);
+  if (platform !== "ios" || !dynamic || !isManagedExpo(cwd, "ios")) {
+    return base(cwd, platform);
+  }
+  const evaluated = await evaluatedExpoName(cwd, readConfig, onEvaluate);
+  if ("error" in evaluated) {
+    return { ...base(cwd, platform), evaluatedConfig: dynamic, evaluationError: evaluated.error };
+  }
+  const named = base(cwd, platform, evaluated.name);
+  if (!named.buildCommand) {
+    return {
+      ...named,
+      evaluatedConfig: dynamic,
+      evaluationError: `the name "${evaluated.name}" has no letters or digits`
+    };
+  }
+  return { ...named, evaluatedConfig: dynamic };
+}
 
 // src/lib/dev-setup.ts
 function platformChoices(cwd) {
@@ -1095,6 +1177,37 @@ function fillLaterHint(skipped, platform) {
   }
   return lines.join("\n");
 }
+async function promptDefaults(cwd, platform, opts = {}) {
+  const progress = {};
+  try {
+    return await resolvedDefaultsFor(cwd, platform, {
+      ...opts,
+      onEvaluate: () => {
+        progress.spinner = createSpinner("Reading Expo config\u2026").start();
+      }
+    });
+  } finally {
+    progress.spinner?.stop();
+  }
+}
+function evaluatedConfigNote(cwd, defaults) {
+  const file = defaults.evaluatedConfig;
+  if (!file) return;
+  if (defaults.evaluationError) {
+    console.log(chalk2.dim(`  Couldn't read the name from ${file}: ${defaults.evaluationError}`));
+    return;
+  }
+  if (notedConfigDirs.has(cwd)) return;
+  notedConfigDirs.add(cwd);
+  console.log(
+    chalk2.dim(
+      `  The iOS name was read from ${file} using your local environment.
+  If it depends on environment variables, set the same ones for the cloud build
+  (build.env, or build variables).`
+    )
+  );
+}
+var notedConfigDirs = /* @__PURE__ */ new Set();
 async function commandSelect(message, detected) {
   const choices = [];
   if (detected) choices.push({ value: "default", name: `Use detected default: ${detected}` });
@@ -1103,7 +1216,8 @@ async function commandSelect(message, detected) {
   return select({ message, choices });
 }
 async function promptBuildConfig(cwd, platform) {
-  const defaults = defaultsFor(cwd, platform);
+  const defaults = await promptDefaults(cwd, platform);
+  evaluatedConfigNote(cwd, defaults);
   const choice = await commandSelect(`Build command for ${platform}`, defaults.buildCommand);
   if (choice === "skip") return null;
   if (choice === "default") {
@@ -1123,7 +1237,8 @@ async function promptBuildConfig(cwd, platform) {
   return { command, artifact };
 }
 async function promptProductionBuildConfig(cwd, platform) {
-  const defaults = productionDefaultsFor(cwd, platform);
+  const defaults = await promptDefaults(cwd, platform, { production: true });
+  evaluatedConfigNote(cwd, defaults);
   const choice = await commandSelect(
     `Production build command for ${platform}`,
     defaults.buildCommand
@@ -1329,6 +1444,203 @@ function runTar(args) {
   });
 }
 
+// src/lib/build-preflight.ts
+import { execFile as execFile3 } from "child_process";
+import { realpathSync, statSync as statSync4 } from "fs";
+import { dirname as dirname2, isAbsolute, join as join7, relative } from "path";
+import { parse } from "shell-quote";
+var DIRECTORY_CHANGERS = /* @__PURE__ */ new Set(["cd", "pushd"]);
+var DIRECTORY_FLAGS = /^(--cwd|--prefix|--dir|-C)(=|$)/;
+var VALUE_FLAGS = /^(--cwd|--prefix|--dir|-C|--loglevel|--registry|--workspace|--filter)$/;
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["-g", "--global", "--location=global"]);
+var SEPARATORS = /* @__PURE__ */ new Set(["&&", "||", ";", ";;", "|", "|&", "&", "(", ")"]);
+var REDIRECTIONS = /* @__PURE__ */ new Set([">", ">>", "<", ">&", "<&", "&>", "&>>", ">|", "<>"]);
+var WRAPPERS = /* @__PURE__ */ new Set(["time", "env", "corepack", "command", "exec", "nohup"]);
+var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "npx", "yarn", "pnpm", "pnpx", "bun", "bunx"]);
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function simpleCommands(command) {
+  const out = [];
+  const flush = (words) => {
+    while (words.length > 0 && ASSIGNMENT.test(words[0])) words.shift();
+    while (words.length > 0 && WRAPPERS.has(words[0])) {
+      words.shift();
+      while (words.length > 0 && (words[0].startsWith("-") || ASSIGNMENT.test(words[0]))) {
+        words.shift();
+      }
+    }
+    if (words.length === 0) return;
+    const base = words[0].replace(/@[^/]*$/, "");
+    const program = JS_PACKAGE_MANAGERS.has(base) ? base : words[0];
+    out.push({ program, args: words.slice(1) });
+  };
+  for (const line of command.replace(/\\\r?\n/g, " ").split(/\r?\n/)) {
+    let tokens;
+    try {
+      tokens = parse(line, (name) => `$${name}`);
+    } catch {
+      continue;
+    }
+    let words = [];
+    let redirectTarget = false;
+    for (const t of tokens) {
+      if (typeof t === "string") {
+        if (redirectTarget) {
+          redirectTarget = false;
+          continue;
+        }
+        if (t === "{" || t === "}") flush(words.splice(0));
+        else if (t.length > 0) words.push(t);
+      } else if ("comment" in t) {
+        break;
+      } else if ("op" in t && t.op === "glob") {
+        words.push(t.pattern);
+      } else if ("op" in t && SEPARATORS.has(t.op)) {
+        flush(words);
+        words = [];
+      } else if ("op" in t && REDIRECTIONS.has(t.op)) {
+        if (words.length > 1 && /^\d+$/.test(words[words.length - 1])) words.pop();
+        redirectTarget = true;
+      }
+    }
+    flush(words);
+  }
+  return out;
+}
+function positionals(args) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (VALUE_FLAGS.test(a)) i++;
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+var isGlobal = (args) => args.some((a) => GLOBAL_FLAGS.has(a));
+var VERSION_OR_HELP = /* @__PURE__ */ new Set(["-v", "--version", "-h", "--help"]);
+var NPM_INSTALL_VERBS = /* @__PURE__ */ new Set([
+  "ci",
+  "clean-install",
+  "install-clean",
+  "install",
+  "i",
+  "add",
+  "install-test",
+  "it"
+]);
+var NEEDS_MANIFEST_VERBS = /* @__PURE__ */ new Set([
+  "ci",
+  "clean-install",
+  "install-clean",
+  "install-test",
+  "it",
+  "run",
+  "run-script"
+]);
+function installsInStep({ program, args }) {
+  if (isGlobal(args)) return false;
+  const [verb, ...rest] = positionals(args);
+  if (program === "yarn") {
+    if (verb === void 0) return !args.some((a) => VERSION_OR_HELP.has(a));
+    if (verb === "install" || verb === "add") return true;
+    return verb === "workspaces" && rest[0] === "focus";
+  }
+  if (program === "npm" || program === "pnpm" || program === "bun") {
+    return verb !== void 0 && NPM_INSTALL_VERBS.has(verb);
+  }
+  return false;
+}
+function needsManifest({ program, args }) {
+  if (isGlobal(args) || args.some((a) => DIRECTORY_FLAGS.test(a))) return false;
+  const [verb, ...rest] = positionals(args);
+  if (program === "yarn") {
+    if (verb === void 0) return !args.some((a) => VERSION_OR_HELP.has(a));
+    if (verb === "install" || verb === "run") return true;
+    return verb === "workspaces" && rest[0] === "focus";
+  }
+  if (program === "npm" || program === "pnpm" || program === "bun") {
+    if (verb === void 0) return false;
+    if (NEEDS_MANIFEST_VERBS.has(verb)) return true;
+    return (verb === "install" || verb === "i") && rest.length === 0;
+  }
+  return false;
+}
+function packageManagerAtRoot(command) {
+  for (const step of simpleCommands(command)) {
+    if (DIRECTORY_CHANGERS.has(step.program)) return null;
+    if (JS_PACKAGE_MANAGERS.has(step.program) && positionals(step.args)[0] === "init") return null;
+    if (needsManifest(step)) return step.program;
+  }
+  return null;
+}
+function installsDependencies(command) {
+  return simpleCommands(command).some(installsInStep);
+}
+function missingPackageJsonError(command, files, dir) {
+  const pm = packageManagerAtRoot(command);
+  if (!pm || files.has("package.json")) return null;
+  return `No package.json in ${dir}. Run vibeview build from your project root. (Your build command runs \`${pm}\` there; nothing was uploaded or charged.)`;
+}
+function missingInstallWarning(command, files) {
+  const hit = JS_LOCKFILE_INSTALLS.find(([lockfile]) => files.has(lockfile));
+  if (!hit || files.has(".pnp.cjs") || installsDependencies(command)) return null;
+  return `Your build command doesn't install dependencies; node_modules is never uploaded, so the build will likely fail. Add \`${hit[1]} &&\` at the start.`;
+}
+function missingLockfileWarning(command, files) {
+  if (!files.has("package.json")) return null;
+  if (JS_LOCKFILE_INSTALLS.some(([lockfile]) => files.has(lockfile))) return null;
+  if (!installsDependencies(command)) return null;
+  return "No lockfile in the upload (yarn.lock, package-lock.json, pnpm-lock.yaml): a frozen install (`npm ci`, `--immutable`, `--frozen-lockfile`) will fail, and any other install resolves fresh versions. Commit your lockfile, or run vibeview build from the directory that has it.";
+}
+function bunWarning(command) {
+  const step = simpleCommands(command).find((s) => s.program === "bun" || s.program === "bunx");
+  if (!step) return null;
+  return `Your build command runs \`${step.program}\`, but cloud builders don't have Bun, so that step will fail unless your command installs Bun first. Use npm, yarn or pnpm instead.`;
+}
+function buildCommandWarnings(command, files) {
+  return [
+    bunWarning(command),
+    missingInstallWarning(command, files),
+    missingLockfileWarning(command, files)
+  ].filter((w) => w !== null);
+}
+function projectRootHint(cwd, gitRoot, files, hasPackageJson = (dir) => isFile2(join7(dir, "package.json"))) {
+  if (!gitRoot || files.has("package.json")) return null;
+  cwd = realPathOr(cwd);
+  gitRoot = realPathOr(gitRoot);
+  const rel = relative(gitRoot, cwd);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  for (let dir = dirname2(cwd); ; dir = dirname2(dir)) {
+    if (hasPackageJson(dir)) {
+      return `You're running from ${cwd}; the project root looks like ${dir}. Only ${cwd} will be uploaded.`;
+    }
+    if (dir === gitRoot || dir === dirname2(dir)) return null;
+  }
+}
+function realPathOr(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function isFile2(path) {
+  try {
+    return statSync4(path).isFile();
+  } catch {
+    return false;
+  }
+}
+async function gitToplevel(cwd) {
+  return new Promise((resolve) => {
+    execFile3("git", ["rev-parse", "--show-toplevel"], { cwd }, (err, stdout) => {
+      resolve(err ? null : stdout.trim() || null);
+    });
+  });
+}
+
 // src/commands/build.ts
 var CLOUD_PLATFORMS = ["ios", "android", "tvos", "androidtv"];
 var PRODUCTION_SIGNING_PLATFORMS = ["ios", "android", "androidtv", "tvos"];
@@ -1795,6 +2107,25 @@ async function runCloudBuildCommand(cwd, cfgRef, opts, deps) {
       }
       throw err;
     }
+    const uploaded = new Set(files);
+    const warnings = /* @__PURE__ */ new Map();
+    for (const p of platforms) {
+      const command = productionBuilds.get(p)?.command ?? cfg.platforms[p].build.command;
+      const missingPkg = missingPackageJsonError(command, uploaded, cwd);
+      if (missingPkg) fail(opts, missingPkg, "no_package_json");
+      for (const w of buildCommandWarnings(command, uploaded)) {
+        warnings.set(w, [...warnings.get(w) ?? [], p]);
+      }
+    }
+    const rootHint = projectRootHint(cwd, await (d.gitToplevel ?? gitToplevel)(cwd), uploaded);
+    if (rootHint) warnings.set(rootHint, [...platforms]);
+    for (const [message, ps] of warnings) {
+      for (const p of ps) emitCloud(opts.json, { event: "warning", platform: p, message });
+      if (!opts.json) {
+        const prefix = platforms.length > 1 && ps.length < platforms.length ? `${ps.join(", ")}: ` : "";
+        console.error(chalk3.yellow(`\u26A0 ${prefix}${message}`));
+      }
+    }
     const packSpinner = !opts.json ? createSpinner(`packing source (${files.length} files)`) : null;
     packSpinner?.start();
     let tarPath;
@@ -2173,7 +2504,7 @@ your build command must produce a zip \u2014 use the package/zip step, not deplo
 // src/commands/dev.ts
 import { spawn as spawn4 } from "child_process";
 import { createWriteStream, mkdirSync as mkdirSync5 } 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 chalk4 from "chalk";
@@ -2376,14 +2707,14 @@ import { createInterface as createInterface2 } from "readline";
 
 // src/lib/metro-state.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 var STATE_DIR2 = ".vibeview";
 var STATE_FILE2 = "metro-state.json";
 function statePath2(cwd) {
-  return join7(cwd, STATE_DIR2, STATE_FILE2);
+  return join8(cwd, STATE_DIR2, STATE_FILE2);
 }
 function metroLogPath(cwd) {
-  return join7(cwd, STATE_DIR2, "metro.log");
+  return join8(cwd, STATE_DIR2, "metro.log");
 }
 function isPidAlive2(pid) {
   try {
@@ -2395,7 +2726,7 @@ function isPidAlive2(pid) {
 }
 function writeMetroState(cwd, state) {
   const path = statePath2(cwd);
-  mkdirSync4(dirname2(path), { recursive: true });
+  mkdirSync4(dirname3(path), { recursive: true });
   writeFileSync6(path, JSON.stringify(state, null, 2) + "\n");
 }
 function readMetroState(cwd) {
@@ -2534,7 +2865,7 @@ async function waitFor(cond, timeoutMs, everyMs) {
 
 // src/lib/reload-loop.ts
 import { watch } from "fs";
-import { basename, dirname as dirname3 } from "path";
+import { basename, dirname as dirname4 } from "path";
 function createReloadLoop(deps) {
   let inFlight = null;
   let pendingFollowUp = false;
@@ -2615,11 +2946,11 @@ function isIgnoredWatchPath(relPath, artifact, userIgnore = []) {
   if (IGNORED_FILES.includes(rel)) return true;
   if (userIgnore.some((entry) => isUnderPath(rel, entry))) return true;
   const artifactPattern = artifact.replace(/\\/g, "/").replace(/^\.\//, "");
-  const artifactDir = dirname3(artifactPattern);
+  const artifactDir = dirname4(artifactPattern);
   if (artifactDir !== "." && (rel === artifactDir || rel.startsWith(`${artifactDir}/`))) {
     return true;
   }
-  if (dirname3(rel) !== artifactDir) return false;
+  if (dirname4(rel) !== artifactDir) return false;
   const name = basename(artifactPattern);
   const re = new RegExp(`^${name.split("*").map(escapeRegExp).join(".*")}$`);
   return re.test(basename(rel));
@@ -3497,7 +3828,7 @@ async function runDevInProcess(opts) {
       const captureMetroLine = (line) => {
         try {
           if (!metroLogStream) {
-            mkdirSync5(dirname4(metroLogPath(process.cwd())), { recursive: true });
+            mkdirSync5(dirname5(metroLogPath(process.cwd())), { recursive: true });
             metroLogStream = createWriteStream(metroLogPath(process.cwd()), { flags: "w" });
           }
           metroLogStream.write(line.replace(/^\[metro\] /, "") + "\n");
@@ -4618,9 +4949,9 @@ function flagKey(cli) {
   const name = cli.replace(/^--/, "");
   return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
-function buildToolCall(cmd, positionals, opts) {
+function buildToolCall(cmd, positionals2, opts) {
   if (cmd.verb === "tap") {
-    const target = positionals[0];
+    const target = positionals2[0];
     if (!target) throw new Error('tap requires a target: an element ref (@e5) or "x,y"');
     const coords = parseCoords(target);
     if (coords) {
@@ -4635,7 +4966,7 @@ function buildToolCall(cmd, positionals, opts) {
     return { tool: "tap", args: { ref: stripRef(target) } };
   }
   if (cmd.verb === "long-press") {
-    const target = positionals[0];
+    const target = positionals2[0];
     if (!target) throw new Error("long-press requires a ref, e.g. @e5");
     if (parseCoords(target) || target.includes(",") && !REF_RE.test(target)) {
       throw new Error(
@@ -4649,8 +4980,8 @@ function buildToolCall(cmd, positionals, opts) {
     return { tool: cmd.tool, args: args2 };
   }
   if (cmd.verb === "drag") {
-    const from = positionals[0];
-    const to = positionals[1];
+    const from = positionals2[0];
+    const to = positionals2[1];
     if (!from || !to) {
       throw new Error('drag requires two targets: <from> <to>, each an element ref (@e5) or "x,y"');
     }
@@ -4691,7 +5022,7 @@ function buildToolCall(cmd, positionals, opts) {
     return { tool: cmd.tool, args: args2 };
   }
   if (cmd.verb === "scroll") {
-    const direction = positionals[0];
+    const direction = positionals2[0];
     const valid = ["up", "down", "left", "right"];
     if (!direction || !valid.includes(direction)) {
       throw new Error(`scroll: direction must be one of ${valid.join(", ")}, got "${direction}"`);
@@ -4699,7 +5030,7 @@ function buildToolCall(cmd, positionals, opts) {
     return { tool: cmd.tool, args: { name: `scroll_${direction}` } };
   }
   if (cmd.verb === "swipe") {
-    const direction = positionals[0];
+    const direction = positionals2[0];
     const valid = ["up", "down", "left", "right"];
     if (!direction || !valid.includes(direction)) {
       throw new Error(`swipe: direction must be one of ${valid.join(", ")}, got "${direction}"`);
@@ -4711,7 +5042,7 @@ function buildToolCall(cmd, positionals, opts) {
     return { tool: cmd.tool, args: args2 };
   }
   if (cmd.verb === "set-posture") {
-    const hasPosture = positionals[0] !== void 0 && positionals[0] !== "";
+    const hasPosture = positionals2[0] !== void 0 && positionals2[0] !== "";
     const hasAngle = opts.angle !== void 0 && opts.angle !== "";
     if (hasPosture === hasAngle) {
       throw new FlagError(
@@ -4724,7 +5055,7 @@ function buildToolCall(cmd, positionals, opts) {
   for (const param of cmd.params) {
     let raw;
     if (param.cli === "positional") {
-      raw = positionals[positionalIndex];
+      raw = positionals2[positionalIndex];
       positionalIndex += 1;
     } else {
       const key = flagKey(param.cli);
@@ -4774,7 +5105,7 @@ var NON_USE_TOOLS = /* @__PURE__ */ new Set([
 function countsAsUse(tool) {
   return !NON_USE_TOOLS.has(tool);
 }
-async function runAgentVerb(cmd, positionals, opts) {
+async function runAgentVerb(cmd, positionals2, opts) {
   const { token, baseUrl } = resolveAuth(opts);
   const sessionId = opts.session || readDevState(process.cwd())?.session_id;
   if (!sessionId) {
@@ -4783,7 +5114,7 @@ async function runAgentVerb(cmd, positionals, opts) {
   }
   let call;
   try {
-    call = buildToolCall(cmd, positionals, opts);
+    call = buildToolCall(cmd, positionals2, opts);
   } catch (err) {
     process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
 `);

package/dist/cli.js

@@ -25,7 +25,7 @@ import {
   readMetroState,
   recordDevUse,
   runAgentVerb
-} from "./chunk-VFCG4U7V.js";
+} from "./chunk-NJ2IXB5H.js";
 import {
   ApiClient,
   ApiStatusError,
@@ -4147,7 +4147,7 @@ program.command("dev-reload").description(
 program.command("mcp").description(
   "Run an MCP stdio server exposing the agent verbs (tap, swipe, type, ...) plus dev_start/dev_stop/dev_reload as tools"
 ).option("--token <token>", "API token (or set VIBEVIEW_API_TOKEN)").action(async (opts) => {
-  const { runMcpServer } = await import("./server-2CDIRTBV.js");
+  const { runMcpServer } = await import("./server-DF3CDWL4.js");
   await runMcpServer({ ...opts, version: pkg.version });
 });
 program.command("agent-setup").description(

package/dist/{server-2CDIRTBV.js → server-DF3CDWL4.js}

@@ -28,7 +28,7 @@ import {
   renderEnvelope,
   resolveMetro,
   startDevSession
-} from "./chunk-VFCG4U7V.js";
+} from "./chunk-NJ2IXB5H.js";
 import {
   ApiClient,
   NotFoundError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeview",
-  "version": "0.36.1",
+  "version": "0.37.1",
   "description": "VibeView CLI -- run your app on cloud iOS simulators, Android emulators, Apple TV, Android TV and Roku devices: a React Native dev loop, device control for you or your coding agent (CLI or MCP), and tests from CI",
   "mcpName": "io.github.vibeview/vibeview",
   "type": "module",
@@ -33,11 +33,13 @@
     "ignore": "^7.0.0",
     "open": "^11.0.0",
     "ora": "^9.0.0",
+    "shell-quote": "^1.8.3",
     "ws": "^8.18.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/shell-quote": "^1.7.5",
     "@types/ws": "^8.5.0",
     "dotenv": "^16.4.5",
     "tsup": "^8.0.0",