@shipvo/cli 0.1.4 → 0.1.6

package/dist/publish.js

@@ -1,14 +1,15 @@
 // `shipvo publish`: build the Hermes bundle, sign a release pointer, publish bundle + patches + the agent-facing web
 // artifact to the control plane. `shipvo rollback --to N`: republish an earlier bundle as a new release.
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import path, { dirname, join, relative, resolve } from "node:path";
 import { sha256Hex, signBytes } from "./index.js";
-import { checkBundle, parseDeclared } from "./hermes.js";
+import { bsdiff } from "./bsdiff.js";
+import { checkBundle, checkEngine, installedHermesEngine, parseDeclared, parseEngine } from "./hermes.js";
 import { requiredNativeModules } from "./native.js";
 import { checkPublishPolicy } from "./policy.js";
-import { args as parse, kv as kvFor, loadConfig, seed } from "./config.js";
+import { CliFailure, UsageError, runJson } from "./json-out.js";
+import { args as parse, hasStore, kv as kvFor, loadConfig, offlineKv, seed } from "./config.js";
 const MIME = { ".html": "text/html", ".js": "text/javascript", ".json": "application/json", ".css": "text/css", ".ico": "image/x-icon", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".ttf": "font/ttf", ".svg": "image/svg+xml" };
 const walk = (d) => readdirSync(d).flatMap((f) => (statSync(join(d, f)).isDirectory() ? walk(join(d, f)) : [join(d, f)]));
 /** Release numbers are shared across platforms, so one number means one commit everywhere. */
@@ -34,7 +35,7 @@ const platformsOf = (a) => {
         return ["android", "ios"];
     if (p === "android" || p === "ios")
         return [p];
-    throw new Error(`--platform must be android, ios or all (got "${a.platform}")`);
+    throw new UsageError(`--platform must be android, ios or all (got "${a.platform}")`);
 };
 /** Unknown flags are errors: a typo like --dryrun must not fall through to a real publish. */
 function checkFlags(argv, known) {
@@ -42,7 +43,7 @@ function checkFlags(argv, known) {
     if (bad.length) {
         const eq = bad.find((x) => x.includes("="));
         const hint = eq ? ` Write "${eq.replace("=", " ")}" (a space, not =).` : "";
-        throw new Error(`Unknown flag ${bad.join(", ")}.${hint} Known flags: ${known.map((k) => "--" + k).join(" ")}`);
+        throw new UsageError(`Unknown flag ${bad.join(", ")}.${hint} Known flags: ${known.map((k) => "--" + k).join(" ")}`);
     }
 }
 /** An on/off flag: bare or "true" is on, "false" is off. Anything else is an error, so a typo never flips it silently. */
@@ -52,7 +53,12 @@ function switchFlag(a, name) {
         return false;
     if (v === "true")
         return true;
-    throw new Error(`--${name} is an on/off flag: use --${name}, --${name} true or --${name} false (got "${v}")`);
+    throw new UsageError(`--${name} is an on/off flag: use --${name}, --${name} true or --${name} false (got "${v}")`);
+}
+/** True when `file` is strictly inside `root`. Uses the platform's separator, so it works with Windows paths too. */
+export function isInside(root, file, p = path) {
+    const rel = p.relative(root, file);
+    return rel !== "" && !rel.startsWith("..") && !p.isAbsolute(rel);
 }
 /** A store that only writes files under `dir` (key `p/app/1/b0` becomes `dir/p/app/1/b0`). It reads back only what this run wrote (kept in memory), never old files, so the iOS pass can find the web artifact and a dry run never needs a control plane. */
 function localKv(dir) {
@@ -65,7 +71,7 @@ function localKv(dir) {
         async keys(prefix) { return [...mem.keys()].filter((k) => k.startsWith(prefix)); },
         async put(k, body, _type) {
             const f = resolve(root, k);
-            if (!f.startsWith(root + "/"))
+            if (!isInside(root, f))
                 throw new Error(`refusing to write outside ${dir}: ${k}`);
             const bytes = typeof body === "string" ? enc.encode(body) : new Uint8Array(body);
             mkdirSync(dirname(f), { recursive: true });
@@ -74,7 +80,7 @@ function localKv(dir) {
         },
     };
 }
-const PUBLISH_FLAGS = ["bands", "platform", "release", "min-shell", "hermes-bytecode-version", "max-bases", "skip-export", "skip-web", "dry-run", "out"];
+const PUBLISH_FLAGS = ["bands", "platform", "release", "min-shell", "hermes-bytecode-version", "max-bases", "skip-export", "skip-web", "dry-run", "dry-run-policy", "out", "json"];
 export const PUBLISH_HELP = `Usage: shipvo publish [flags]
 
 Build, sign and publish an over-the-air release.
@@ -89,28 +95,48 @@ Flags (write a value after a space, not =; on/off flags can be bare, or true/fal
   --skip-export               Reuse the last build in dist-ota/
   --skip-web                  Do not publish the web copy for the simulator
   --dry-run                    Build and sign, write files locally, send nothing
+  --dry-run-policy             Check the policy in shipvo.json for these --bands, print the result, publish nothing
   --out <dir>                  Where --dry-run writes files (default .shipvo/dry-run)
+  --json                       Print one JSON envelope on stdout; text and build output go to stderr
   --help                       Show this help
 `;
+const DOCTOR = [{ command: "shipvo doctor --json", why: "Check your setup." }];
 export async function publish(argv) {
     if (argv.includes("--help") || argv.includes("-h")) {
         console.log(PUBLISH_HELP);
         return;
     }
+    if (argv.includes("--json"))
+        return runJson(() => publishRun(argv, true), DOCTOR);
+    await publishRun(argv, false);
+}
+async function publishRun(argv, json) {
+    // In --json mode the build tools must not write to stdout either.
+    const io = json ? ["inherit", 2, 2] : "inherit";
     checkFlags(argv, PUBLISH_FLAGS);
     const a = parse(argv), cfg = loadConfig(), SEED = seed();
+    if (switchFlag(a, "dry-run-policy")) {
+        const verdict = checkPublishPolicy(cfg.policy, (a.bands || "b0,b1,b2").split(","));
+        if (verdict.ok) {
+            const msg = cfg.policy === undefined ? "No policy in shipvo.json: nothing to check." : "Policy allows this publish.";
+            console.log(msg);
+            return { code: "policy_ok", summary: msg, data: { policy: cfg.policy === undefined ? "none" : "allowed", bands: (a.bands || "b0,b1,b2").split(",") }, next: [{ command: "shipvo publish --dry-run --json", why: "Build and sign without sending." }] };
+        }
+        return refused(verdict, json);
+    }
     const dry = switchFlag(a, "dry-run"), skipExport = switchFlag(a, "skip-export"), skipWeb = switchFlag(a, "skip-web");
     if (a.out !== undefined && !dry)
-        throw new Error("--out only works with --dry-run");
+        throw new UsageError("--out only works with --dry-run");
     if (a.out === "true")
-        throw new Error("--out needs a directory: pass --out <dir>");
+        throw new UsageError("--out needs a directory: pass --out <dir>");
     const outDir = a.out || ".shipvo/dry-run";
     const kv = dry ? localKv(outDir) : kvFor(cfg);
     const APP = cfg.appId, MAJOR = cfg.shellMajor;
     const MIN_SHELL = a["min-shell"] || JSON.parse(readFileSync("app.json", "utf8")).expo.version; // a bundle needs the shell it was built against
     if (a["hermes-bytecode-version"] === "true")
-        throw new Error("--hermes-bytecode-version needs a value: pass a value like 96 (or 96,98)");
+        throw new UsageError("--hermes-bytecode-version needs a value: pass a value like 96 (or 96,98)");
     const declaredHermes = parseDeclared(a["hermes-bytecode-version"] ?? cfg.hermesBytecodeVersion);
+    const hermesEngine = checkEngine(installedHermesEngine(process.cwd()), parseEngine(cfg.hermesEngine)); // fails before anything is uploaded
     const skippedNative = [];
     const nativeModules = requiredNativeModules(".", skippedNative);
     if (skippedNative.length)
@@ -120,11 +146,8 @@ export async function publish(argv) {
     const bands = (a.bands || "b0,b1,b2").split(",");
     if (dry) {
         const verdict = checkPublishPolicy(cfg.policy, bands);
-        if (!verdict.ok) {
-            console.error(`Refused by policy rule ${verdict.rule}: ${verdict.reason}`);
-            process.exitCode = 1;
-            return;
-        }
+        if (!verdict.ok)
+            return refused(verdict, json);
     }
     const platforms = platformsOf(a);
     const release = Number(a.release || 0) || (await currentRelease(kv, APP, MAJOR)) + 1;
@@ -132,16 +155,16 @@ export async function publish(argv) {
     if (dry)
         console.error(`dry run: nothing is sent anywhere; files go to ${outDir}. No patches are built offline. Release is ${release}${a.release ? "" : " (pass --release N to match the control plane)"}.`);
     let totalBytes = 0;
-    const patchInfo = { bases: 0, bsdiff: false, patches: 0 };
+    const patchInfo = { bases: 0, patches: 0 };
     for (const pf of platforms) {
         // Android published alone keeps the original dist-ota/ layout, so existing CI keeps working.
         const root = platforms.length === 1 && pf === "android" ? "dist-ota" : `dist-ota/${pf}`;
         if (!skipExport)
-            execSync(`npx expo export --platform ${pf} --output-dir ${root} --clear`, { stdio: "inherit" });
+            execSync(`npx expo export --platform ${pf} --output-dir ${root} --clear`, { stdio: io });
         const jsDir = `${root}/_expo/static/js/${pf}`;
         const file = readdirSync(jsDir).find((f) => f.endsWith(".hbc")) || readdirSync(jsDir).find((f) => f.endsWith(".js"));
         if (!file)
-            throw new Error("no bundle in " + jsDir);
+            throw new CliFailure("no bundle in " + jsDir, "no_bundle", 1, [{ command: "shipvo publish --json", why: "Run again without --skip-export so the bundle is built." }]);
         const bytes = new Uint8Array(readFileSync(join(jsDir, file)));
         const hermesVersion = checkBundle(file, bytes, declaredHermes); // fails before anything is uploaded
         const name = bundleName(release, pf), newSha = sha256Hex(bytes);
@@ -169,29 +192,23 @@ export async function publish(argv) {
                 }
                 catch { }
             }
-            // Only look for bsdiff4 when there is an older bundle to patch from; a first release needs no patches.
-            let bsdiff = false;
+            // Memory grows with bundle size (plain arrays); only a thrown error falls back to the full bundle.
+            // Patches are built in-process (no Python or other tool); a first release has no older bundle to patch from.
             if (bases.size > 0) {
-                try {
-                    execSync("python3 -c 'import bsdiff4'", { stdio: "ignore" });
-                    bsdiff = true;
-                }
-                catch {
-                    console.error("Small patches are off because the Python tool bsdiff4 is not installed (pip install bsdiff4). Full bundles are published instead. Updates still work, they are just bigger.");
-                }
-            }
-            if (bsdiff) {
-                const work = mkdtempSync(join(tmpdir(), "shipvo-"));
-                writeFileSync(join(work, "new.hbc"), bytes);
                 for (const [fromSha, key] of bases) {
                     if (fromSha === newSha)
                         continue;
                     const base = await kv.getBytes(key);
                     if (!base)
                         continue;
-                    writeFileSync(join(work, "old.hbc"), base);
-                    execSync(`python3 -c "import bsdiff4; bsdiff4.file_diff('${join(work, "old.hbc")}', '${join(work, "new.hbc")}', '${join(work, "p.bsdiff")}')"`);
-                    const patch = new Uint8Array(readFileSync(join(work, "p.bsdiff")));
+                    let patch;
+                    try {
+                        patch = bsdiff(new Uint8Array(base), bytes);
+                    }
+                    catch {
+                        console.error(`Could not build a small patch from release ${fromSha.slice(0, 8)}; publishing the full bundle`);
+                        continue;
+                    }
                     if (patch.length >= bytes.length * 0.6)
                         continue;
                     const pkey = `b/${APP}/${pf === "ios" ? "ios-" : ""}d-${fromSha.slice(0, 16)}-r${release}.bsdiff`;
@@ -200,14 +217,13 @@ export async function publish(argv) {
                 }
             }
             patchInfo.bases = bases.size;
-            patchInfo.bsdiff = bsdiff;
             patchInfo.patches = patches.length;
             console.error(`patches: ${patches.map((p) => `${p.from_sha256.slice(0, 8)}=${(p.size / 1024).toFixed(1)}KB`).join(", ") || "none"}`);
         }
         // The agent-facing web artifact of the same commit, served at /w/<app>/r<N>/ for the simulator (built once, with the first platform).
         let web = null;
         if (!skipWeb && pf === platforms[0]) {
-            web = await publishWeb(kv, cfg, APP, release, dry ? outDir : undefined);
+            web = await publishWeb(kv, cfg, APP, release, dry ? outDir : undefined, io);
         }
         else if (!skipWeb) {
             try {
@@ -219,10 +235,10 @@ export async function publish(argv) {
         for (const band of bands) {
             const body = JSON.stringify({ schema_version: "1.0", app_id: APP, shell_major: MAJOR, band, ...(pf === "ios" ? { platform: "ios" } : {}), release, issued_at,
                 core: { version: `1.0.${release}`, sha256: newSha, size: bytes.length, url: `b/${APP}/${name}`, patches },
-                addons: [], screens: [], min_shell_version: MIN_SHELL, ...(hermesVersion ? { hermes_bytecode_version: hermesVersion } : {}), ...(nativeModules ? { required_native_modules: nativeModules } : {}), ...(web ? { web } : {}) });
+                addons: [], screens: [], min_shell_version: MIN_SHELL, ...(hermesVersion ? { hermes_bytecode_version: hermesVersion } : {}), ...(hermesVersion && hermesEngine ? { hermes_engine: hermesEngine } : {}), ...(nativeModules ? { required_native_modules: nativeModules } : {}), ...(web ? { web } : {}) });
             await kv.put(pointerKey(APP, MAJOR, band, pf), JSON.stringify({ body, signature: signBytes(new TextEncoder().encode(body), SEED) }), "application/json");
         }
-        await kv.put(pf === "ios" ? `h/${APP}/ios-r${release}` : `h/${APP}/r${release}`, JSON.stringify({ release, issued_at, sha256: newSha, size: bytes.length, min_shell_version: MIN_SHELL, ...(hermesVersion ? { hermes_bytecode_version: hermesVersion } : {}), ...(nativeModules ? { required_native_modules: nativeModules } : {}), web }), "application/json");
+        await kv.put(pf === "ios" ? `h/${APP}/ios-r${release}` : `h/${APP}/r${release}`, JSON.stringify({ release, issued_at, sha256: newSha, size: bytes.length, min_shell_version: MIN_SHELL, ...(hermesVersion ? { hermes_bytecode_version: hermesVersion } : {}), ...(hermesVersion && hermesEngine ? { hermes_engine: hermesEngine } : {}), ...(nativeModules ? { required_native_modules: nativeModules } : {}), web }), "application/json");
         totalBytes += bytes.length;
         summary[pf] = { bytes: bytes.length, patches: patches.map((p) => ({ from: p.from_sha256.slice(0, 12), kb: +(p.size / 1024).toFixed(1) })) };
         if (web)
@@ -236,14 +252,41 @@ export async function publish(argv) {
     if (dry)
         console.log(dryRunSummary(release, totalBytes, outDir, patchInfo));
     else
-        console.log(JSON.stringify(summary));
+        console.log(publishedSummary(release, bands));
+    const flags = [a.bands ? `--bands ${a.bands}` : "", a.platform ? `--platform ${a.platform}` : ""].filter(Boolean).join(" ");
+    const data = { ...summary, platforms, total_bytes: totalBytes };
+    if (dry)
+        return { code: "dry_run", summary: `Dry run complete: release ${release}, ${formatSize(totalBytes)}. Nothing was sent.`, data, next: [{ command: `shipvo publish ${flags} --json`.replace(/ +/g, " "), why: "Publish for real." }] };
+    const rest = ["b0", "b1", "b2"].filter((b) => !bands.includes(b));
+    const next = [{ command: "shipvo status --json", why: "See how the release does on phones." }];
+    if (rest.length)
+        next.push({ command: `shipvo promote --to ${rest.join(",")} --json`, why: `Widen release ${release} to ${rest.join(", ")} when it looks healthy.` });
+    return { code: "published", summary: `Published release ${release} to ${bands.join(", ")} (${platforms.join(", ")}).`, data, next };
+}
+function refused(verdict, json) {
+    const msg = `Refused by policy rule ${verdict.rule}: ${verdict.reason}`;
+    if (json)
+        throw new CliFailure(msg, "policy_refused", 1, [{ command: "shipvo publish --dry-run-policy --json", why: "Check the policy for other --bands." }]);
+    console.error(msg);
+    process.exitCode = 1;
+    return { code: "policy_refused", summary: msg, data: {}, next: [] };
+}
+/** The publish result in plain words. `--json` carries the full detail. */
+export function publishedSummary(release, bands) {
+    const rest = ["b0", "b1", "b2"].filter((b) => !bands.includes(b));
+    const next = rest.length ? `Next: shipvo status, then shipvo promote --to ${rest.join(",")}.` : "Next: shipvo status.";
+    return `Published release ${release} to ${bands.join(", ")}. ${next}`;
+}
+/** The rollback result in plain words. */
+export function rolledBackSummary(to, release) {
+    return `Rolled back to the code of release ${to} as new release ${release}. Next: shipvo status.`;
 }
 /** Bytes in plain units: KB below 1 MB, so a small bundle never reads as 0.00 MB. */
 export function formatSize(bytes) {
     return bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(2)} MB`;
 }
 /** The dry-run result in plain words. `info` says what happened with patches on Android. */
-export function dryRunSummary(release, bytes, outDir, info = { bases: 0, bsdiff: false, patches: 0 }) {
+export function dryRunSummary(release, bytes, outDir, info = { bases: 0, patches: 0 }) {
     const lines = [
         `Dry run complete. Nothing was sent.`,
         `  Release:  ${release}`,
@@ -254,14 +297,32 @@ export function dryRunSummary(release, bytes, outDir, info = { bases: 0, bsdiff:
         lines.push(`Patches are not built in a dry run, because older releases are not read. Publish for real to build them.`);
     else if (info.bases === 0)
         lines.push(`Full bundles are fine for a first release. Small patches matter once you have older releases to compare against.`);
-    else if (!info.bsdiff)
-        lines.push(`Patches were skipped because bsdiff4 is not installed (pip install bsdiff4). Full bundles still work.`);
+    else if (info.patches === 0)
+        lines.push(`No small patch was built, so this update is a full bundle. Full bundles still work.`);
     else
         lines.push(`Patches built: ${info.patches}.`);
     return lines.join("\n");
 }
-async function publishWeb(kv, cfg, APP, release, outDir) {
-    execSync("PN_SIM=1 npx expo export --platform web --output-dir dist-web --clear", { stdio: "inherit" });
+/** The line for a listing file that is not there. It says the file is optional and what to do. */
+export function missingListingNote(file, name) {
+    if (name === "icon")
+        return `No app icon yet (optional). Add ${file} to show one in the store.`;
+    if (name.startsWith("shot-"))
+        return `No screenshot yet (optional). Add ${file} to show it in the store.`;
+    return `No ${name} yet (optional). Add ${file} to show it in the store.`;
+}
+/** Upload one listing file to the store prefix. A missing file prints a note and returns null. */
+export async function uploadListingFile(kv, store, file, name) {
+    if (!existsSync(file)) {
+        console.error(missingListingNote(file, name));
+        return null;
+    }
+    const ext = file.slice(file.lastIndexOf(".")).toLowerCase();
+    await kv.put(`${store}/${name}${ext}`, new Uint8Array(readFileSync(file)), MIME[ext] ?? "application/octet-stream");
+    return `${name}${ext}`;
+}
+async function publishWeb(kv, cfg, APP, release, outDir, io = "inherit") {
+    execSync("npx expo export --platform web --output-dir dist-web --clear", { stdio: io, env: { ...process.env, PN_SIM: "1" } });
     const base = `w/${APP}/r${release}`;
     const files = [];
     let indexSha = "";
@@ -293,10 +354,7 @@ async function publishWeb(kv, cfg, APP, release, outDir) {
     // Store listing assets (icon, screenshots) and the release note, read by shipvo.dev/apps and list_apps.
     const L = cfg.listing ?? {};
     const store = `w/${APP}/store`;
-    const up = async (file, name) => { if (!existsSync(file)) {
-        console.error(`listing: ${file} not found, skipped`);
-        return null;
-    } const ext = file.slice(file.lastIndexOf(".")).toLowerCase(); await kv.put(`${store}/${name}${ext}`, new Uint8Array(readFileSync(file)), MIME[ext] ?? "application/octet-stream"); return `${name}${ext}`; };
+    const up = (file, name) => uploadListingFile(kv, store, file, name);
     const icon = L.icon ? await up(L.icon, "icon") : null;
     const shots = [];
     for (const [i, f] of (L.screenshots ?? []).entries()) {
@@ -314,11 +372,23 @@ async function publishWeb(kv, cfg, APP, release, outDir) {
     return web;
 }
 export async function rollback(argv) {
-    checkFlags(argv, ["to", "bands", "platform", "dry-run"]);
-    const a = parse(argv), dry = a["dry-run"] !== undefined, cfg = loadConfig(), SEED = seed(), kv = kvFor(cfg);
+    if (argv.includes("--json"))
+        return runJson(() => rollbackRun(argv, true), [...DOCTOR, { command: "shipvo status --json", why: "See the newest releases." }]);
+    await rollbackRun(argv, false);
+}
+async function rollbackRun(argv, json) {
+    checkFlags(argv, ["to", "bands", "platform", "dry-run", "json"]);
+    const a = parse(argv), dry = a["dry-run"] !== undefined, cfg = loadConfig();
+    const offline = dry && !hasStore();
+    const SEED = dry ? "" : seed(), kv = offline ? offlineKv() : kvFor(cfg);
+    if (offline)
+        console.error("Offline rehearsal: reading releases from .shipvo/dry-run (written by shipvo publish --dry-run). No login used, nothing is sent.");
     const APP = cfg.appId, MAJOR = cfg.shellMajor, to = Number(a.to);
     if (!to) {
-        console.error("Usage: shipvo rollback --to <release> [--bands b0,b1,b2] [--platform android|ios|all] [--dry-run]");
+        const usage = "Usage: shipvo rollback --to <release> [--bands b0,b1,b2] [--platform android|ios|all] [--dry-run] [--json]";
+        if (json)
+            throw new UsageError(usage);
+        console.error(usage);
         process.exit(2);
     }
     const release = (await currentRelease(kv, APP, MAJOR)) + 1, issued_at = new Date().toISOString();
@@ -327,6 +397,8 @@ export async function rollback(argv) {
     for (const pf of platforms) {
         const bytes = await kv.getBytes(`b/${APP}/${bundleName(to, pf)}`);
         if (!bytes) {
+            if (json)
+                throw new CliFailure(`Release ${to} ${pf} bundle not found`, "not_found", 1, [{ command: "shipvo status --json", why: "See which releases exist." }]);
             console.error(`Release ${to} ${pf} bundle not found`);
             process.exit(1);
         }
@@ -344,9 +416,12 @@ export async function rollback(argv) {
                 await kv.put(pointerKey(APP, MAJOR, band, pf), JSON.stringify({ body, signature: signBytes(new TextEncoder().encode(body), SEED) }), "application/json");
         }
     }
+    const data = { app: APP, rolled_back_to_code_of: to, new_release: release, min_shell_version: minShell, issued_at, platforms, bands, dry_run: dry };
     if (dry) {
         console.log([`Rollback preview for ${APP}:`, `  Rolling back to the code of release ${to}`, `  New release number: ${release}`, `  Platforms: ${platforms.join(", ")}`, `  Bands: ${bands.join(", ")}`, `  Min shell version: ${minShell}`, `Dry run: nothing was written.`].join("\n"));
-        return;
+        const real = argv.filter((x) => x !== "--dry-run").join(" ");
+        return { code: "dry_run", summary: `Rollback preview: release ${to} code becomes release ${release}. Nothing was written.`, data, next: [{ command: `shipvo rollback ${real}`, why: "Do the rollback." }] };
     }
-    console.log(JSON.stringify({ app: APP, rolled_back_to_code_of: to, new_release: release, min_shell_version: minShell, issued_at }));
+    console.log(rolledBackSummary(to, release));
+    return { code: "rolled_back", summary: `Rolled back to the code of release ${to} as release ${release}.`, data, next: [{ command: "shipvo status --json", why: "Check that phones pick up the rollback." }] };
 }

package/dist/qr.d.ts

@@ -0,0 +1,9 @@
+export declare const QR_MAX_BYTES = 134;
+/** Reed-Solomon error codewords for `data`. */
+export declare function rsRemainder(data: number[], degree: number): number[];
+/** The 15 format bits for level L and a mask number. */
+export declare function formatBits(mask: number): number;
+/** Encodes text as a QR code. Returns rows of modules, true for dark. Throws when the text is over 134 bytes. */
+export declare function qrMatrix(text: string): boolean[][];
+/** Draws the matrix for a terminal: black on white with ANSI colours, two rows per line, a 2 module quiet zone. */
+export declare function qrToTerminal(matrix: boolean[][], quiet?: number): string;

package/dist/qr.js

@@ -0,0 +1,213 @@
+// A small QR code encoder: byte mode, error correction level L, versions 1 to 6 (up to 134 bytes). No dependencies.
+// Enough for a LAN URL. `qrMatrix` returns the modules; `qrToTerminal` draws them with half-block characters.
+const SIZES = [
+    [19, 7, 1], [34, 10, 1], [55, 15, 1], [80, 20, 1], [108, 26, 1], [136, 18, 2],
+];
+const ALIGN = [[], [6, 18], [6, 22], [6, 26], [6, 30], [6, 34]];
+export const QR_MAX_BYTES = 134;
+const EXP = new Uint8Array(512);
+const LOG = new Uint8Array(256);
+for (let i = 0, x = 1; i < 255; i++) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 256)
+        x ^= 0x11d;
+}
+for (let i = 255; i < 512; i++)
+    EXP[i] = EXP[i - 255];
+const mul = (a, b) => (a && b ? EXP[LOG[a] + LOG[b]] : 0);
+/** Reed-Solomon error codewords for `data`. */
+export function rsRemainder(data, degree) {
+    let gen = [1];
+    for (let i = 0; i < degree; i++) {
+        const next = new Array(gen.length + 1).fill(0);
+        gen.forEach((c, j) => { next[j] ^= c; next[j + 1] ^= mul(c, EXP[i]); });
+        gen = next;
+    }
+    const rem = new Array(degree).fill(0);
+    for (const b of data) {
+        const f = b ^ rem.shift();
+        rem.push(0);
+        for (let i = 0; i < degree; i++)
+            rem[i] ^= mul(gen[i + 1], f);
+    }
+    return rem;
+}
+function codewordsFor(bytes, version) {
+    const [total, ecc, blocks] = SIZES[version - 1];
+    const bits = [];
+    const put = (v, n) => { for (let i = n - 1; i >= 0; i--)
+        bits.push((v >>> i) & 1); };
+    put(4, 4);
+    put(bytes.length, 8);
+    for (const b of bytes)
+        put(b, 8);
+    put(0, Math.min(4, total * 8 - bits.length));
+    while (bits.length % 8)
+        bits.push(0);
+    const data = [];
+    for (let i = 0; i < bits.length; i += 8)
+        data.push(parseInt(bits.slice(i, i + 8).join(""), 2));
+    for (let pad = 0xec; data.length < total; pad ^= 0xec ^ 0x11)
+        data.push(pad);
+    const per = total / blocks;
+    const dataBlocks = Array.from({ length: blocks }, (_, i) => data.slice(i * per, (i + 1) * per));
+    const eccBlocks = dataBlocks.map((b) => rsRemainder(b, ecc));
+    const out = [];
+    for (let i = 0; i < per; i++)
+        for (const b of dataBlocks)
+            out.push(b[i]);
+    for (let i = 0; i < ecc; i++)
+        for (const b of eccBlocks)
+            out.push(b[i]);
+    return out;
+}
+const MASKS = [
+    (x, y) => (x + y) % 2 === 0, (_x, y) => y % 2 === 0, (x) => x % 3 === 0, (x, y) => (x + y) % 3 === 0,
+    (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0, (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+    (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0, (x, y) => ((((x + y) % 2) + ((x * y) % 3)) % 2) === 0,
+];
+/** The 15 format bits for level L and a mask number. */
+export function formatBits(mask) {
+    const data = (1 << 3) | mask; // level L is 01
+    let rem = data;
+    for (let i = 0; i < 10; i++)
+        rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+    return ((data << 10) | rem) ^ 0x5412;
+}
+function penalty(m) {
+    const n = m.length;
+    let score = 0;
+    let dark = 0;
+    const line = (get) => {
+        let run = 1;
+        for (let i = 1; i <= n; i++) {
+            if (i < n && get(i) === get(i - 1))
+                run++;
+            else {
+                if (run >= 5)
+                    score += run - 2;
+                run = 1;
+            }
+        }
+        const s = Array.from({ length: n }, (_, i) => (get(i) ? 1 : 0)).join("");
+        for (const p of ["10111010000", "00001011101"])
+            for (let i = s.indexOf(p); i >= 0; i = s.indexOf(p, i + 1))
+                score += 40;
+    };
+    for (let a = 0; a < n; a++) {
+        line((i) => m[a][i]);
+        line((i) => m[i][a]);
+    }
+    for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+            if (m[y][x])
+                dark++;
+            if (x + 1 < n && y + 1 < n && m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1])
+                score += 3;
+        }
+    return score + (Math.ceil(Math.abs(dark * 20 - n * n * 10) / (n * n)) - 1) * 10;
+}
+/** Encodes text as a QR code. Returns rows of modules, true for dark. Throws when the text is over 134 bytes. */
+export function qrMatrix(text) {
+    const bytes = new TextEncoder().encode(text);
+    const version = SIZES.findIndex(([total]) => bytes.length <= total - 2) + 1;
+    if (!version)
+        throw new Error(`QR code input is ${bytes.length} bytes; the limit is ${QR_MAX_BYTES}.`);
+    const size = 17 + 4 * version;
+    const codewords = codewordsFor(bytes, version);
+    const base = Array.from({ length: size }, () => new Array(size).fill(false));
+    const fn = Array.from({ length: size }, () => new Array(size).fill(false));
+    const set = (x, y, dark) => { if (x >= 0 && y >= 0 && x < size && y < size) {
+        base[y][x] = dark;
+        fn[y][x] = true;
+    } };
+    for (const [cx, cy] of [[3, 3], [size - 4, 3], [3, size - 4]]) {
+        for (let dy = -4; dy <= 4; dy++)
+            for (let dx = -4; dx <= 4; dx++) {
+                const d = Math.max(Math.abs(dx), Math.abs(dy));
+                set(cx + dx, cy + dy, d !== 4 && d !== 2);
+            }
+    }
+    for (let i = 8; i < size - 8; i++) {
+        set(i, 6, i % 2 === 0);
+        set(6, i, i % 2 === 0);
+    }
+    const pos = ALIGN[version - 1];
+    for (const cy of pos)
+        for (const cx of pos) {
+            if ((cx === 6 && cy === 6) || (cx === 6 && cy === size - 7) || (cx === size - 7 && cy === 6))
+                continue;
+            for (let dy = -2; dy <= 2; dy++)
+                for (let dx = -2; dx <= 2; dx++)
+                    set(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+        }
+    const format = (mask) => {
+        const f = formatBits(mask);
+        const bit = (i) => ((f >>> i) & 1) === 1;
+        for (let i = 0; i <= 5; i++)
+            set(8, i, bit(i));
+        set(8, 7, bit(6));
+        set(8, 8, bit(7));
+        set(7, 8, bit(8));
+        for (let i = 9; i < 15; i++)
+            set(14 - i, 8, bit(i));
+        for (let i = 0; i < 8; i++)
+            set(size - 1 - i, 8, bit(i));
+        for (let i = 8; i < 15; i++)
+            set(8, size - 15 + i, bit(i));
+        set(8, size - 8, true);
+    };
+    format(0); // reserves the areas; redone below with the chosen mask
+    let k = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        for (let v = 0; v < size; v++)
+            for (let j = 0; j < 2; j++) {
+                const x = right - j;
+                const y = ((right + 1) & 2) === 0 ? size - 1 - v : v;
+                if (!fn[y][x] && k < codewords.length * 8) {
+                    base[y][x] = ((codewords[k >> 3] >>> (7 - (k & 7))) & 1) === 1;
+                    k++;
+                }
+            }
+    }
+    let best;
+    let bestScore = Infinity;
+    for (let mask = 0; mask < 8; mask++) {
+        const m = base.map((row) => row.slice());
+        for (let y = 0; y < size; y++)
+            for (let x = 0; x < size; x++)
+                if (!fn[y][x] && MASKS[mask](x, y))
+                    m[y][x] = !m[y][x];
+        const saveBase = base.map((r) => r.slice());
+        for (let y = 0; y < size; y++)
+            base[y] = m[y];
+        format(mask);
+        const s = penalty(base);
+        if (s < bestScore) {
+            bestScore = s;
+            best = base.map((r) => r.slice());
+        }
+        for (let y = 0; y < size; y++)
+            base[y] = saveBase[y];
+    }
+    return best;
+}
+/** Draws the matrix for a terminal: black on white with ANSI colours, two rows per line, a 2 module quiet zone. */
+export function qrToTerminal(matrix, quiet = 2) {
+    const n = matrix.length + quiet * 2;
+    const at = (x, y) => matrix[y - quiet]?.[x - quiet] === true;
+    const lines = [];
+    for (let y = 0; y < n; y += 2) {
+        let s = "\x1b[30;47m";
+        for (let x = 0; x < n; x++) {
+            const t = at(x, y), b = y + 1 < n && at(x, y + 1);
+            s += t && b ? "█" : t ? "▀" : b ? "▄" : " ";
+        }
+        lines.push(s + "\x1b[0m");
+    }
+    return lines.join("\n");
+}

package/dist/report-md.d.ts

@@ -0,0 +1,27 @@
+type Step = {
+    kind?: string;
+    target?: string;
+    text?: string;
+    enter?: boolean;
+    line?: number;
+};
+type Flow = {
+    name?: string;
+    status?: string;
+    steps?: Step[];
+    failedStep?: Step | null;
+    message?: string | null;
+    screenshots?: string[];
+    screenshot?: string | null;
+};
+export type TestReport = {
+    app?: string | null;
+    commit?: string | null;
+    release?: string | null;
+    time?: string | null;
+    parityLimits?: string[];
+    flows?: Flow[];
+};
+export declare function stepText(s: Step): string;
+export declare function renderReportMarkdown(report: TestReport): string;
+export {};