vibeview 0.35.0 → 0.36.1

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

@@ -585,6 +585,73 @@ function clearDevState(cwd) {
   if (existsSync(path)) {
     rmSync2(path, { force: true });
   }
+  rmSync2(join2(cwd, STATE_DIR, "dev-use.json"), { force: true });
+}
+function clearDevStateIfOwned(cwd, pid) {
+  const found = readDevStateFile(cwd);
+  if (found && found.state.pid === pid) clearDevState(cwd);
+}
+
+// src/lib/dev-use.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync,
+  rmSync as rmSync3,
+  statSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var STALE_MS = 7 * 24 * 60 * 60 * 1e3;
+function useDir() {
+  return join3(homedir(), ".vibeview", "dev-use");
+}
+function notePath(sessionId) {
+  if (!/^[A-Za-z0-9_-]{1,128}$/.test(sessionId)) return null;
+  return join3(useDir(), `${sessionId}.json`);
+}
+function registerDevUse(sessionId) {
+  const path = notePath(sessionId);
+  if (!path) return;
+  try {
+    mkdirSync2(useDir(), { recursive: true });
+    writeFileSync3(path, JSON.stringify({ at: 0 }) + "\n");
+    const now = Date.now();
+    for (const name of readdirSync(useDir())) {
+      const p = join3(useDir(), name);
+      try {
+        if (now - statSync(p).mtimeMs > STALE_MS) rmSync3(p, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function recordDevUse(sessionId, at = Date.now()) {
+  const path = notePath(sessionId);
+  if (!path) return;
+  try {
+    if (!existsSync2(path)) return;
+    writeFileSync3(path, JSON.stringify({ at }) + "\n");
+  } catch {
+  }
+}
+function readDevUse(sessionId) {
+  const path = notePath(sessionId);
+  if (!path) return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    return typeof parsed?.at === "number" ? parsed.at : null;
+  } catch {
+    return null;
+  }
+}
+function clearDevUse(sessionId) {
+  const path = notePath(sessionId);
+  if (!path) return;
+  rmSync3(path, { force: true });
 }
 
 // src/lib/metro-check.ts
@@ -601,17 +668,17 @@ async function checkMetro(port, timeoutMs = 1500) {
 }
 
 // src/lib/local-config.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
 var DIR = ".vibeview";
 var FILE2 = "local.json";
 function localConfigPath(cwd) {
-  return join3(cwd, DIR, FILE2);
+  return join4(cwd, DIR, FILE2);
 }
 function loadLocalDevConfig(cwd) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync3(localConfigPath(cwd), "utf-8"));
+    parsed = JSON.parse(readFileSync4(localConfigPath(cwd), "utf-8"));
   } catch {
     return {};
   }
@@ -651,16 +718,16 @@ function saveLocalDevConfig(cwd, cfg) {
   const pruned = prune(cfg);
   const target = localConfigPath(cwd);
   if (!pruned.defaultPlatform && !pruned.platforms) {
-    rmSync3(target, { force: true });
+    rmSync4(target, { force: true });
     return;
   }
-  mkdirSync2(join3(cwd, DIR), { recursive: true });
+  mkdirSync3(join4(cwd, DIR), { recursive: true });
   const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync3(tmp, JSON.stringify(pruned, null, 2) + "\n");
+    writeFileSync4(tmp, JSON.stringify(pruned, null, 2) + "\n");
     renameSync2(tmp, target);
   } catch (err) {
-    rmSync3(tmp, { force: true });
+    rmSync4(tmp, { force: true });
     throw err;
   }
   ensureGitignored(cwd);
@@ -714,19 +781,19 @@ import { input, select } from "@inquirer/prompts";
 
 // src/lib/project-detect.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
 import ignore from "ignore";
 function readJson(cwd, name) {
   try {
-    return JSON.parse(readFileSync4(join4(cwd, name), "utf-8"));
+    return JSON.parse(readFileSync5(join5(cwd, name), "utf-8"));
   } catch {
     return null;
   }
 }
 function isFile(path) {
   try {
-    return statSync(path).isFile();
+    return statSync2(path).isFile();
   } catch {
     return false;
   }
@@ -734,19 +801,19 @@ function isFile(path) {
 function detectFlavor(cwd) {
   let deps = {};
   try {
-    const pkg = JSON.parse(readFileSync4(join4(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync5(join5(cwd, "package.json"), "utf-8"));
     deps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
   }
   if ("expo" in deps) return "expo";
-  if (existsSync2(join4(cwd, "android", "gradlew")) || iosWorkspaceName(cwd)) return "bare-rn";
-  if (isFile(join4(cwd, "manifest"))) return "roku";
+  if (existsSync3(join5(cwd, "android", "gradlew")) || iosWorkspaceName(cwd)) return "bare-rn";
+  if (isFile(join5(cwd, "manifest"))) return "roku";
   return "unknown";
 }
 function nativeDirShipped(cwd, dir) {
-  if (!existsSync2(join4(cwd, dir))) return false;
+  if (!existsSync3(join5(cwd, dir))) return false;
   try {
-    const ig = ignore().add(readFileSync4(join4(cwd, ".gitignore"), "utf-8"));
+    const ig = ignore().add(readFileSync5(join5(cwd, ".gitignore"), "utf-8"));
     return !ig.ignores(`${dir}/`);
   } catch {
     return true;
@@ -762,7 +829,7 @@ function isManagedExpo(cwd, platform) {
 }
 function iosWorkspaceName(cwd) {
   try {
-    const found = readdirSync(join4(cwd, "ios")).find((f) => f.endsWith(".xcworkspace"));
+    const found = readdirSync2(join5(cwd, "ios")).find((f) => f.endsWith(".xcworkspace"));
     return found ? found.replace(/\.xcworkspace$/, "") : null;
   } catch {
     return null;
@@ -771,9 +838,9 @@ 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 (existsSync2(join4(cwd, "yarn.lock"))) return "yarn install --immutable";
-  if (existsSync2(join4(cwd, "pnpm-lock.yaml"))) return "pnpm install --frozen-lockfile";
-  if (existsSync2(join4(cwd, "package-lock.json"))) return "npm ci";
+  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";
 }
 function managedExpoAndroidCommand(cwd) {
@@ -787,7 +854,7 @@ var ROKU_ZIP_COMMAND = "zip -r out/channel.zip manifest source components images
 function rokuDefaults(cwd) {
   const pkg = readJson(cwd, "package.json");
   const scripts = pkg?.scripts ?? {};
-  const runner = existsSync2(join4(cwd, "yarn.lock")) ? "yarn" : "npm run";
+  const runner = existsSync3(join5(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"))
   );
@@ -845,7 +912,7 @@ function expoSanitizedName(name) {
   return name.replace(/[\W_]+/g, "").normalize("NFD").replace(/[\u0300-\u036f]/g, "");
 }
 function managedExpoIosName(cwd) {
-  if (existsSync2(join4(cwd, "app.config.js")) || existsSync2(join4(cwd, "app.config.ts"))) {
+  if (existsSync3(join5(cwd, "app.config.js")) || existsSync3(join5(cwd, "app.config.ts"))) {
     return null;
   }
   const raw = readJson(cwd, "app.config.json") ?? readJson(cwd, "app.json");
@@ -900,22 +967,22 @@ function uniqueMatch(text, re) {
 }
 function readText(path) {
   try {
-    return readFileSync4(path, "utf-8");
+    return readFileSync5(path, "utf-8");
   } catch {
     return null;
   }
 }
 function pbxprojText(cwd) {
   try {
-    const proj = readdirSync(join4(cwd, "ios")).find((f) => f.endsWith(".xcodeproj"));
-    return proj ? readText(join4(cwd, "ios", proj, "project.pbxproj")) : null;
+    const proj = readdirSync2(join5(cwd, "ios")).find((f) => f.endsWith(".xcodeproj"));
+    return proj ? readText(join5(cwd, "ios", proj, "project.pbxproj")) : null;
   } catch {
     return null;
   }
 }
 var readExpoConfig = (cwd) => {
-  const cli = join4(cwd, "node_modules", "expo", "bin", "cli");
-  if (!existsSync2(cli)) {
+  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 new Promise((resolve, reject) => {
@@ -954,12 +1021,12 @@ async function localAppIdentity(cwd, platform, readConfig = readExpoConfig) {
   let bundleId = null;
   let versionUnreadable = null;
   const dynamicName = ["app.config.ts", "app.config.js", "app.config.mjs", "app.config.cjs"].find(
-    (f) => existsSync2(join4(cwd, f))
+    (f) => existsSync3(join5(cwd, f))
   );
   const staticRaw = readJson(cwd, "app.config.json") ?? readJson(cwd, "app.json");
-  const isExpo = Boolean(dynamicName) || staticRaw !== null && "expo" in staticRaw || existsSync2(join4(cwd, "node_modules", "expo", "package.json"));
+  const isExpo = Boolean(dynamicName) || staticRaw !== null && "expo" in staticRaw || existsSync3(join5(cwd, "node_modules", "expo", "package.json"));
   let expo = null;
-  if (isExpo && (dynamicName || existsSync2(join4(cwd, "node_modules", "expo", "bin", "cli")))) {
+  if (isExpo && (dynamicName || existsSync3(join5(cwd, "node_modules", "expo", "bin", "cli")))) {
     try {
       expo = await readConfig(cwd);
     } catch (err) {
@@ -979,7 +1046,7 @@ async function localAppIdentity(cwd, platform, readConfig = readExpoConfig) {
     if (typeof id === "string") bundleId = id;
   }
   if (android && (!version || !bundleId)) {
-    const gradle = readText(join4(cwd, "android", "app", "build.gradle")) ?? readText(join4(cwd, "android", "app", "build.gradle.kts"));
+    const gradle = readText(join5(cwd, "android", "app", "build.gradle")) ?? readText(join5(cwd, "android", "app", "build.gradle.kts"));
     if (gradle) {
       version ??= uniqueMatch(gradle, /versionName\s*=?\s*["']([^"']+)["']/g);
       bundleId ??= uniqueMatch(gradle, /applicationId\s*=?\s*["']([^"']+)["']/g);
@@ -1003,7 +1070,7 @@ function platformChoices(cwd) {
     { value: "tvos", name: "Apple TV simulator" },
     { value: "androidtv", name: "Android TV emulator" }
   ];
-  if (detectFlavor(cwd) === "roku") choices.unshift({ value: "roku", name: "Roku (beta)" });
+  if (detectFlavor(cwd) === "roku") choices.unshift({ value: "roku", name: "Roku" });
   return choices;
 }
 function appsForPlatform(apps, platform) {
@@ -1094,9 +1161,9 @@ async function promptMetroCommand(cwd, platform) {
 
 // src/lib/source-pack.ts
 import { execFile as execFile2, spawn } from "child_process";
-import { lstatSync, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync4, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { lstatSync, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
 import { tmpdir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import ignore2 from "ignore";
 var NotAGitRepoError = class extends Error {
   constructor(message) {
@@ -1122,15 +1189,15 @@ 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");
+  const vvignorePath = join6(projectRoot, ".vvignore");
   if (statOrNull(vvignorePath)?.isFile()) {
-    const ig = ignore2().add(readFileSync5(vvignorePath, "utf-8"));
+    const ig = ignore2().add(readFileSync6(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));
+    const st = statOrNull(join6(projectRoot, relPath));
     if (!st) continue;
     result.push(relPath);
   }
@@ -1180,7 +1247,7 @@ async function packSource(projectRoot, files, opts = {}) {
   let totalBytes = 0;
   const sized = [];
   for (const relPath of files) {
-    const bytes = lstatSync(join5(projectRoot, relPath)).size;
+    const bytes = lstatSync(join6(projectRoot, relPath)).size;
     totalBytes += bytes;
     sized.push({ path: relPath, bytes });
   }
@@ -1191,14 +1258,14 @@ async function packSource(projectRoot, files, opts = {}) {
       largest
     );
   }
-  const tmpDir = mkdtempSync(join5(tmpdir(), "vibeview-source-pack-"));
-  const cleanup = () => rmSync4(tmpDir, { recursive: true, force: true });
+  const tmpDir = mkdtempSync(join6(tmpdir(), "vibeview-source-pack-"));
+  const cleanup = () => rmSync5(tmpDir, { recursive: true, force: true });
   try {
     const supportsNull = await probeTarNullSupport();
-    const tarPath = join5(tmpDir, "source.tgz");
+    const tarPath = join6(tmpDir, "source.tgz");
     if (supportsNull) {
-      const listPath = join5(tmpDir, "files.list");
-      writeFileSync4(listPath, files.map((f) => `${f}\0`).join(""));
+      const listPath = join6(tmpDir, "files.list");
+      writeFileSync5(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"));
@@ -1207,12 +1274,12 @@ async function packSource(projectRoot, files, opts = {}) {
           `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");
-      writeFileSync4(listPath, files.map((f) => `${f}
+      const listPath = join6(tmpDir, "files.list");
+      writeFileSync5(listPath, files.map((f) => `${f}
 `).join(""));
       await runTar(["-czf", tarPath, "-C", projectRoot, "-T", listPath]);
     }
-    const sizeBytes = statSync2(tarPath).size;
+    const sizeBytes = statSync3(tarPath).size;
     return { tarPath, sizeBytes, cleanup };
   } catch (err) {
     cleanup();
@@ -1228,12 +1295,12 @@ var nullSupportCache = null;
 function probeTarNullSupport() {
   if (!nullSupportCache) {
     nullSupportCache = new Promise((resolve) => {
-      const tmp = mkdtempSync(join5(tmpdir(), "vibeview-tar-probe-"));
-      const listPath = join5(tmp, "empty.list");
-      writeFileSync4(listPath, "");
-      const out = join5(tmp, "probe.tgz");
+      const tmp = mkdtempSync(join6(tmpdir(), "vibeview-tar-probe-"));
+      const listPath = join6(tmp, "empty.list");
+      writeFileSync5(listPath, "");
+      const out = join6(tmp, "probe.tgz");
       execFile2("tar", ["-czf", out, "-C", tmp, "--null", "-T", listPath], (err) => {
-        rmSync4(tmp, { recursive: true, force: true });
+        rmSync5(tmp, { recursive: true, force: true });
         resolve(!err);
       });
     });
@@ -2105,7 +2172,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 mkdirSync4 } from "fs";
+import { createWriteStream, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname4 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { select as select3 } from "@inquirer/prompts";
@@ -2156,7 +2223,8 @@ function redactSecrets(text) {
 }
 
 // src/lib/tunnel-client.ts
-var FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([4008, 4009]);
+var TUNNEL_REPLACED_CLOSE_CODE = 4008;
+var FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([TUNNEL_REPLACED_CLOSE_CODE, 4009]);
 var MAX_BACKOFF_MS = 8e3;
 var STABLE_MS = 2e3;
 var TunnelClient = class {
@@ -2222,12 +2290,18 @@ var TunnelClient = class {
       const heldMs = Date.now() - openedAt;
       const why = reason?.length ? ` reason="${reason.toString()}"` : "";
       this.debug(`ws#${conn} close code=${code}${why} heldMs=${heldMs}`);
+      if (this.ws !== ws) return;
       if (this.stableTimer) {
         clearTimeout(this.stableTimer);
         this.stableTimer = null;
       }
       for (const s of this.sockets.values()) s.destroy();
       this.sockets.clear();
+      if (!this.stopped && code === TUNNEL_REPLACED_CLOSE_CODE) {
+        this.stopped = true;
+        this.setState("replaced");
+        return;
+      }
       if (this.stopped || FATAL_CLOSE_CODES.has(code)) {
         this.stopped = true;
         this.setState("closed");
@@ -2301,15 +2375,15 @@ import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 
 // src/lib/metro-state.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname2, join as join6 } from "path";
+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";
 var STATE_DIR2 = ".vibeview";
 var STATE_FILE2 = "metro-state.json";
 function statePath2(cwd) {
-  return join6(cwd, STATE_DIR2, STATE_FILE2);
+  return join7(cwd, STATE_DIR2, STATE_FILE2);
 }
 function metroLogPath(cwd) {
-  return join6(cwd, STATE_DIR2, "metro.log");
+  return join7(cwd, STATE_DIR2, "metro.log");
 }
 function isPidAlive2(pid) {
   try {
@@ -2321,13 +2395,13 @@ function isPidAlive2(pid) {
 }
 function writeMetroState(cwd, state) {
   const path = statePath2(cwd);
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(state, null, 2) + "\n");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync6(path, JSON.stringify(state, null, 2) + "\n");
 }
 function readMetroState(cwd) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(statePath2(cwd), "utf-8"));
+    parsed = JSON.parse(readFileSync7(statePath2(cwd), "utf-8"));
   } catch {
     return null;
   }
@@ -2339,10 +2413,11 @@ function readMetroState(cwd) {
 }
 function clearMetroState(cwd) {
   const path = statePath2(cwd);
-  if (existsSync3(path)) rmSync5(path, { force: true });
+  if (existsSync4(path)) rmSync6(path, { force: true });
 }
-function killOwnedMetro(cwd) {
+function killOwnedMetro(cwd, expectedPid) {
   const state = readMetroState(cwd);
+  if (expectedPid !== void 0 && state?.pid !== expectedPid) return false;
   clearMetroState(cwd);
   if (!state) return false;
   try {
@@ -2352,6 +2427,18 @@ function killOwnedMetro(cwd) {
     return false;
   }
 }
+function handOffMetro(cwd, metroPid, sessionId) {
+  const state = readMetroState(cwd);
+  if (!state || state.pid !== metroPid) return;
+  try {
+    writeMetroState(cwd, { ...state, handed_off_session: sessionId });
+  } catch {
+  }
+}
+function metroHandedOffTo(cwd, metroPid, sessionId) {
+  const state = readMetroState(cwd);
+  return state !== null && state.pid === metroPid && state.handed_off_session === sessionId;
+}
 
 // src/lib/metro-manager.ts
 var TAIL_LINES2 = 20;
@@ -2367,12 +2454,12 @@ async function ensureMetro(cwd, metro, log, timeoutMs = 9e4) {
   const ownHoldsPort = own !== null && own.port === metro.port;
   if (status !== "down") {
     if (ownHoldsPort && metro.command && own.command !== metro.command) {
-      killOwnedMetro(cwd);
+      killOwnedMetro(cwd, own.pid);
       await waitFor(async () => await checkMetro(metro.port) === "down", 1e4, 250);
-      await spawnMetro(cwd, metro.command, metro.port, log, timeoutMs);
-      return { status: "respawned", warnings };
+      const pid2 = await spawnMetro(cwd, metro.command, metro.port, log, timeoutMs);
+      return { status: "respawned", warnings, pid: pid2 };
     }
-    if (ownHoldsPort) return { status: "reused-own", warnings };
+    if (ownHoldsPort) return { status: "reused-own", warnings, pid: own.pid };
     if (status === "listening") {
       warnings.push(
         `something is listening on localhost:${metro.port} but it doesn't look like Metro \u2014 continuing anyway`
@@ -2393,8 +2480,8 @@ Or set "metroCommand" in vibeview.json and vibeview dev will start it for you.
 If Metro uses another port, pass --metro-port <port>.`
     );
   }
-  await spawnMetro(cwd, metro.command, metro.port, log, timeoutMs);
-  return { status: "spawned", warnings };
+  const pid = await spawnMetro(cwd, metro.command, metro.port, log, timeoutMs);
+  return { status: "spawned", warnings, pid };
 }
 async function spawnMetro(cwd, command, port, log, timeoutMs) {
   const child = spawn3(command, {
@@ -2422,16 +2509,16 @@ async function spawnMetro(cwd, command, port, log, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     if (exited !== null) {
-      killOwnedMetro(cwd);
+      killOwnedMetro(cwd, child.pid);
       throw new Error(
         `Metro command exited (code ${exited}) before localhost:${port} came up.
 ` + (tail.length ? `Last output:
   ${tail.join("\n  ")}` : "")
       );
     }
-    if (await checkMetro(port, 1e3) === "running") return;
+    if (await checkMetro(port, 1e3) === "running") return child.pid;
     if (Date.now() > deadline) {
-      killOwnedMetro(cwd);
+      killOwnedMetro(cwd, child.pid);
       throw new Error(`timed out waiting for Metro on localhost:${port} (command: ${command})`);
     }
     await new Promise((r) => setTimeout(r, 500));
@@ -2568,6 +2655,60 @@ function leaseLapsedReason(gapMs) {
   if (gapMs <= AGENT_LEASE_TTL_MS) return void 0;
   return `the session ended because this computer did not check in with VibeView for ${Math.round(gapMs / 1e3)}s (asleep, offline, or the process was paused) \u2014 start a new session to continue`;
 }
+var TUNNEL_REPLACED_REASON = "another VibeView dev connection took over this session \u2014 it keeps running there";
+var SessionReplacedError = class extends Error {
+  /** The session the newer client took over (it keeps running there). */
+  sessionId;
+  constructor(sessionId) {
+    super(TUNNEL_REPLACED_REASON);
+    this.name = "SessionReplacedError";
+    this.sessionId = sessionId;
+  }
+};
+var IDLE_WARNING_EPISODE_SLACK_MS = 5e3;
+function parseIdleWarningSeconds(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+  const seconds = Math.round(raw);
+  return seconds > 0 ? seconds : null;
+}
+function createIdleWarningTracker() {
+  let endsAt = null;
+  let issued = 0;
+  let accepted = 0;
+  return {
+    begin: () => ++issued,
+    observe(info, now = Date.now(), stamp) {
+      if (!info || info.idle_warning === void 0) return null;
+      if (stamp !== void 0) {
+        if (stamp < accepted) return null;
+        accepted = stamp;
+      }
+      const w = info.idle_warning;
+      if (w === null) {
+        if (endsAt === null) return null;
+        endsAt = null;
+        return { kind: "cleared" };
+      }
+      if (typeof w !== "object") return null;
+      const seconds = parseIdleWarningSeconds(w.seconds_remaining);
+      if (seconds === null) return null;
+      const at = now + seconds * 1e3;
+      if (endsAt !== null && at <= endsAt + IDLE_WARNING_EPISODE_SLACK_MS) return null;
+      endsAt = at;
+      return { kind: "warn", seconds_remaining: seconds };
+    },
+    noteUse() {
+      accepted = ++issued;
+      if (endsAt === null) return null;
+      endsAt = null;
+      return { kind: "cleared" };
+    }
+  };
+}
+function idleWarningLine(seconds, mode) {
+  const keep = mode === "metro" ? "use the device or save a file" : mode === "roku" ? "use the device or reload the channel" : "use the device";
+  return `Session ends in ${seconds} s: ${keep} to keep it`;
+}
 function queuedLine(position, reasonMessage) {
   const where = position ? ` (position ${position})` : "";
   const why = reasonMessage ?? "Every device is busy.";
@@ -2580,8 +2721,28 @@ function devBuildLines(choice, standalone) {
     listBuilds: "vibeview list-builds"
   });
 }
+var stdoutClosed = false;
+var stdoutGuarded = false;
+function guardStdout() {
+  if (stdoutGuarded) return;
+  stdoutGuarded = true;
+  process.stdout.on("error", (err) => {
+    if (err?.code === "EPIPE") {
+      stdoutClosed = true;
+      return;
+    }
+    throw err;
+  });
+}
 function emit(json, evt) {
-  if (json) console.log(JSON.stringify(evt));
+  if (!json || stdoutClosed) return;
+  guardStdout();
+  try {
+    console.log(JSON.stringify(evt));
+  } catch (err) {
+    if (err?.code === "EPIPE") stdoutClosed = true;
+    else throw err;
+  }
 }
 async function startDevSession(cfg, onEvent = () => {
 }, onTunnelState) {
@@ -2619,6 +2780,43 @@ async function startDevSession(cfg, onEvent = () => {
   let queueEntryId = null;
   let lastLeaseAt = Date.now();
   let leaseTimer = null;
+  const idle = createIdleWarningTracker();
+  let lastOutsideUse = Date.now();
+  registerDevUse(sessionId);
+  const noteOutsideUse = () => {
+    const at = readDevUse(sessionId);
+    if (at === null || at <= lastOutsideUse) return;
+    lastOutsideUse = at;
+    reportIdleChange(idle.noteUse());
+  };
+  const noteSessionInfo = (info, stamp) => {
+    if (stopping) return;
+    noteOutsideUse();
+    reportIdleChange(idle.observe(info, void 0, stamp));
+  };
+  const noteUse = () => {
+    if (stopping) return;
+    reportIdleChange(idle.noteUse());
+  };
+  const reportIdleChange = (change) => {
+    if (!change) return;
+    try {
+      if (change.kind === "cleared") {
+        cfg.onIdleWarning?.(sessionId, null);
+        return;
+      }
+      cfg.onIdleWarning?.(sessionId, { seconds_remaining: change.seconds_remaining });
+      onEvent({
+        event: "idle_warning",
+        session_id: sessionId,
+        seconds_remaining: change.seconds_remaining
+      });
+    } catch (err) {
+      console.error(
+        `idle warning hook failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  };
   const stopSession = async (code) => {
     if (stopping) return;
     stopping = true;
@@ -2633,11 +2831,29 @@ async function startDevSession(cfg, onEvent = () => {
     }
     await api.stopSession(sessionId).catch(() => {
     });
+    clearDevUse(sessionId);
     onEvent({ event: "session_ended", session_id: sessionId, code, ...reason ? { reason } : {} });
   };
+  let replaced = false;
+  const releaseSession = () => {
+    if (stopping) return;
+    stopping = true;
+    replaced = true;
+    if (leaseTimer) clearInterval(leaseTimer);
+    leaseTimer = null;
+    tunnel?.stop();
+    onEvent({
+      event: "session_ended",
+      session_id: sessionId,
+      code: 0,
+      reason: TUNNEL_REPLACED_REASON,
+      replaced: true
+    });
+  };
   const renewLease = async () => {
     if (stopping) return;
     let info;
+    const stamp = idle.begin();
     try {
       info = await api.touchSession(sessionId, { lease: true });
     } catch {
@@ -2649,6 +2865,7 @@ async function startDevSession(cfg, onEvent = () => {
       return;
     }
     lastLeaseAt = Date.now();
+    noteSessionInfo(info, stamp);
   };
   void renewLease();
   leaseTimer = setInterval(() => void renewLease(), AGENT_LEASE_RENEW_MS);
@@ -2700,6 +2917,8 @@ async function startDevSession(cfg, onEvent = () => {
               event: "warning",
               message: `can't reach Metro on localhost:${cfg.metroPort} \u2014 is it running? (yarn start)`
             });
+          } else if (s === "replaced") {
+            releaseSession();
           } else if (s === "closed" && !stopping) {
             void stopSession(1);
           }
@@ -2714,8 +2933,10 @@ async function startDevSession(cfg, onEvent = () => {
       sessionId,
       18e4,
       2e3,
-      () => onEvent({ event: "installing", session_id: sessionId })
+      () => onEvent({ event: "installing", session_id: sessionId }),
+      () => replaced
     );
+    if (replaced) throw new SessionReplacedError(sessionId);
     for (const w of active.warnings ?? []) {
       if (reportedWarnings.has(w)) continue;
       reportedWarnings.add(w);
@@ -2728,9 +2949,13 @@ async function startDevSession(cfg, onEvent = () => {
       reportedWarnings,
       session: active,
       lapsedReason: () => leaseLapsedReason(Date.now() - lastLeaseAt),
+      noteSessionInfo,
+      beginPresence: () => idle.begin(),
+      noteUse,
       build: usesTunnel && cfg.projectDir ? describeDevBuild(app, active, { ...pick, pinned: cfg.buildId !== void 0 }, project) : null
     };
   } catch (err) {
+    if (replaced) throw new SessionReplacedError(sessionId);
     await stopSession(1);
     throw err;
   }
@@ -2827,10 +3052,11 @@ async function pollUntilTunnelReady(api, sessionId, timeoutMs, intervalMs = 2e3)
     await new Promise((r) => setTimeout(r, intervalMs));
   }
 }
-async function pollUntilActive(api, sessionId, timeoutMs, intervalMs = 2e3, onInstallPending) {
+async function pollUntilActive(api, sessionId, timeoutMs, intervalMs = 2e3, onInstallPending, shouldAbort) {
   const deadline = Date.now() + timeoutMs;
   let pendingReported = false;
   for (; ; ) {
+    if (shouldAbort?.()) throw new Error("wait for the session aborted");
     const info = await api.touchSession(sessionId);
     const blocking = findBlockingWarning(info);
     if (blocking) throw new Error(blocking);
@@ -3253,6 +3479,7 @@ async function runDevInProcess(opts) {
     }
   }
   let metroOwnedThisRun = false;
+  let metroPid = null;
   let rokuBuild;
   let watchIgnore = [];
   if (standalone && cfg.platform === "roku") {
@@ -3270,7 +3497,7 @@ async function runDevInProcess(opts) {
       const captureMetroLine = (line) => {
         try {
           if (!metroLogStream) {
-            mkdirSync4(dirname4(metroLogPath(process.cwd())), { recursive: true });
+            mkdirSync5(dirname4(metroLogPath(process.cwd())), { recursive: true });
             metroLogStream = createWriteStream(metroLogPath(process.cwd()), { flags: "w" });
           }
           metroLogStream.write(line.replace(/^\[metro\] /, "") + "\n");
@@ -3301,6 +3528,7 @@ async function runDevInProcess(opts) {
       );
     }
     metroOwnedThisRun = metroResult.status === "spawned" || metroResult.status === "respawned";
+    metroPid = metroResult.pid ?? null;
   } else {
     const rokuEntry = loadDevConfig(process.cwd())?.platforms?.[cfg.platform];
     rokuBuild = rokuEntry?.build;
@@ -3320,14 +3548,38 @@ async function runDevInProcess(opts) {
   let stopping = false;
   let handle = null;
   let reloadLoop = null;
-  const stopSession = async (code) => {
+  const ownsMetro = (sessionId) => metroPid !== null && (metroOwnedThisRun || sessionId !== void 0 && metroHandedOffTo(process.cwd(), metroPid, sessionId));
+  const stopOwnedMetro = () => {
+    if (metroPid === null) return;
+    const other = readDevStateFile(process.cwd());
+    if (other?.alive && other.state.pid !== process.pid && other.state.metro_port === (cfg.metroPort ?? 8081) && PLATFORM_NEEDS_METRO[other.state.platform]) {
+      handOffMetro(process.cwd(), metroPid, other.state.session_id);
+      console.error(chalk4.dim("  Metro keeps running for the other vibeview dev in this project."));
+      return;
+    }
+    killOwnedMetro(process.cwd(), metroPid);
+  };
+  const handOffOwnedMetro = (sessionId) => {
+    if (metroPid !== null && sessionId !== void 0 && ownsMetro(sessionId)) {
+      handOffMetro(process.cwd(), metroPid, sessionId);
+    }
+  };
+  const stopSession = async (code, how = {}) => {
     if (stopping) return;
     stopping = true;
+    if (how.replaced) {
+      reloadLoop?.stop();
+      handOffOwnedMetro(how.sessionId);
+      clearDevStateIfOwned(process.cwd(), process.pid);
+      process.exit(code);
+      return;
+    }
     console.error(chalk4.dim("\nStopping session..."));
     reloadLoop?.stop();
+    const ownMetro = ownsMetro(handle?.sessionId);
     await handle?.stop();
-    if (metroOwnedThisRun) killOwnedMetro(process.cwd());
-    clearDevState(process.cwd());
+    if (ownMetro) stopOwnedMetro();
+    clearDevStateIfOwned(process.cwd(), process.pid);
     process.exit(code);
   };
   process.on("SIGINT", () => void stopSession(0));
@@ -3336,6 +3588,7 @@ async function runDevInProcess(opts) {
   let waitingPrinted = false;
   let nextWarningIsMetroUnreachable = false;
   let endedEmitted = false;
+  const idleMode = cfg.platform === "roku" ? "roku" : standalone ? "standalone" : "metro";
   try {
     handle = await startDevSession(
       {
@@ -3373,12 +3626,29 @@ async function runDevInProcess(opts) {
           console.error(
             chalk4.dim("  Putting the channel on the Roku \u2014 the link appears once it is up.")
           );
+        } else if (evt.event === "idle_warning") {
+          console.error(chalk4.yellow(`\u26A0 ${idleWarningLine(evt.seconds_remaining, idleMode)}`));
+        } else if (evt.event === "session_ended" && evt.replaced && !stopping && handle) {
+          console.error(chalk4.dim(evt.reason ?? TUNNEL_REPLACED_REASON));
+          if (ownsMetro(evt.session_id)) {
+            console.error(
+              chalk4.dim("  Metro keeps running for that connection, which stops it when it exits.")
+            );
+          }
+          stopping = true;
+          endedEmitted = true;
+          emit(opts.json, evt);
+          handOffOwnedMetro(evt.session_id);
+          clearDevStateIfOwned(process.cwd(), process.pid);
+          process.exit(0);
         } else if (evt.event === "session_ended" && !stopping && handle) {
           console.error(chalk4.red(evt.reason ?? "session ended by the server"));
           stopping = true;
           endedEmitted = true;
           emit(opts.json, evt);
-          clearDevState(process.cwd());
+          reloadLoop?.stop();
+          if (ownsMetro(evt.session_id)) stopOwnedMetro();
+          clearDevStateIfOwned(process.cwd(), process.pid);
           process.exit(1);
         }
         if (evt.event === "session_ended") {
@@ -3430,19 +3700,26 @@ async function runDevInProcess(opts) {
     if (opts.open !== false) await openBrowser(handle.pageUrl).catch(() => {
     });
     if (rokuBuild) {
+      const rokuPush = 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(chalk4.dim(line))
+      });
+      const live = handle;
       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(chalk4.dim(line))
-        }),
+        // A reloaded channel is use: once the push succeeds, drop an idle
+        // warning from a presence request begun before it.
+        push: async () => {
+          await rokuPush();
+          live.noteUse?.();
+        },
         log: (line) => console.error(chalk4.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
@@ -3486,6 +3763,7 @@ async function runDevInProcess(opts) {
           void (async () => {
             if (stopping) return;
             let info = null;
+            const stamp = handle?.beginPresence?.();
             try {
               info = await api.touchSession(sessionId);
             } catch {
@@ -3504,6 +3782,7 @@ async function runDevInProcess(opts) {
               await stopSession(1);
               return;
             }
+            handle?.noteSessionInfo?.(info, stamp);
             const warningVerdict = lateWarningVerdict(info, reportedWarnings);
             for (const w of warningVerdict.toReport) {
               reportedWarnings.add(w);
@@ -3527,7 +3806,10 @@ async function runDevInProcess(opts) {
     const message = err.message;
     console.error(chalk4.red(`error: ${message}`));
     emit(opts.json, { event: "error", message });
-    await stopSession(1);
+    await stopSession(
+      1,
+      err instanceof SessionReplacedError ? { replaced: true, sessionId: err.sessionId } : {}
+    );
   }
 }
 async function dev(opts) {
@@ -3717,7 +3999,7 @@ var PRESS_PLATFORM_LABELS = [
   ["android", "Android phone / tablet"],
   ["appleTv", "Apple TV"],
   ["androidTv", "Android TV"],
-  ["roku", "Roku (beta)"]
+  ["roku", "Roku"]
 ];
 var PRESS_BUTTONS_BY_PLATFORM = PRESS_PLATFORM_LABELS.map(([key, label]) => [label, PRESS_BUTTONS[key]]);
 function pressButtonLines(indent) {
@@ -4312,7 +4594,7 @@ function agentExitCode(env) {
 }
 
 // src/commands/agent.ts
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 var REF_RE = /^@?(e\d+)$/;
 var COORDS_RE = /^(-?\d+),\s*(-?\d+)$/;
 var FlagError = class extends Error {
@@ -4482,6 +4764,16 @@ function decodeScreenshotResult(result) {
   }
   return Buffer.from(b64, "base64");
 }
+var NON_USE_TOOLS = /* @__PURE__ */ new Set([
+  "ui_tree",
+  "screenshot",
+  "logs",
+  "find_element",
+  "wait"
+]);
+function countsAsUse(tool) {
+  return !NON_USE_TOOLS.has(tool);
+}
 async function runAgentVerb(cmd, positionals, opts) {
   const { token, baseUrl } = resolveAuth(opts);
   const sessionId = opts.session || readDevState(process.cwd())?.session_id;
@@ -4512,6 +4804,7 @@ async function runAgentVerb(cmd, positionals, opts) {
     }
     process.exit(errorExitCode(err));
   }
+  if (countsAsUse(call.tool)) recordDevUse(sessionId);
   if (cmd.verb === "screenshot" && envelope.ok && envelope.result) {
     const outPath = opts.out || defaultScreenshotPath();
     let imageBytes;
@@ -4522,7 +4815,7 @@ async function runAgentVerb(cmd, positionals, opts) {
 `);
       process.exit(1);
     }
-    writeFileSync6(outPath, imageBytes);
+    writeFileSync7(outPath, imageBytes);
     if (opts.json) {
       console.log(
         JSON.stringify({ ...envelope, result: { written_to: outPath, bytes: imageBytes.length } })
@@ -4563,6 +4856,7 @@ export {
   clearDevState,
   readMetroState,
   killOwnedMetro,
+  recordDevUse,
   checkMetro,
   loadLocalDevConfig,
   effectiveDevConfig,
@@ -4574,6 +4868,7 @@ export {
   printTransition,
   printOutcomeLine,
   createRokuPush,
+  parseIdleWarningSeconds,
   startDevSession,
   PLATFORM_DEVICE,
   dev,
@@ -4585,5 +4880,6 @@ export {
   renderEnvelope,
   buildToolCall,
   decodeScreenshotResult,
+  countsAsUse,
   runAgentVerb
 };

package/dist/cli.js

@@ -23,8 +23,9 @@ import {
   readDevState,
   readDevStateFile,
   readMetroState,
+  recordDevUse,
   runAgentVerb
-} from "./chunk-Z6UVEAYO.js";
+} from "./chunk-VFCG4U7V.js";
 import {
   ApiClient,
   ApiStatusError,
@@ -1787,6 +1788,7 @@ async function devReload(opts) {
   } catch (err) {
     fail(opts, "reload_failed", err instanceof Error ? err.message : String(err), 1);
   }
+  recordDevUse(state.session_id);
   if (opts.json) {
     console.log(
       JSON.stringify({
@@ -3660,8 +3662,10 @@ var CLAUDE_MD_SUGGESTION = "After changing UI or app behavior, verify it on a li
 function claudeCliAvailable() {
   return spawnSync("claude", ["--version"], { stdio: "ignore" }).error === void 0;
 }
+var MCP_COMMAND = ["npx", "-y", "vibeview", "mcp"];
+var MCP_ADD_HINT = `claude mcp add vibeview -- ${MCP_COMMAND.join(" ")}`;
 function registerMcp() {
-  const res = spawnSync("claude", ["mcp", "add", "vibeview", "--", "vibeview", "mcp"], {
+  const res = spawnSync("claude", ["mcp", "add", "vibeview", "--", ...MCP_COMMAND], {
     encoding: "utf8"
   });
   if (res.status === 0) {
@@ -3674,7 +3678,7 @@ function registerMcp() {
     return;
   }
   console.error(chalk21.yellow(`\u26A0 could not register the MCP server: ${out.trim() || res.error}`));
-  console.error(chalk21.yellow("  register it manually: claude mcp add vibeview -- vibeview mcp"));
+  console.error(chalk21.yellow(`  register it manually: ${MCP_ADD_HINT}`));
 }
 async function agentSetup(opts) {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -3700,9 +3704,7 @@ async function agentSetup(opts) {
     if (!claudeCliAvailable()) {
       if (opts.mcp === true) {
         console.error(
-          chalk21.yellow(
-            "\u26A0 claude CLI not found \u2014 install Claude Code, then run: claude mcp add vibeview -- vibeview mcp"
-          )
+          chalk21.yellow(`\u26A0 claude CLI not found \u2014 install Claude Code, then run: ${MCP_ADD_HINT}`)
         );
       }
     } else if (opts.mcp === true || process.stdin.isTTY && await confirm({
@@ -3835,7 +3837,7 @@ function resolveMetadata(opts) {
 }
 var program = new Command();
 program.name("vibeview").description(
-  "VibeView CLI -- run your app on cloud iOS simulators, Android emulators, Apple TV, Android TV and Roku (beta) devices: a React Native dev loop (dev), device control for you or your coding agent (ui-tree, tap, mcp), and tests from CI (run-test, run-suites)"
+  "VibeView CLI -- run your app on cloud iOS simulators, Android emulators, Apple TV, Android TV and Roku devices: a React Native dev loop (dev), device control for you or your coding agent (ui-tree, tap, mcp), and tests from CI (run-test, run-suites)"
 ).version(pkg.version);
 program.command("run-suite <suite-id>").description("Run all test cases in a suite").option("--token <token>", "API token (or set VIBEVIEW_API_TOKEN)").option("--output <format>", "Output format: human, json, junit", "human").option("--verbose", "Show per-case breakdown", false).option("--timeout <seconds>", "Max wait time in seconds (queue wait plus execution)", "1800").option("--commit-sha <sha>", "Git commit SHA for GitHub status checks").option("--model <model>", "AI model to use").option("--provider <provider>", "AI provider").option("--mode <mode>", "Execution mode: hybrid, ai, replay").option(
   "--device-category <category>",
@@ -4145,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-EKFF2JBU.js");
+  const { runMcpServer } = await import("./server-2CDIRTBV.js");
   await runMcpServer({ ...opts, version: pkg.version });
 });
 program.command("agent-setup").description(

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

@@ -9,6 +9,7 @@ import {
   buildToolCall,
   checkDevBuild,
   checkMetro,
+  countsAsUse,
   createRokuPush,
   decodeScreenshotResult,
   describeDevBuild,
@@ -20,12 +21,14 @@ import {
   loadDevConfig,
   loadLocalDevConfig,
   parseBuildId,
+  parseIdleWarningSeconds,
   platformWithArticle,
   readDevState,
+  recordDevUse,
   renderEnvelope,
   resolveMetro,
   startDevSession
-} from "./chunk-Z6UVEAYO.js";
+} from "./chunk-VFCG4U7V.js";
 import {
   ApiClient,
   NotFoundError,
@@ -241,9 +244,15 @@ function capitalize(text) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
 function endedLine(ended) {
+  if (ended.status === "replaced") {
+    return `session ${ended.sessionId} was taken over by another VibeView dev connection and is no longer held here (it keeps running there)`;
+  }
   const why = ended.reason ? `: ${ended.reason}` : "";
   return `session ${ended.sessionId} has ended (${ended.status}${why})`;
 }
+function idleNoticeText(sessionId, seconds) {
+  return `Session ${sessionId} ends in ${seconds} s for inactivity: a device action (tap, type, swipe, press, \u2026) keeps it; ui_tree, screenshot, logs, find and wait do not.`;
+}
 async function explainInactive(sessionId, deps) {
   let info;
   try {
@@ -266,7 +275,7 @@ async function explainInactive(sessionId, deps) {
 function findCommand(toolName) {
   return AGENT_COMMANDS.find((c) => toolNameFor(c.verb) === toolName);
 }
-async function handleToolCall(toolName, args, deps, extra = {}) {
+async function dispatchToolCall(toolName, args, deps, extra = {}) {
   if (toolName === "dev_start") {
     return handleDevStart(args, deps, extra);
   }
@@ -331,6 +340,55 @@ async function handleToolCall(toolName, args, deps, extra = {}) {
   }
   return textResult(renderEnvelope(envelope, toolNameFor(cmd.verb)), envelope, !envelope.ok);
 }
+async function handleToolCall(toolName, args, deps, extra = {}) {
+  const held = deps.devSession.current?.()?.sessionId;
+  const dispatched = typeof args.session_id === "string" ? args.session_id.trim() : deps.resolveSessionId();
+  const usesBefore = deps.devSession.useGeneration?.();
+  const result = await dispatchToolCall(toolName, args, deps, extra);
+  noteDeviceUse(toolName, result, deps, held, dispatched);
+  const usedSince = usesBefore !== void 0 && (deps.devSession.useGeneration?.() ?? usesBefore) > usesBefore;
+  return withIdleNotice(toolName, args, result, deps, held, dispatched, usedSince);
+}
+function noteDeviceUse(toolName, result, deps, held, dispatched) {
+  const cmd = findCommand(toolName);
+  if (!cmd || !dispatched || !result.structuredContent) return;
+  if (!countsAsUse(cmd.tool)) return;
+  if (dispatched === held) deps.devSession.noteUse?.(dispatched);
+  else recordDevUse(dispatched);
+}
+var IDLE_NOTICE_DISCARD = /* @__PURE__ */ new Set(["dev_start", "dev_stop", "dev_reload"]);
+function withIdleNotice(toolName, args, result, deps, held, dispatched, usedSince = false) {
+  const dev = deps.devSession;
+  const stopsHeld = toolName === "stop_session" && held !== void 0 && (typeof args.session_id === "string" ? args.session_id.trim() : held) === held;
+  if ((IDLE_NOTICE_DISCARD.has(toolName) || stopsHeld) && !result.isError) {
+    const about = toolName === "dev_start" ? dev.current?.()?.sessionId : held;
+    if (about !== void 0) dev.takeIdleWarning?.(about);
+    return result;
+  }
+  if (findCommand(toolName) && result.structuredContent && typeof result.structuredContent === "object") {
+    const own = result.structuredContent.idle_warning;
+    if (own !== void 0) {
+      const target = dispatched;
+      if (target !== void 0 && target === held) dev.takeIdleWarning?.(target);
+      const seconds = parseIdleWarningSeconds(own?.seconds_remaining);
+      if (usedSince && target === held) return result;
+      if (target && seconds !== null) return appendNotice(result, idleNoticeText(target, seconds));
+      return result;
+    }
+  }
+  const notice = dev.takeIdleWarning?.() ?? null;
+  return notice ? appendNotice(result, notice) : result;
+}
+function appendNotice(result, notice) {
+  const i = result.content.findIndex((b) => b.type === "text");
+  if (i === -1) return { ...result, content: [...result.content, { type: "text", text: notice }] };
+  const content = result.content.slice();
+  const block = content[i];
+  content[i] = { type: "text", text: `${block.text}
+
+${notice}` };
+  return { ...result, content };
+}
 function screenshotToolResult(envelope, args) {
   const { image, preview } = splitScreenshotResult(envelope.result);
   let imageBytes;
@@ -613,7 +671,7 @@ async function handleDevStop(deps) {
   }
   if (!current) {
     return textResult(
-      ended ? `no dev session was running \u2014 it had already ended. ${capitalize(endedLine(ended))}` : "no dev session was running",
+      ended ? ended.status === "replaced" ? `no dev session was running here. ${capitalize(endedLine(ended))}` : `no dev session was running \u2014 it had already ended. ${capitalize(endedLine(ended))}` : "no dev session was running",
       { session_id: null, stopped: false }
     );
   }
@@ -725,6 +783,7 @@ function createDevSessionController(auth, webUrl) {
   let ended = null;
   let reloading = null;
   let pending = null;
+  let idle = null;
   const readRokuBuild = () => {
     try {
       return loadDevConfig(process.cwd())?.platforms?.roku?.build ?? null;
@@ -739,10 +798,25 @@ function createDevSessionController(auth, webUrl) {
     const dead = handle;
     handle = null;
     platform = null;
+    idle = null;
     ended = { ...e, reason: e.reason ?? dead.lapsedReason?.() ?? null };
     void dead.stop().catch(() => {
     });
   };
+  const markReplaced = (sessionId) => {
+    if (!handle || handle.sessionId !== sessionId) return;
+    handle = null;
+    platform = null;
+    idle = null;
+    ended = { sessionId, status: "replaced", reason: null };
+  };
+  let uses = 0;
+  const noteHeldUse = (sessionId) => {
+    if (!handle || handle.sessionId !== sessionId) return;
+    uses++;
+    handle.noteUse?.();
+    if (idle?.sessionId === sessionId) idle = null;
+  };
   const api = () => new ApiClient(auth.baseUrl, auth.token);
   return {
     async start(cfg) {
@@ -832,11 +906,18 @@ function createDevSessionController(auth, webUrl) {
             onCreated: (created) => {
               pending = created;
             },
-            onDequeued: () => progress.dequeued()
+            onDequeued: () => progress.dequeued(),
+            onIdleWarning: (id, warning) => {
+              idle = warning ? { sessionId: id, endsAt: Date.now() + warning.seconds_remaining * 1e3 } : null;
+            }
           },
           (evt) => {
             progress.event(evt);
             if (evt.event === "warning") warnings.push(evt.message);
+            if (evt.event === "session_ended" && evt.replaced && started) {
+              markReplaced(evt.session_id);
+              return;
+            }
             if (evt.event === "session_ended" && evt.code !== 0 && started) {
               const id = evt.session_id;
               void api().getSession(id).then(
@@ -882,6 +963,7 @@ function createDevSessionController(auth, webUrl) {
       await handle?.stop();
       handle = null;
       platform = null;
+      idle = null;
       ended = null;
     },
     async shutdown() {
@@ -890,6 +972,7 @@ function createDevSessionController(auth, webUrl) {
       const starting = pending;
       handle = null;
       platform = null;
+      idle = null;
       pending = null;
       await Promise.all([
         held ? held.stop().then(
@@ -912,6 +995,17 @@ function createDevSessionController(auth, webUrl) {
     lastEnded() {
       return ended;
     },
+    noteUse: noteHeldUse,
+    useGeneration: () => uses,
+    takeIdleWarning(sessionId) {
+      const w = idle;
+      if (sessionId !== void 0 && w?.sessionId !== sessionId) return null;
+      idle = null;
+      if (!w || !handle || handle.sessionId !== w.sessionId) return null;
+      const seconds = Math.ceil((w.endsAt - Date.now()) / 1e3);
+      if (seconds <= 0) return null;
+      return idleNoticeText(w.sessionId, seconds);
+    },
     async reload(requested) {
       if (reloading) {
         throw new Error(
@@ -970,6 +1064,8 @@ function createDevSessionController(auth, webUrl) {
         log: (line) => console.error(line)
       });
       await push();
+      if (handle?.sessionId === target.sessionId) noteHeldUse(target.sessionId);
+      else recordDevUse(target.sessionId);
       return { sessionId: target.sessionId, seconds: (Date.now() - started) / 1e3 };
     }
   }
@@ -978,12 +1074,13 @@ function makeSessionResolver(devSession) {
   return () => devSession.current()?.sessionId ?? readDevState(process.cwd())?.session_id;
 }
 var MCP_INSTRUCTIONS = [
-  "VibeView runs your app on a cloud iOS simulator, Android emulator, Apple TV, Android TV or Roku (beta) device you control with these tools.",
+  "VibeView runs your app on a cloud iOS simulator, Android emulator, Apple TV, Android TV or Roku device you control with these tools.",
   "Loop: dev_start (platform, app from list_apps; add standalone: true for a release or CI build that needs no Metro) -> ui_tree -> act with refs (tap @e5, type, swipe, press) and read the change each action reports -> dev_stop when done.",
   "Foldables: pick one by model in dev_start (list_device_models marks them foldable, with free/busy counts), then set_posture and rotate.",
   "set_location sets the simulated GPS position (phones and tablets) for location-based flows.",
   "screenshot writes a PNG and returns its path; pass inline: true to see the image. logs reads the app output after a crash or blank screen.",
-  "A session stopped elsewhere is reported as ended; call dev_start again for a new one."
+  "A session stopped elsewhere is reported as ended; call dev_start again for a new one.",
+  'A session nobody uses ends after the idle timeout. A result that ends with "Session \u2026 ends in N s for inactivity" means act (tap, type, swipe, press) to keep it, or dev_stop if you are done; ui_tree, screenshot, logs, find and wait do not count as use.'
 ].join("\n");
 async function createMcpServer(opts) {
   const [{ McpServer }, { z }] = await Promise.all([
@@ -1100,6 +1197,7 @@ export {
   deviceLine,
   forMcp,
   handleToolCall,
+  idleNoticeText,
   mcpText,
   progressReporter,
   runMcpServer,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vibeview",
-  "version": "0.35.0",
-  "description": "VibeView CLI -- run your app on cloud iOS simulators, Android emulators, Apple TV, Android TV and Roku (beta) devices: a React Native dev loop, device control for you or your coding agent (CLI or MCP), and tests from CI",
+  "version": "0.36.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",
   "bin": {

package/skills/vibeview-agent/SKILL.md

@@ -211,7 +211,7 @@ appear unexplained in their `git status`.
   `ui-tree` afterwards — old refs are stale. On other phones and tablets
   `rotate` toggles portrait/landscape (only 90 is accepted); TV devices don't
   rotate.
-- **Roku channels (beta)**: start the session with
+- **Roku channels**: start the session with
   `vibeview dev --platform roku --detach` (or `dev_start` with platform
   `roku` over MCP); after an edit run `vibeview dev-reload` (MCP:
   `dev_reload`) to re-package, upload and restart the channel in the same
@@ -254,6 +254,10 @@ vibeview dev-stop
 If the `dev --detach` process is killed or the computer sleeps, its session
 ends on its own within about 90 seconds (unless a browser tab is watching
 it) — but don't rely on that; stop it.
+A session nobody uses also ends on its own after the organization's idle
+timeout (30 minutes by default). Only device actions (tap, type, swipe,
+press, …) and app reloads count as use; `ui-tree`, `screenshot`, `logs`,
+`find` and `wait` do not, and neither does keeping `dev --detach` running.
 A session you did not start with `dev` (one created through the API, the
 sandbox, or a collaboration link) is stopped by id:
 ```bash
@@ -332,6 +336,10 @@ steps the CLI does with plain shell commands:
 If the held session ends elsewhere (dashboard, idle timeout, failure), the
 next tool call answers "session … has ended (…) — call dev_start"; the
 server has already let it go, so `dev_start` starts a fresh one.
+A tool result that ends with `Session … ends in N s for inactivity` means
+the held session is about to time out: act on the device to keep it, or call
+`dev_stop` if you are done. A session another VibeView dev connection took
+over is reported as taken over; it keeps running there, so don't stop it.
 
 **`dev_start` is stateful — it changes the default session for every later
 call.** Once it succeeds, any tool called without an explicit `session_id`