@shipvo/cli 0.1.5 → 0.1.6

package/dist/smoke.d.ts

@@ -0,0 +1,28 @@
+import { type Driver, type Skin } from "./explore.js";
+import { type Envelope } from "./json-out.js";
+export type SmokeData = {
+    platform?: Skin;
+    time_to_first_screen_ms: number | null;
+    elements: number;
+    errors: string[];
+    error_count: number;
+};
+/** What smoke needs from the environment. Tests replace it. */
+export type SmokeDeps = {
+    start: () => Promise<{
+        base: string;
+        stop: () => void;
+    }>;
+    driver: (base: string, app: string, session: string, platform: Skin) => Driver;
+    /** Current accessibility tree. Defaults to the simulator's `screen` action. */
+    screen: (base: string, session: string) => Promise<string>;
+};
+/** Elements in an accessibility tree: lines that carry a ref. */
+export declare const countElements: (tree: string | null | undefined) => number;
+/** Runs the check and returns the envelope and exit code. Never prints. */
+export declare function smokeCheck(argv: string[], deps?: Partial<SmokeDeps>): Promise<{
+    doc: Envelope<string, unknown>;
+    exit: number;
+}>;
+/** Returns the exit code: 0 loads, 1 failed, 2 setup error. */
+export declare function smoke(argv: string[]): Promise<number>;

package/dist/smoke.js

@@ -0,0 +1,117 @@
+// `shipvo smoke`: does the app load? Starts the simulator (startSim), opens the app, waits for the first screen to settle.
+import { existsSync } from "node:fs";
+import { args as parse, BOOLEAN_FLAGS, loadConfig } from "./config.js";
+import { simDriver, startSim } from "./explore.js";
+import { detectPackageManager, installCommand } from "./ensure-playwright.js";
+import { emit, envelope } from "./json-out.js";
+const MAX_ERRORS = 5;
+/** Elements in an accessibility tree: lines that carry a ref. */
+export const countElements = (tree) => (tree ?? "").split("\n").filter((l) => /\[ref=/.test(l)).length;
+async function screenOf(base, session) {
+    const r = await fetch(base.replace(/\/$/, "") + "/act", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ session, action: "screen" }), signal: AbortSignal.timeout(30000) });
+    if (!r.ok)
+        throw new Error(`simulator /act -> ${r.status}`);
+    return (await r.json()).screen ?? "";
+}
+const installNext = () => { const { cmd, args } = installCommand(detectPackageManager(process.cwd(), existsSync)); return { command: `${cmd} ${args.join(" ")} && npx playwright install chromium`, why: "Install the browser the simulator needs." }; };
+/** Words that are not flags or flag values: the platform. */
+const positionals = (argv) => { const out = []; for (let i = 0; i < argv.length; i++) {
+    const x = argv[i];
+    if (x.startsWith("--")) {
+        if (!BOOLEAN_FLAGS.has(x.slice(2)) && argv[i + 1] !== undefined && !argv[i + 1].startsWith("--"))
+            i++;
+    }
+    else
+        out.push(x);
+} return out; };
+/** Runs the check and returns the envelope and exit code. Never prints. */
+export async function smokeCheck(argv, deps) {
+    const a = parse(argv);
+    const setup = (msg, next = [{ command: "shipvo doctor --json", why: "Check the setup." }]) => ({ doc: envelope("setup_error", msg, {}, next, 2), exit: 2 });
+    const pos = positionals(argv);
+    if (pos.length > 1 || (pos[0] !== undefined && pos[0] !== "android" && pos[0] !== "ios"))
+        return setup(`Unknown platform "${pos.join(" ")}". Use android or ios.`, [{ command: "shipvo smoke android", why: "Pick android or ios." }, { command: "shipvo smoke ios", why: "Or the iPhone style." }]);
+    const platform = pos[0] === "ios" ? "ios" : "android";
+    const t = a.timeout === undefined ? 30 : Number(a.timeout);
+    if (!(t > 0) || !Number.isFinite(t))
+        return setup("--timeout must be a number of seconds above 0", [{ command: "shipvo smoke --timeout 30", why: "Use a positive number." }]);
+    let cfg;
+    try {
+        cfg = loadConfig();
+    }
+    catch (e) {
+        return setup(e instanceof Error ? e.message : String(e), [{ command: "shipvo init .", why: "Set up this folder." }]);
+    }
+    const json = argv.includes("--json");
+    let sim;
+    try {
+        sim = await (deps?.start ?? (() => startSim(a, cfg, json)))();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const browser = /playwright|chromium|browser|exited before it was ready/i.test(msg);
+        return setup(msg, browser ? [installNext(), { command: "shipvo doctor --json", why: "Check the setup." }] : undefined);
+    }
+    let timer;
+    try {
+        const session = `smoke-${Date.now().toString(36)}`;
+        const driver = (deps?.driver ?? simDriver)(sim.base, cfg.appId, session, platform);
+        const get = deps?.screen ?? screenOf;
+        const started = Date.now();
+        const timedOut = new Promise((ok) => { timer = setTimeout(() => ok("timeout"), t * 1000); });
+        const run = (async () => {
+            const opened = await driver.open();
+            if (!opened.ok)
+                throw new Error(opened.error ?? "the simulator could not open the app");
+            let tree = opened.screen ?? "";
+            // Settled: two snapshots in a row are the same.
+            for (let i = 0; i < 20; i++) {
+                const next = await get(sim.base, session);
+                const same = next === tree;
+                tree = next;
+                if (same)
+                    break;
+                await new Promise((r) => setTimeout(r, 100));
+            }
+            return { ms: Date.now() - started, tree, errors: await driver.errors() };
+        })();
+        run.catch(() => { });
+        const r = await Promise.race([run, timedOut]);
+        if (r === "timeout") {
+            const data = { platform, time_to_first_screen_ms: null, elements: 0, errors: [], error_count: 0 };
+            return { doc: envelope("timeout", `The app did not show a first screen within ${t} s`, data, [{ command: `shipvo smoke ${platform} --timeout ${Math.ceil(t * 2)} --json`, why: "Try a longer timeout." }], 1), exit: 1 };
+        }
+        const elements = countElements(r.tree);
+        const data = { platform, time_to_first_screen_ms: r.ms, elements, errors: r.errors.slice(0, MAX_ERRORS), error_count: r.errors.length };
+        if (r.errors.length)
+            return { doc: envelope("errors", `The app threw ${r.errors.length} error${r.errors.length === 1 ? "" : "s"} while loading: ${r.errors[0]}`, data, [{ command: `shipvo smoke ${platform} --json`, why: "Run again after fixing." }], 1), exit: 1 };
+        if (!elements)
+            return { doc: envelope("empty_screen", "The first screen has no elements", data, [{ command: `shipvo smoke ${platform} --json`, why: "Run again after fixing." }], 1), exit: 1 };
+        return { doc: envelope("ok", `The app loads on ${platform}: first screen in ${r.ms} ms, ${elements} element${elements === 1 ? "" : "s"}, no errors`, data, [{ command: "shipvo test --json", why: "Run your step files." }], 0), exit: 0 };
+    }
+    catch (e) {
+        return setup(e instanceof Error ? e.message : String(e));
+    }
+    finally {
+        clearTimeout(timer);
+        sim.stop();
+    }
+}
+/** Returns the exit code: 0 loads, 1 failed, 2 setup error. */
+export async function smoke(argv) {
+    const { doc, exit } = await smokeCheck(argv);
+    if (argv.includes("--json"))
+        emit(doc);
+    else {
+        console.log(doc.summary);
+        const d = doc.data;
+        for (const e of d.errors ?? [])
+            console.log(`  error: ${e}`);
+        if ((d.error_count ?? 0) > (d.errors?.length ?? 0))
+            console.log(`  …and ${d.error_count - d.errors.length} more`);
+        if (exit)
+            for (const n of doc.next)
+                console.error(`Next: ${n.command}  (${n.why})`);
+    }
+    return exit;
+}

package/dist/spawn-bin.d.ts

@@ -0,0 +1,11 @@
+export interface SpawnCall {
+    command: string;
+    args: string[];
+    shell?: boolean;
+}
+/**
+ * Build the arguments for `spawn`. On Windows, npx, npm and pnpm are `.cmd`
+ * shims, which need a shell, so the args are quoted for cmd.exe.
+ * On other platforms the call is returned unchanged.
+ */
+export declare function spawnBin(command: string, args: string[], platform?: NodeJS.Platform): SpawnCall;

package/dist/spawn-bin.js

@@ -0,0 +1,21 @@
+const WIN_CMD_SHIMS = new Set(["npx", "npm", "pnpm"]);
+const NEEDS_QUOTES = /[\s&|<>^(),;=]/;
+function quoteForCmd(arg) {
+    if (!NEEDS_QUOTES.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '\\"')}"`;
+}
+/**
+ * Build the arguments for `spawn`. On Windows, npx, npm and pnpm are `.cmd`
+ * shims, which need a shell, so the args are quoted for cmd.exe.
+ * On other platforms the call is returned unchanged.
+ */
+export function spawnBin(command, args, platform = process.platform) {
+    if (platform !== "win32")
+        return { command, args };
+    return {
+        command: WIN_CMD_SHIMS.has(command) ? `${command}.cmd` : command,
+        args: args.map(quoteForCmd),
+        shell: true,
+    };
+}

package/dist/status.d.ts

@@ -1,3 +1,5 @@
+import { type Next } from "./json-out.js";
+export type { Next };
 type Row = {
     release: number;
     events: Record<string, number>;
@@ -16,12 +18,27 @@ type Halted = {
 };
 /** Plain-text table: one row per release, one column per event name, then the two medians. */
 export declare function formatStatus(releases: Row[]): string;
+/** What a band serves: a release number, null when it has none (404), or "?" when it cannot be read. */
+export type BandValue = number | null | "?";
+/** Release each band serves, from the public pointer. A halted release or a failed read gives "?", not "no release". */
+export declare function fetchBands(base: string, appId: string, major: number, fetchFn: typeof fetch): Promise<Record<string, BandValue>>;
+/** "bands: b0=4 b1=4 b2=4", plus a hint to promote when readable bands differ. "-" is no release, "?" is unreadable. */
+export declare function describeBands(bands: Record<string, BandValue>): string[];
 /** "auto-halt: off" or "auto-halt: on at 20% after 20 reports". */
 export declare function describeAutoHalt(c: AutoHalt | undefined): string;
-export type Next = {
-    command: string;
-    why: string;
+export type TestRelease = {
+    release: number;
+    passing: number;
+    failing: number;
+    failing_flows?: {
+        name: string;
+        first_failed_release: number;
+    }[];
 };
+/** Test results the app uploaded with shipvo test --upload. Empty when none exist or the control plane cannot say. */
+export declare function fetchTestResults(base: string, appId: string, fetchFn: typeof fetch): Promise<TestRelease[]>;
+/** "tests: release 3: 2 failing (checkout, since release 2)" lines, newest first. */
+export declare function describeTests(tests: TestRelease[]): string[];
 export type StatusJson = {
     ok: boolean;
     code: "ok" | "no_project" | "no_signing_key" | "release_halted" | "no_release" | "error";
@@ -52,6 +69,12 @@ export type StatusJson = {
             title: string;
             state: string;
         } | null;
+        skills: {
+            package: string;
+            name: string;
+            synced: boolean;
+        }[];
+        tests: TestRelease[];
     };
     next: Next[];
 };
@@ -61,4 +84,3 @@ export declare function statusJson(appArg: string | undefined, fetchFn: typeof f
     exit: number;
 }>;
 export declare function status(argv: string[], fetchFn?: typeof fetch): Promise<number>;
-export {};

package/dist/status.js

@@ -1,9 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { routeStore } from "@shipvo/store";
-import { args, loadConfig } from "./config.js";
-import { detectProject } from "./agents.js";
+import { args, loadConfig, publishToken } from "./config.js";
+import { detectProject, skillStatus } from "./agents.js";
 import { portFree } from "./sim.js";
+import { emit } from "./json-out.js";
 const ms = (v) => (typeof v === "number" ? String(Math.round(v)) : "-");
 /** Plain-text table: one row per release, one column per event name, then the two medians. */
 export function formatStatus(releases) {
@@ -13,6 +14,41 @@ export function formatStatus(releases) {
     const w = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
     return rows.map((r) => r.map((c, i) => (i === 0 ? c.padEnd(w[i]) : c.padStart(w[i]))).join("  ")).join("\n");
 }
+const BANDS = ["b0", "b1", "b2"];
+/** Release each band serves, from the public pointer. A halted release or a failed read gives "?", not "no release". */
+export async function fetchBands(base, appId, major, fetchFn) {
+    const out = {};
+    await Promise.all(BANDS.map(async (b) => {
+        out[b] = "?";
+        try {
+            const r = await fetchFn(`${base}/p/${encodeURIComponent(appId)}/${major}/${b}`);
+            if (r.status === 404) {
+                // Only "no_release" means none. release_halted and mismatch errors also answer 404.
+                const e = (await r.json().catch(() => null));
+                if (e?.error === "no_release")
+                    out[b] = null;
+                return;
+            }
+            if (!r.ok)
+                return;
+            const env = (await r.json());
+            const rel = JSON.parse(String(env.body)).release;
+            if (typeof rel === "number")
+                out[b] = rel;
+        }
+        catch { /* unreadable: show "?" */ }
+    }));
+    return out;
+}
+/** "bands: b0=4 b1=4 b2=4", plus a hint to promote when readable bands differ. "-" is no release, "?" is unreadable. */
+export function describeBands(bands) {
+    const line = `bands: ${BANDS.map((b) => `${b}=${bands[b] ?? "-"}`).join(" ")}`;
+    const readable = BANDS.map((b) => bands[b] ?? null).filter((v) => v !== "?");
+    if (new Set(readable).size < 2)
+        return [line];
+    const newest = Math.max(...readable.filter((v) => v !== null));
+    return [line, `Bands differ. Run shipvo promote to give every band the newest release (${newest}).`];
+}
 /** "auto-halt: off" or "auto-halt: on at 20% after 20 reports". */
 export function describeAutoHalt(c) {
     if (!c || typeof c.threshold !== "number")
@@ -20,6 +56,26 @@ export function describeAutoHalt(c) {
     const n = c.min_reports ?? 20;
     return `auto-halt: on at ${Math.round(c.threshold * 1000) / 10}% after ${n} report${n === 1 ? "" : "s"}`;
 }
+/** Test results the app uploaded with shipvo test --upload. Empty when none exist or the control plane cannot say. */
+export async function fetchTestResults(base, appId, fetchFn) {
+    const token = publishToken();
+    if (!token)
+        return [];
+    try {
+        const r = await fetchFn(`${base}/r/${encodeURIComponent(appId)}/tests`, { headers: { authorization: `Bearer ${token}` } });
+        if (!r.ok)
+            return [];
+        const d = (await r.json());
+        return Array.isArray(d.releases) ? d.releases : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** "tests: release 3: 2 failing (checkout, since release 2)" lines, newest first. */
+export function describeTests(tests) {
+    return tests.map((t) => `tests: release ${t.release}: ${t.failing ? `${t.failing} failing (${(t.failing_flows ?? []).map((f) => `${f.name}${f.first_failed_release === t.release ? "" : `, since release ${f.first_failed_release}`}`).join("; ")})` : `all ${t.passing} passing`}`);
+}
 const alive = (pid) => { try {
     process.kill(pid, 0);
     return true;
@@ -52,9 +108,10 @@ async function localFacts(dir, simPort = 4545) {
 export async function statusJson(appArg, fetchFn, dir = process.cwd()) {
     const kind = detectProject(dir);
     const f = await localFacts(dir);
-    const shared = { sim: f.sim, run_server: f.run, signing_key: { present: f.hasKey }, store_step: f.storeStep };
+    const shared = { sim: f.sim, run_server: f.run, signing_key: { present: f.hasKey }, store_step: f.storeStep, skills: skillStatus(dir) };
+    let tests = [];
     const mk = (code, summary, next, appId, pending, exit) => ({
-        doc: { ok: exit === 0, code, summary, data: { project: { kind, app_id: appId }, ...shared, pending_release: pending }, next }, exit,
+        doc: { ok: exit === 0, code, summary, data: { project: { kind, app_id: appId }, ...shared, pending_release: pending, tests }, next }, exit,
     });
     if (!existsSync(join(dir, "shipvo.json"))) {
         return mk("no_project", "No shipvo.json here.", [{ command: kind === "unknown" ? "shipvo init myapp" : "shipvo init .", why: "This folder is not set up for Shipvo yet." }], null, null, 1);
@@ -79,6 +136,7 @@ export async function statusJson(appArg, fetchFn, dir = process.cwd()) {
         return mk("error", `Could not reach the control plane at ${baseUrl} (${e instanceof Error ? e.message : String(e)}).`, [{ command: "shipvo doctor", why: "Check the control plane URL and network." }], appId, null, 2);
     }
     const releases = data.releases ?? [];
+    tests = await fetchTestResults(baseUrl, appId, fetchFn);
     const pending = { newest: releases.length ? Math.max(...releases.map((r) => r.release)) : null, halted: data.halted ?? null, auto_halt: data.auto_halt ?? null };
     const next = [];
     let code = "ok", exit = 0;
@@ -111,7 +169,7 @@ export async function status(argv, fetchFn = fetch) {
     const a = args(argv);
     if (argv.includes("--json")) {
         const { doc, exit } = await statusJson(a.app && a.app !== "true" ? a.app : undefined, fetchFn);
-        console.log(JSON.stringify(doc));
+        emit(doc);
         return exit;
     }
     const cfg = loadConfig();
@@ -133,8 +191,11 @@ export async function status(argv, fetchFn = fetch) {
     // An older control plane has no auto_halt field: say nothing rather than a wrong "off".
     if ("auto_halt" in data)
         console.log(describeAutoHalt(data.auto_halt));
+    const printBands = async () => { for (const l of describeBands(await fetchBands(base, appId, cfg.shellMajor, fetchFn)))
+        console.log(l); };
     if (!releases.length) {
         console.log(`No telemetry yet for "${appId}".`);
+        await printBands();
         return 0;
     }
     const h = data.halted;
@@ -143,5 +204,8 @@ export async function status(argv, fetchFn = fetch) {
         console.log(`Release ${h.release} is halted: ${h.failed} of ${h.reports} devices failed (limit ${pct}%). Publish a new release or run shipvo rollback to clear.`);
     }
     console.log(formatStatus(releases));
+    for (const l of describeTests(await fetchTestResults(base, appId, fetchFn)))
+        console.log(l);
+    await printBands();
     return 0;
 }

package/dist/templates/github-action/shipvo-check.yml

@@ -0,0 +1,18 @@
+name: Shipvo check
+
+on:
+  pull_request:
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: shipvo/shipvo/actions/check@main

package/dist/test.d.ts

@@ -42,5 +42,5 @@ export type FlowReport = {
     message: string | null;
 };
 /** Runs the suite. Returns the exit code: 0 when every step passed (or every failure was repaired and written), 1 otherwise. */
-export declare function testCmd(argv: string[], kit?: TestKit, rawLog?: (s: string) => void): Promise<number>;
+export declare function testCmd(argv: string[], kit?: TestKit, rawLog?: (s: string) => void, fetchFn?: typeof fetch): Promise<number>;
 export {};

package/dist/test.js

@@ -6,6 +6,8 @@ import { execFileSync } from "node:child_process";
 import { PARITY_LIMITS } from "./explore.js";
 import { renderReportMarkdown } from "./report-md.js";
 import { pathToFileURL } from "node:url";
+import { emit, envelope } from "./json-out.js";
+import { loadConfig, publishToken } from "./config.js";
 /** The same step as a plain-language line (only the target of a tap or type step is ever rewritten). */
 export function stepLine(s) {
     const bad = (v) => v !== undefined && /["\r\n]/.test(v);
@@ -80,41 +82,72 @@ function flagValue(argv, name) {
     return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[i + 1] : undefined;
 }
 /** Runs the suite. Returns the exit code: 0 when every step passed (or every failure was repaired and written), 1 otherwise. */
-export async function testCmd(argv, kit, rawLog = console.log) {
+export async function testCmd(argv, kit, rawLog, fetchFn = fetch) {
+    const json = argv.includes("--json");
+    // With --json, stdout holds only the document: progress goes to stderr.
+    const out = rawLog ?? (json ? (s) => console.error(s) : console.log);
+    const flows = [];
+    const fail = (msg, next, code = "usage") => {
+        if (json)
+            emit(envelope(code, msg, { flows }, next, 2));
+        else
+            console.error(msg);
+        return 2;
+    };
     const repair = argv.includes("--repair");
     const write = argv.includes("--write");
     if (write && !repair) {
-        console.error("--write only works with --repair");
-        return 2;
+        return fail("--write only works with --repair", [{ command: "shipvo test --repair --write", why: "--write needs --repair." }]);
     }
     const reportPath = flagValue(argv, "--report");
     const release = flagValue(argv, "--release");
     const reportMdPath = flagValue(argv, "--report-md");
+    const platform = flagValue(argv, "--platform") ?? "android";
+    const upload = argv.includes("--upload");
+    if (platform !== "android" && platform !== "ios") {
+        return fail('--platform must be "android" or "ios"', [{ command: "shipvo test --platform ios", why: "Pass android or ios." }]);
+    }
+    if (upload && !reportPath) {
+        return fail("--upload needs --report <file>", [{ command: "shipvo test --report report.json --release 12 --upload", why: "Upload sends the report file." }]);
+    }
+    if (upload && !release) {
+        return fail("--upload needs --release <number>", [{ command: "shipvo test --report report.json --release 12 --upload", why: "Results are stored per release." }]);
+    }
     if (argv.includes("--report") && !reportPath) {
-        console.error("--report needs a file name");
-        return 2;
+        return fail("--report needs a file name", [{ command: "shipvo test --report report.json", why: "Pass a file name." }]);
     }
     if (argv.includes("--report-md") && !reportMdPath) {
-        console.error("--report-md needs a file name");
-        return 2;
+        return fail("--report-md needs a file name", [{ command: "shipvo test --report-md report.md", why: "Pass a file name." }]);
     }
-    const valueIdx = new Set(["--report", "--report-md", "--release"].map((f) => argv.indexOf(f) + 1).filter((i) => i > 0));
+    const valueIdx = new Set(["--report", "--report-md", "--release", "--platform"].map((f) => argv.indexOf(f) + 1).filter((i) => i > 0));
     const given = argv.filter((a, i) => !a.startsWith("--") && !valueIdx.has(i));
-    const flows = [];
     const files = given.length ? given : findStepFiles("tests");
     if (!files.length) {
-        console.error("No tests found. Put plain-language steps in tests/*.steps, or pass file names.");
-        return 2;
+        return fail("No tests found. Put plain-language steps in tests/*.steps, or pass file names.", [{ command: "shipvo test tests/example.steps", why: "Pass a steps file, or add tests/*.steps." }]);
+    }
+    let k;
+    try {
+        k = kit ?? (await loadKit());
+    }
+    catch (e) {
+        return fail(e.message, [{ command: "npm i -D @shipvo/test", why: "shipvo test needs @shipvo/test in the app." }]);
     }
-    const k = kit ?? (await loadKit());
     const scrub = (t) => k.redact?.(t) ?? t;
     // Every line goes through scrub: screen text and errors can echo a secret.
-    const log = (s) => rawLog(scrub(s));
+    const log = (s) => out(scrub(s));
     let failed = 0, repaired = 0, unresolved = 0;
     for (const file of files) {
-        const text = readFileSync(file, "utf8");
-        const steps = k.parseSteps(text);
-        const phone = await k.openApp();
+        let text, steps, phone;
+        try {
+            text = readFileSync(file, "utf8");
+            steps = k.parseSteps(text);
+            phone = await k.openApp();
+        }
+        catch (e) {
+            if (!json)
+                throw e;
+            return fail(`${file}: ${scrub(e.message.split("\n")[0])}`, [{ command: "shipvo doctor --json", why: "Check the steps file path, the step syntax and the simulator." }], "error");
+        }
         const edits = new Map();
         const flow = { name: file, status: "passed", steps, failedStep: null, message: null };
         flows.push(flow);
@@ -176,7 +209,7 @@ export async function testCmd(argv, kit, rawLog = console.log) {
     else
         log(failed ? `${failed} failed` : "all steps passed");
     if (reportPath || reportMdPath) {
-        const report = { app: appIdFromConfig(), commit: gitCommit(), release: release ?? null, time: new Date().toISOString(), parityLimits: PARITY_LIMITS, flows };
+        const report = { app: appIdFromConfig(), commit: gitCommit(), release: release ?? null, platform, time: new Date().toISOString(), parityLimits: PARITY_LIMITS, flows };
         if (reportPath) {
             writeFileSync(reportPath, JSON.stringify(report, null, 2) + "\n");
             log(`wrote report ${reportPath}`);
@@ -186,5 +219,35 @@ export async function testCmd(argv, kit, rawLog = console.log) {
             log(`wrote Markdown report ${reportMdPath}`);
         }
     }
-    return failed === 0 || (write && repaired === failed) ? 0 : 1;
+    let uploadError = null;
+    if (upload && reportPath) {
+        const token = publishToken();
+        try {
+            if (!token)
+                throw new Error("No publish token. Set SHIPVO_PUBLISH_TOKEN, or run shipvo app create.");
+            const base = loadConfig().controlPlane.replace(/\/$/, "");
+            const appId = appIdFromConfig();
+            if (!appId)
+                throw new Error("No appId in shipvo.json.");
+            const r = await fetchFn(`${base}/r/${encodeURIComponent(appId)}/${encodeURIComponent(release)}/tests`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: readFileSync(reportPath, "utf8") });
+            if (!r.ok) {
+                const e = (await r.json().catch(() => null));
+                throw new Error(e?.message ?? e?.error ?? `HTTP ${r.status}`);
+            }
+            log(`uploaded report for release ${release} (${platform})`);
+        }
+        catch (e) {
+            uploadError = e.message;
+            log(`Could not upload the report: ${uploadError}`);
+        }
+    }
+    const exit = failed === 0 || (write && repaired === failed) ? 0 : 1;
+    if (json) {
+        const bad = flows.filter((f) => f.status === "failed");
+        const data = { uploaded: upload ? !uploadError : undefined, upload_error: uploadError ?? undefined, flows: flows.map((f) => ({ name: f.name, status: f.status, steps: f.steps.length, failedStep: f.failedStep, message: f.message })), failed, repaired, unresolved };
+        emit(exit === 0
+            ? envelope("ok", failed ? `${failed} failed step(s) repaired and written.` : `All ${flows.length} flow(s) passed.`, data, [{ command: "shipvo explore --json", why: "Walk the app for crashes and accessibility problems." }], 0)
+            : envelope("tests_failed", `${bad.length} of ${flows.length} flow(s) failed.`, data, [repair ? { command: "shipvo test --repair --write", why: "Write the proposed repairs to the steps files." } : { command: `shipvo test ${bad[0]?.name ?? ""} --repair --json`.replace("  ", " "), why: "Show a diff that fixes broken steps." }], 1));
+    }
+    return exit;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipvo/cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "license": "Apache-2.0",
   "bin": {
@@ -12,8 +12,8 @@
     "@noble/ed25519": "^2.1.0",
     "@noble/hashes": "^1.5.0",
     "plist": "^3.1.1",
-    "@shipvo/schema": "0.0.5",
-    "@shipvo/sim": "^0.1.5",
+    "@shipvo/schema": "0.0.6",
+    "@shipvo/sim": "^0.1.6",
     "@shipvo/store": "^0.0.2"
   },
   "devDependencies": {
@@ -52,6 +52,7 @@
     "directory": "packages/cli"
   },
   "files": [
+    "skills",
     "dist",
     "README.md"
   ],

package/skills/shipvo-cli/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: shipvo-cli
+description: Use the shipvo command line. Use when the project depends on @shipvo/cli and you need the right command to set up, check status, publish, roll back or configure agents.
+---
+
+# @shipvo/cli
+
+Run from the app's root folder. Use `npx -y @shipvo/cli <command>` if `shipvo` is not on the path.
+
+When unsure, run these two:
+
+```bash
+shipvo doctor
+shipvo status --json
+```
+
+`status --json` prints `ok`, `code`, `summary`, `data` and `next`. `next` is a list of `{ command, why }`: run those. Exit codes: 0 ok, 1 action needed, 2 error. `data.skills` lists the package skills and whether each is synced.
+
+## Common commands
+
+```bash
+shipvo init --dry-run     # print the plan, change nothing
+shipvo init --yes         # apply it
+shipvo sim                # simulator on http://localhost:4545
+shipvo publish --dry-run  # check a release before you publish
+shipvo rollback --to <release>
+shipvo agents setup       # AGENTS.md, .mcp.json and package skills
+shipvo skills sync        # only copy package skills
+```
+
+Add `--dry-run` to `agents setup` and `skills sync` to see what would change. Both are safe to run again. Run `shipvo help` for every command.