vibeview 0.37.1 → 0.38.0

package/dist/{server-DF3CDWL4.js → server-FMU3HQWF.js}

@@ -28,12 +28,12 @@ import {
   renderEnvelope,
   resolveMetro,
   startDevSession
-} from "./chunk-NJ2IXB5H.js";
+} from "./chunk-AV674D7T.js";
 import {
   ApiClient,
   NotFoundError,
   resolveAuth
-} from "./chunk-QRJAFBH3.js";
+} from "./chunk-MYXUGCR5.js";
 
 // src/mcp/server.ts
 import { writeFileSync } from "fs";
@@ -44,6 +44,72 @@ var SESSION_ID_PROPERTY = {
   type: "string",
   description: "Session ID to target. Optional: falls back to the MCP-server-held dev_start session, then this project's `vibeview dev --detach` state, if either is available."
 };
+var AI_USE_PROPERTY = {
+  type: "string",
+  description: "smart (default): replays saved paths and uses AI only where the screen changed; no_ai: replays only, no usage credit; ai_only: the AI does every step.",
+  enum: ["smart", "no_ai", "ai_only"]
+};
+var AI_USE_MODE = { smart: "hybrid", no_ai: "replay", ai_only: "ai" };
+var CREATE_TEST_DEF = {
+  name: "create_test",
+  description: 'Create a test for an app from plain-language steps, one per line; a check is a step starting with "Verify". Returns the test id for run_test. The first run is driven by AI; once it passes, later runs replay the saved path.',
+  mutating: true,
+  properties: {
+    app: { type: "string", description: "App id (from list_apps)." },
+    name: { type: "string", description: "Test name." },
+    steps: { type: "string", description: "The steps, one per line." },
+    group: { type: "string", description: "Group id to add the test to (optional)." }
+  },
+  required: ["app", "name", "steps"]
+};
+var RUN_TEST_DEF = {
+  name: "run_test",
+  description: "Run a saved test. With session_id it runs on that session (the device you are driving). Without it, VibeView always starts a new device of the test app's platform, runs the test and stops the device (it does not use a session you hold from dev_start; pass session_id to run on a session you hold). Returns a run id for get_run.",
+  mutating: true,
+  properties: {
+    test: { type: "string", description: "Test id (from create_test or the Tests page)." },
+    session_id: { type: "string", description: "Run on this session instead of a new device." },
+    device_model: {
+      type: "string",
+      description: "Device model for a new device (from list_device_models); omitted: any free one."
+    },
+    ai_use: AI_USE_PROPERTY,
+    start_from_current_screen: {
+      type: "boolean",
+      description: "With session_id: no reset before the test."
+    }
+  },
+  required: ["test"]
+};
+var RUN_GROUP_DEF = {
+  name: "run_group",
+  description: "Run every test of a group in order. With session_id it runs on that session; without it, on a new device of the app platform that VibeView starts and stops (it does not use a session you hold from dev_start; pass session_id to run on a session you hold). Returns a run id for get_run.",
+  mutating: true,
+  properties: {
+    group: {
+      type: "string",
+      description: "Group id (from the Tests page or `vibeview list-suites`)."
+    },
+    session_id: { type: "string", description: "Run on this session instead of a new device." },
+    device_model: {
+      type: "string",
+      description: "Device model for a new device; omitted: any free one."
+    },
+    ai_use: AI_USE_PROPERTY,
+    start_from_current_screen: {
+      type: "boolean",
+      description: "With session_id: no reset before the first test."
+    }
+  },
+  required: ["group"]
+};
+var GET_RUN_DEF = {
+  name: "get_run",
+  description: "A run's status and, when a test failed, which step and why. Pass the run id run_test or run_group returned.",
+  mutating: false,
+  properties: { run_id: { type: "string", description: "Run id." } },
+  required: ["run_id"]
+};
 var MCP_DEV_PLATFORMS = DEV_PLATFORMS;
 function isMcpDevPlatform(p) {
   return isDevPlatform(p) && MCP_DEV_PLATFORMS.includes(p);
@@ -210,9 +276,14 @@ function buildToolDefinitions() {
     LIST_DEVICE_MODELS_DEF,
     LIST_APPS_DEF,
     LIST_BUILDS_DEF,
-    STOP_SESSION_DEF
+    STOP_SESSION_DEF,
+    CREATE_TEST_DEF,
+    RUN_TEST_DEF,
+    RUN_GROUP_DEF,
+    GET_RUN_DEF
   ];
 }
+var runClientOf = (deps) => deps.runClient ?? new ApiClient(deps.auth.baseUrl, deps.auth.token, { client: "mcp" });
 function textResult(text, structuredContent, isError = false) {
   return { content: [{ type: "text", text }], structuredContent, isError };
 }
@@ -275,6 +346,118 @@ async function explainInactive(sessionId, deps) {
 function findCommand(toolName) {
   return AGENT_COMMANDS.find((c) => toolNameFor(c.verb) === toolName);
 }
+async function handleCreateTest(args, deps) {
+  const steps = String(args.steps ?? "").split("\n").map((s) => s.trim()).filter(Boolean).map((text) => ({ text }));
+  if (!steps.length) return errorResult("create_test: `steps` needs at least one line");
+  try {
+    const created = await runClientOf(deps).createTest({
+      name: String(args.name),
+      app_id: String(args.app),
+      steps,
+      group_ids: typeof args.group === "string" && args.group ? [args.group] : void 0
+    });
+    const verb = created.outcome === "unchanged" ? "Test already exists, unchanged" : created.outcome === "updated" ? "Updated existing test" : "Created test";
+    return textResult(
+      `${verb} ${created.public_id}: ${created.name} (${steps.length} steps). Run it with run_test test=${created.public_id}.`,
+      created
+    );
+  } catch (err) {
+    return errorResult(`error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function handleRun(kind, args, deps) {
+  const id = String(kind === "test" ? args.test : args.group);
+  const mode = typeof args.ai_use === "string" ? AI_USE_MODE[args.ai_use] : void 0;
+  const client = runClientOf(deps);
+  try {
+    if (typeof args.session_id === "string" && args.session_id) {
+      const r2 = await client.startRunOnSession(args.session_id, {
+        ...kind === "test" ? { test_id: id } : { group_id: id },
+        start_from_current_screen: args.start_from_current_screen === true,
+        mode
+      });
+      return textResult(
+        `Started ${kind} run ${r2.run_public_id} on session ${args.session_id}. Check it with get_run run_id=${r2.run_public_id}.`,
+        r2
+      );
+    }
+    const devices = typeof args.device_model === "string" && args.device_model ? [{ model: args.device_model }] : void 0;
+    const r = await client.startRun(
+      kind === "test" ? { target: "test", test_ids: [id], devices, mode } : { target: "group", group_id: id, devices, mode }
+    );
+    const queued = r.lanes.some((l) => l.status === "queued") ? " It is waiting for a free device." : "";
+    return textResult(
+      `Started run ${r.batch_id}.${queued} Check it with get_run run_id=${r.batch_id}.`,
+      r
+    );
+  } catch (err) {
+    return errorResult(`error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function notCheckedNote(status, n) {
+  if (status !== "passed" || typeof n !== "number" || n <= 0) return "";
+  return ` \u2014 ${n} step${n === 1 ? "" : "s"} not checked (no recorded actions; not verified)`;
+}
+var RUN_IN_PROGRESS = /* @__PURE__ */ new Set(["queued", "pending", "running"]);
+function formatRunForAgent(run) {
+  const lines = [];
+  if (run.lanes) {
+    lines.push(
+      `${run.name}: ${run.status} \u2014 ${run.summary.tests_passed} of ${run.summary.tests_total} tests passed`
+    );
+    for (const lane of run.lanes) {
+      const detail = [lane.platform, lane.os_version].filter(Boolean).join(" ");
+      let head = `${lane.model ? `${lane.model} (${detail})` : detail}: ${lane.status}`;
+      if (lane.status === "queued" && typeof lane.queue?.position === "number") {
+        head += ` (position ${lane.queue.position} in the queue)`;
+      }
+      if (lane.error_message) head += ` \u2014 ${lane.error_message}`;
+      lines.push(head);
+      for (const r of lane.runs ?? []) {
+        const count = r.kind === "group" && typeof r.tests_total === "number" ? ` (${r.tests_passed ?? 0}/${r.tests_total} tests passed)` : "";
+        lines.push(
+          `  ${r.name}: ${r.status}${count}${r.error_message ? ` \u2014 ${r.error_message}` : ""}`
+        );
+      }
+    }
+  } else if (Array.isArray(run.test_runs)) {
+    lines.push(`${run.suite_name ?? "Group"}: ${run.status}`);
+    for (const t of run.test_runs) {
+      const q = t.quarantined && t.status === "failed" ? " (quarantined)" : "";
+      lines.push(
+        `  ${t.case_name}: ${t.status}${q}${t.error_message ? ` \u2014 ${t.error_message}` : ""}${notCheckedNote(t.status, t.steps_not_checked)}`
+      );
+    }
+  } else {
+    const name = run.case_name ?? run.suite_name ?? "Run";
+    const failed = (run.steps ?? []).find((s) => s.status === "failed");
+    const notChecked = typeof run.steps_not_checked === "number" ? run.steps_not_checked : (run.steps ?? []).filter((s) => s.status === "not_checked").length;
+    const q = run.quarantined && run.status === "failed" ? " (quarantined)" : "";
+    lines.push(
+      `${name}: ${run.status}${q}${run.error_message ? ` \u2014 ${run.error_message}` : ""}${notCheckedNote(run.status, notChecked)}`
+    );
+    if (failed) {
+      lines.push(
+        `Failed step: ${failed.step ?? failed.step_text ?? failed.text ?? ""} \u2014 ${failed.error ?? ""}`
+      );
+    }
+  }
+  if (RUN_IN_PROGRESS.has(run.status))
+    lines.push("Still in progress: call get_run again to see the result.");
+  return lines.join("\n");
+}
+async function handleGetRun(args, deps) {
+  const id = String(args.run_id ?? "");
+  if (!id) return errorResult("get_run: `run_id` is required");
+  const client = runClientOf(deps);
+  try {
+    const kind = await client.resolveRun(id);
+    const run = kind.kind === "batch" ? await client.getRunBatch(id) : await client.getRunStatus(id);
+    return textResult(formatRunForAgent(run), run);
+  } catch (err) {
+    return errorResult(`error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 async function dispatchToolCall(toolName, args, deps, extra = {}) {
   if (toolName === "dev_start") {
     return handleDevStart(args, deps, extra);
@@ -300,6 +483,10 @@ async function dispatchToolCall(toolName, args, deps, extra = {}) {
   if (toolName === "stop_session") {
     return handleStopSession(args, deps);
   }
+  if (toolName === "create_test") return handleCreateTest(args, deps);
+  if (toolName === "run_test") return handleRun("test", args, deps);
+  if (toolName === "run_group") return handleRun("group", args, deps);
+  if (toolName === "get_run") return handleGetRun(args, deps);
   const cmd = findCommand(toolName);
   if (!cmd) {
     return errorResult(`Unknown tool: ${toolName}`);
@@ -687,7 +874,7 @@ async function handleUploadApp(args, deps) {
   }
   const name = typeof args.name === "string" && args.name ? args.name : void 0;
   const upload = deps.uploadApp ?? (async (f, n) => {
-    const { uploadAppBuild } = await import("./upload-app-BPTGBDQB.js");
+    const { uploadAppBuild } = await import("./upload-app-UHJLFQKZ.js");
     const { result: result2 } = await uploadAppBuild(f, { ...deps.auth, name: n });
     return result2;
   });
@@ -1079,6 +1266,7 @@ var MCP_INSTRUCTIONS = [
   "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.",
+  "Tests: create_test, then run_test (or run_group) and get_run. With session_id a run uses the session you hold; without it, a run starts its own new device (never your dev_start session).",
   "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");
@@ -1196,6 +1384,7 @@ export {
   createShutdown,
   deviceLine,
   forMcp,
+  formatRunForAgent,
   handleToolCall,
   idleNoticeText,
   mcpText,

package/dist/{upload-app-BPTGBDQB.js → upload-app-UHJLFQKZ.js}

@@ -3,7 +3,7 @@ import {
   describeBuild,
   uploadApp,
   uploadAppBuild
-} from "./chunk-QRJAFBH3.js";
+} from "./chunk-MYXUGCR5.js";
 export {
   describeBuild,
   uploadApp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeview",
-  "version": "0.37.1",
+  "version": "0.38.0",
   "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",
@@ -30,6 +30,7 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "chalk": "^5.0.0",
     "commander": "^14.0.0",
+    "fflate": "~0.8.2",
     "ignore": "^7.0.0",
     "open": "^11.0.0",
     "ora": "^9.0.0",

package/skills/vibeview-agent/SKILL.md

@@ -216,7 +216,7 @@ appear unexplained in their `git status`.
   `roku` over MCP); after an edit run `vibeview dev-reload` (MCP:
   `dev_reload`) to re-package, upload and restart the channel in the same
   session — about five seconds. The remote's names are `press up/down/left/right/select/back`
-  (`dpad_*` also works); `home` is not forwarded. `type` lands in a focused
+  (`dpad_*` also works), plus `enter`, `backspace` and the media keys `play/rewind/forward/replay/info`; `home` is refused (the session stays in your channel); `relaunch-app` restarts the channel with its launch parameters; `clear-text` is unavailable. `type` lands in a focused
   on-screen keyboard; the typed text shows up in the tree as the text box's
   child label, which is what the response verifies against. `logs` returns
   the channel's console output (its `print` lines, why it exited, and the
@@ -287,7 +287,7 @@ human-readable text.
 | `clear-text` | — | Clear the text in the currently focused input field. |
 | `press` | `<button>` | Press a device button or perform a system gesture (home, back, d-pad, etc). |
 | `open-url` | `<url>` | Open a deep link in the app under test, never a browser. Android: a link the app has no screen for fails. iOS/Apple TV: only the app's own URL scheme (`myapp://...`); a web or system link is refused. |
-| `relaunch-app` | — | Close the app and start it again (cold start, data kept) — for "does it persist after a restart" checks. The app log keeps streaming. Not on Roku or embed sessions. |
+| `relaunch-app` | — | Close the app and start it again (cold start, data kept) — for "does it persist after a restart" checks. The app log keeps streaming. Not on embed sessions. |
 | `set-posture` | `<closed\|partial\|open>` or `--angle <0-180>` | Fold or unfold a foldable device (form factor `foldable`: the iPhone Duo, Android foldables) to a preset or an exact hinge angle — exactly one. Reports posture, angle and lit screen. Errors on a device without a hinge. |
 | `rotate` | `[--degrees <90\|180\|270>]` | Rotate the device and report the new orientation. Phones/tablets and Android foldables toggle portrait/landscape (90 only); the iPhone Duo turns a quarter clockwise by default. Not on TV. |
 | `set-location` | `--lat <n> --lon <n>` | Set the device's simulated GPS position (decimal degrees; west and south are negative) for location-based flows. Phones, tablets and foldables; not on TV. |
@@ -331,6 +331,10 @@ steps the CLI does with plain shell commands:
 | `list_builds` | `app` (required) | List an app's uploaded builds with their kind (`debug`/`release`/`unknown`). The MCP equivalent of `vibeview list-builds`. |
 | `dev_stop` | — | Stop the session `dev_start` started. The MCP equivalent of `vibeview dev-stop`. Says "no dev session was running" when there was none. |
 | `stop_session` | `session_id` (required) | Stop any session by id. The MCP equivalent of `vibeview stop <session-id>`. Says so when the session had already ended. |
+| `create_test` | `app`, `name`, `steps` (required), `group` | Create a test from plain-language steps, one per line (a check is a step starting with "Verify"). Returns the test id for `run_test`. |
+| `run_test` | `test` (required), `session_id`, `device_model`, `ai_use`, `start_from_current_screen` | Run a saved test. With `session_id` it runs on a session you hold; without it, VibeView always starts a new device, runs the test and stops it (it never uses your `dev_start` session). `ai_use`: `smart` (default), `no_ai` (replay only), `ai_only`. Returns a run id for `get_run`. |
+| `run_group` | `group` (required), `session_id`, `device_model`, `ai_use`, `start_from_current_screen` | Run every test of a group in order, on `session_id` or, without it, on a new device VibeView starts (never your `dev_start` session). Returns a run id for `get_run`. |
+| `get_run` | `run_id` (required) | A run's status and, when a test failed, which step and why. |
 | `dev_reload` | — | Roku only: re-package, upload and restart the channel in the held session (or this project's `vibeview dev --detach` session). The MCP equivalent of `vibeview dev-reload`. |
 
 If the held session ends elsewhere (dashboard, idle timeout, failure), the