@shipvo/cli 0.1.3 → 0.1.4

package/dist/preview.d.ts

@@ -0,0 +1,35 @@
+export type PreviewFile = {
+    path: string;
+    bytes: Uint8Array;
+    contentType: string;
+};
+export type PreviewResult = {
+    url: string;
+    claimUrl: string | null;
+    expiresAt: string | null;
+    files: number;
+    warnings: string[];
+};
+export type PreviewOpts = {
+    fetch?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    maxRetries?: number;
+};
+export declare const blockedPath: (rel: string) => boolean;
+/** Throws if any file would leak a secret. Names the file and the kind, never the value. */
+export declare function refuseSecrets(files: PreviewFile[], secrets?: string[]): void;
+/** Reads a build folder into upload entries, skipping files that must never be uploaded. */
+export declare function collectFiles(dir: string): PreviewFile[];
+/** The page people open: the app in an Android or iPhone frame, with skin, size and theme switches and a back control. */
+export declare function framePage(name: string): string;
+/** Puts the frame page at index.html and the app's own entry at app.html (its asset paths are absolute, so it stays at the site root). */
+export declare function wrapBuild(buildDir: string, name: string): PreviewFile[];
+/** Publishes to here.now anonymously: create, upload, finalize. Refreshes expired upload URLs and waits out 429s. */
+export declare function publishToHereNow(files: PreviewFile[], o?: PreviewOpts): Promise<PreviewResult>;
+export declare const NOTICE = "This link is public: anyone who has it can open the preview. It expires in 24 hours unless you open the claim link and sign in to here.now, which keeps it.";
+/** Builds, wraps and publishes. Used by the CLI and by the MCP `publish_preview` tool (through `shipvo preview --json`). */
+export declare function runPreview(root: string, o?: PreviewOpts & {
+    skipBuild?: boolean;
+    buildDir?: string;
+}): Promise<PreviewResult>;
+export declare function preview(argv: string[]): Promise<void>;

package/dist/preview.js

@@ -0,0 +1,249 @@
+// `shipvo preview`: build the web artifact with the simulated device, wrap it in a phone-sized frame page
+// and publish it to here.now with no account. The link is public and lasts 24 hours unless claimed.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join, relative, sep, extname } from "node:path";
+import { args as parse, loadConfig } from "./config.js";
+const API = "https://here.now/api/v1";
+const CLIENT = "shipvo/cli";
+const TYPES = {
+    ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".json": "application/json",
+    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".svg": "image/svg+xml", ".webp": "image/webp",
+    ".ico": "image/x-icon", ".ttf": "font/ttf", ".otf": "font/otf", ".woff": "font/woff", ".woff2": "font/woff2", ".txt": "text/plain; charset=utf-8", ".wasm": "application/wasm",
+};
+const typeOf = (p) => TYPES[extname(p).toLowerCase()] ?? "application/octet-stream";
+// Files that never leave the machine, wherever they sit in the tree.
+const BLOCKED_SEGMENTS = new Set([".shipvo", ".git", "node_modules", ".herenow"]);
+const BLOCKED_NAME = /^(\.env.*|.*\.map|.*\.(pem|key|p8|p12|jks|keystore|mobileprovision)|seed\.txt|publish-token|id_rsa|id_ed25519)$/i;
+export const blockedPath = (rel) => {
+    const segs = rel.split(/[\\/]/);
+    return segs.some((s) => BLOCKED_SEGMENTS.has(s)) || BLOCKED_NAME.test(segs[segs.length - 1]);
+};
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----/, "a private key"],
+    [/SHIPVO_SIGNING_SEED\s*["']?\s*[:=]/, "SHIPVO_SIGNING_SEED"],
+    [/SHIPVO_PUBLISH_TOKEN\s*["']?\s*[:=]/, "SHIPVO_PUBLISH_TOKEN"],
+    [/CLOUDFLARE_API_TOKEN\s*["']?\s*[:=]/, "CLOUDFLARE_API_TOKEN"],
+    [/\bgh[pousr]_[A-Za-z0-9]{30,}/, "a GitHub token"],
+    [/\bAKIA[0-9A-Z]{16}\b/, "an AWS access key"],
+    [/\bsk-[A-Za-z0-9_-]{32,}/, "an API key"],
+];
+const TEXT = /\.(html|js|mjs|css|json|txt|svg)$/i;
+/** Secret values this process knows: they must not appear in anything we upload. */
+function knownSecrets() {
+    const e = process.env;
+    const out = [e.SHIPVO_SIGNING_SEED, e.PURENATIVE_SIGNING_SEED, e.SHIPVO_PUBLISH_TOKEN, e.CLOUDFLARE_API_TOKEN];
+    for (const f of [join(process.cwd(), ".shipvo", "seed.txt"), join(process.cwd(), ".shipvo", "publish-token")]) {
+        try {
+            out.push(readFileSync(f, "utf8").trim());
+        }
+        catch { }
+    }
+    return out.filter((s) => !!s && s.length >= 16);
+}
+/** Throws if any file would leak a secret. Names the file and the kind, never the value. */
+export function refuseSecrets(files, secrets = knownSecrets()) {
+    for (const f of files) {
+        if (!TEXT.test(f.path))
+            continue;
+        const text = Buffer.from(f.bytes).toString("utf8");
+        for (const s of secrets)
+            if (text.includes(s))
+                throw new Error(`Refusing to publish: ${f.path} contains a secret value from your environment or .shipvo/. Remove it from the app's web build and run again.`);
+        for (const [re, what] of SECRET_PATTERNS)
+            if (re.test(text))
+                throw new Error(`Refusing to publish: ${f.path} references ${what}. Keep secrets out of the web build and run again.`);
+    }
+}
+/** Reads a build folder into upload entries, skipping files that must never be uploaded. */
+export function collectFiles(dir) {
+    const out = [];
+    const walk = (d) => {
+        for (const name of readdirSync(d)) {
+            const full = join(d, name), rel = relative(dir, full).split(sep).join("/");
+            if (blockedPath(rel))
+                continue;
+            if (statSync(full).isDirectory())
+                walk(full);
+            else
+                out.push({ path: rel, bytes: new Uint8Array(readFileSync(full)), contentType: typeOf(rel) });
+        }
+    };
+    walk(dir);
+    return out;
+}
+/** The page people open: the app in an Android or iPhone frame, with skin, size and theme switches and a back control. */
+export function framePage(name) {
+    const title = name.replace(/[<>&"']/g, "");
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
+<title>${title} preview</title>
+<style>
+:root{color-scheme:light}body.dark{color-scheme:dark}
+html,body{margin:0;height:100%;font:14px system-ui,sans-serif;background:#e8eaed;color:#111}
+body.dark{background:#15171a;color:#eee}
+.bar{display:flex;gap:8px;justify-content:center;align-items:center;padding:10px;flex-wrap:wrap}
+.bar button,.back{font:inherit;padding:6px 12px;border:1px solid #888;border-radius:8px;background:transparent;color:inherit;cursor:pointer}
+.bar button[aria-pressed=true]{background:#2563eb;border-color:#2563eb;color:#fff}
+.stage{display:flex;justify-content:center;padding:0 10px 20px}
+.device{display:flex;flex-direction:column;background:#000;color:#fff;border-radius:28px;box-shadow:0 8px 30px #0005;overflow:hidden;width:360px;max-width:100%;box-sizing:border-box;padding:0 6px}
+.device[data-skin=iphone]{border-radius:44px;padding:0 10px}
+.status{display:flex;justify-content:space-between;align-items:center;height:28px;padding:0 14px;font-size:12px;flex:none}
+.device[data-skin=iphone] .status{height:44px;padding:0 24px}
+.device[data-skin=android] .status .notch{display:none}
+.device[data-skin=iphone] .status .icons{letter-spacing:2px}
+.notch{width:90px;height:24px;background:#000;border-radius:14px;position:absolute}
+.device[data-skin=iphone] .status{position:relative}
+.device[data-skin=iphone] .status .notch{left:50%;margin-left:-45px;top:8px;background:#111}
+iframe{border:0;background:#fff;width:100%;flex:1;min-height:0;display:block}
+.nav{flex:none;display:flex;justify-content:center;align-items:center;height:44px}
+.device[data-skin=iphone] .nav{height:44px}
+.back{color:#fff;border-color:#888;padding:4px 14px}
+.device[data-skin=iphone] .back{display:block;position:relative;width:134px;height:44px;padding:0;border:0;background:transparent;font-size:0}
+.device[data-skin=iphone] .back::after{content:"";position:absolute;left:0;right:0;top:50%;height:5px;margin-top:-2px;border-radius:3px;background:#fff}
+.back:focus-visible{outline:2px solid #fff;outline-offset:2px}
+.device[data-skin=android] .back{border:0}
+.note{text-align:center;opacity:.7;padding:0 12px 16px}
+@media (max-width:500px){.bar,.note{display:none}.stage{padding:0}.device{padding:0!important;width:100vw!important;height:100vh!important;height:100dvh!important;border-radius:0!important;box-shadow:none}}
+</style></head><body>
+<div class="bar" role="toolbar" aria-label="Preview options">
+<button data-skin="android" aria-pressed="true">Android</button><button data-skin="iphone" aria-pressed="false">iPhone</button>
+<button data-size="phone" aria-pressed="true">Phone</button><button data-size="large" aria-pressed="false">Large phone</button><button data-size="tablet" aria-pressed="false">Tablet</button>
+<button id="theme" aria-pressed="false">Dark</button></div>
+<div class="stage"><div class="device" id="device" data-skin="android" style="width:360px;height:760px">
+<div class="status" id="status"><span id="clock">9:41</span><span class="notch"></span><span class="icons" id="icons">&#9679;&#9679; 5G 100%</span></div>
+<iframe id="app" src="app.html" title="${title}"></iframe>
+<div class="nav"><button class="back" id="back" aria-label="Back" title="Back">&#9664; Back</button></div>
+</div></div>
+<p class="note">${title}: simulated device, public preview. System sheets such as permissions and payments are simulated.</p>
+<script>
+var SIZES={phone:[360,760],large:[412,892],tablet:[820,1180]},IPHONE={phone:[390,844],large:[430,932],tablet:[820,1180]};
+var skin="android",size="phone",d=document.getElementById("device"),f=document.getElementById("app"),bk=document.getElementById("back");
+function pressed(sel,val,key){document.querySelectorAll(sel).forEach(function(o){o.setAttribute("aria-pressed",o.dataset[key]===val)})}
+function apply(){var s=(skin==="iphone"?IPHONE:SIZES)[size];d.dataset.skin=skin;d.style.width=s[0]+"px";d.style.height=s[1]+"px";bk.innerHTML=skin==="iphone"?"Back":"&#9664; Back";bk.setAttribute("aria-label","Back");document.getElementById("icons").innerHTML=skin==="iphone"?"5G &#9646; 100%":"&#9679;&#9679; 5G 100%";pressed("[data-skin]",skin,"skin");pressed("[data-size]",size,"size")}
+document.querySelectorAll("[data-skin]").forEach(function(b){b.onclick=function(){skin=b.dataset.skin;apply()}});
+document.querySelectorAll("[data-size]").forEach(function(b){b.onclick=function(){size=b.dataset.size;apply()}});
+// Back does what the simulator's back action does: press the screen's Back button, else go back in history.
+function goBack(){var w=f.contentWindow;try{var doc=w&&w.document;if(!doc)return;var els=doc.querySelectorAll("button,[role=button],a");for(var i=0;i<els.length;i++){var e=els[i],t=(e.getAttribute("aria-label")||e.textContent||"").trim();if(t==="Back"){e.click();return}}w.history.back()}catch(x){}}
+bk.onclick=goBack;
+var t=document.getElementById("theme");t.onclick=function(){var k=!document.body.classList.contains("dark");document.body.classList.toggle("dark",k);t.setAttribute("aria-pressed",k);t.textContent=k?"Light":"Dark";f.style.colorScheme=k?"dark":"light"};
+apply();
+</script></body></html>
+`;
+}
+/** Puts the frame page at index.html and the app's own entry at app.html (its asset paths are absolute, so it stays at the site root). */
+export function wrapBuild(buildDir, name) {
+    const files = collectFiles(buildDir).filter((f) => f.path !== "index.html");
+    const entry = join(buildDir, "index.html");
+    if (!existsSync(entry))
+        throw new Error("The web build has no index.html. Run `npx expo export --platform web` and check it works.");
+    files.push({ path: "app.html", bytes: new Uint8Array(readFileSync(entry)), contentType: typeOf("x.html") });
+    files.push({ path: "index.html", bytes: new TextEncoder().encode(framePage(name)), contentType: typeOf("x.html") });
+    return files;
+}
+const realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Publishes to here.now anonymously: create, upload, finalize. Refreshes expired upload URLs and waits out 429s. */
+export async function publishToHereNow(files, o = {}) {
+    const f = o.fetch ?? fetch, sleep = o.sleep ?? realSleep, max = o.maxRetries ?? 3;
+    refuseSecrets(files);
+    const blocked = files.find((x) => blockedPath(x.path));
+    if (blocked)
+        throw new Error(`Refusing to upload ${blocked.path}.`);
+    const headers = { "content-type": "application/json", "X-HereNow-Client": CLIENT };
+    /** One JSON call; on 429 waits retry_after seconds (or Retry-After) and tries again, up to `max` times. */
+    const call = async (url, body, what) => {
+        for (let attempt = 0;; attempt++) {
+            const r = await f(url, { method: "POST", headers, body: JSON.stringify(body) });
+            if (r.status === 429 && attempt < max) {
+                let j = {};
+                try {
+                    j = await r.json();
+                }
+                catch { }
+                const secs = Number(j.retry_after ?? r.headers.get("retry-after") ?? 5);
+                await sleep((Number.isFinite(secs) && secs > 0 ? Math.min(secs, 120) : 5) * 1000);
+                continue;
+            }
+            let j = {};
+            try {
+                j = await r.json();
+            }
+            catch { }
+            if (!r.ok)
+                throw new Error(r.status === 429 ? `here.now is rate limiting this publish (${what}). Wait ${j.retry_after ?? "a few"} seconds and run again.` : `here.now ${what} failed (${r.status}): ${j.message ?? j.error ?? "no details"}`);
+            return j;
+        }
+    };
+    const created = await call(`${API}/publish`, { files: files.map((x) => ({ path: x.path, size: x.bytes.length, contentType: x.contentType })) }, "create");
+    const slug = created.slug;
+    let targets = created.upload.uploads;
+    const byPath = new Map(files.map((x) => [x.path, x]));
+    const putAll = async (list) => {
+        const expired = [];
+        for (const t of list) {
+            const file = byPath.get(t.path);
+            if (!file)
+                continue;
+            const r = await f(t.url, { method: "PUT", headers: { "content-type": file.contentType, ...(t.headers ?? {}) }, body: file.bytes });
+            if (r.status === 403 || r.status === 401 || r.status === 400)
+                expired.push(t);
+            else if (!r.ok)
+                throw new Error(`Upload of ${t.path} failed (${r.status}).`);
+        }
+        return expired;
+    };
+    let pending = await putAll(targets);
+    for (let i = 0; pending.length && i < 2; i++) {
+        const fresh = await call(`${API}/publish/${slug}/uploads/refresh`, { claimToken: created.claimToken }, "refresh upload URLs");
+        const want = new Set(pending.map((p) => p.path));
+        targets = fresh.upload.uploads.filter((t) => want.has(t.path));
+        pending = await putAll(targets);
+    }
+    if (pending.length)
+        throw new Error(`Could not upload ${pending.length} file(s), e.g. ${pending[0].path}. Check that *.r2.cloudflarestorage.com is reachable, then run again.`);
+    const done = await call(`${API}/publish/${slug}/finalize`, { versionId: created.upload.versionId }, "finalize");
+    const warnings = (done.warnings ?? []).map((w) => (typeof w === "string" ? w : JSON.stringify(w)));
+    return { url: done.siteUrl ?? created.siteUrl, claimUrl: created.claimUrl ?? null, expiresAt: created.expiresAt ?? null, files: files.length, warnings };
+}
+function build(root, out) {
+    rmSync(out, { recursive: true, force: true });
+    mkdirSync(join(root, ".shipvo"), { recursive: true });
+    return new Promise((resolve, reject) => {
+        const p = spawn("npx", ["expo", "export", "--platform", "web", "--clear", "--output-dir", out], { cwd: root, env: { ...process.env, PN_SIM: "1" }, stdio: ["ignore", "ignore", "inherit"] });
+        p.on("error", reject);
+        p.on("exit", (c) => (c === 0 ? resolve() : reject(new Error(`The web build failed (exit ${c}). Run \`npx expo export --platform web\` to see why.`))));
+    });
+}
+export const NOTICE = "This link is public: anyone who has it can open the preview. It expires in 24 hours unless you open the claim link and sign in to here.now, which keeps it.";
+/** Builds, wraps and publishes. Used by the CLI and by the MCP `publish_preview` tool (through `shipvo preview --json`). */
+export async function runPreview(root, o = {}) {
+    const cfg = loadConfig(root);
+    const provider = cfg.preview ?? "here.now";
+    if (provider === "control-plane")
+        throw new Error('shipvo.json sets "preview": "control-plane". That provider is not built yet. Remove the setting or use "here.now".');
+    if (provider !== "here.now")
+        throw new Error(`shipvo.json: "preview" must be "here.now" or "control-plane", not "${provider}".`);
+    const dir = o.buildDir ?? join(root, ".shipvo", "preview-build");
+    if (!o.skipBuild)
+        await build(root, dir);
+    return publishToHereNow(wrapBuild(dir, cfg.name), o);
+}
+export async function preview(argv) {
+    const a = parse(argv);
+    const json = a.json === "true";
+    if (!json)
+        console.error("Building the web app with the simulated device…");
+    const r = await runPreview(process.cwd(), { skipBuild: a["skip-build"] === "true" });
+    if (json) {
+        console.log(JSON.stringify({ url: r.url, claimUrl: r.claimUrl, expiresAt: r.expiresAt, files: r.files, warnings: r.warnings, public: true, notice: NOTICE }));
+        return;
+    }
+    console.log(`Preview: ${r.url}`);
+    if (r.claimUrl)
+        console.log(`Keep it (claim link): ${r.claimUrl}`);
+    if (r.expiresAt)
+        console.log(`Expires: ${r.expiresAt}`);
+    console.log(NOTICE);
+    for (const w of r.warnings)
+        console.log(`Warning from here.now: ${w}`);
+}

package/dist/promote.d.ts

@@ -0,0 +1,9 @@
+import { kv as kvFor } from "./config.js";
+type Store = Pick<ReturnType<typeof kvFor>, "get" | "put">;
+export declare const PROMOTE_FLAGS: string[];
+export declare const PROMOTE_HELP = "Usage: shipvo promote [flags]\n\nWiden a staged release to more bands. The release number, bundle and patches stay the same; the pointer is signed again.\n\nFlags (write a value after a space, not =):\n  --to b1,b2                   Bands to write (default: every band with no pointer for this release)\n                               Bands that already hold a newer release are always skipped\n  --platform android|ios|all   Platform to promote (default android)\n  --dry-run                    Print the plan, write nothing\n  --force                      Promote even if the release is halted or has reverts\n  --help                       Show this help\n";
+export declare function promote(argv: string[], deps?: {
+    kv?: Store;
+    fetchFn?: typeof fetch;
+}): Promise<void>;
+export {};

package/dist/promote.js

@@ -0,0 +1,126 @@
+// `shipvo promote`: widen a staged release to more bands. Reads the pointer on the narrowest band that has one,
+// and writes the same release (same bundle, hashes and patches) to the other bands with a fresh issued_at and signature.
+import { signBytes } from "./index.js";
+import { args as parse, kv as kvFor, loadConfig, seed } from "./config.js";
+const BANDS = ["b0", "b1", "b2"];
+const REVERT_EVENTS = ["rolled_back", "crash_loop_revert"];
+const pointerKey = (app, major, band, pf) => (pf === "ios" ? `p/${app}/${major}/ios/${band}` : `p/${app}/${major}/${band}`);
+export const PROMOTE_FLAGS = ["to", "platform", "dry-run", "force"];
+export const PROMOTE_HELP = `Usage: shipvo promote [flags]
+
+Widen a staged release to more bands. The release number, bundle and patches stay the same; the pointer is signed again.
+
+Flags (write a value after a space, not =):
+  --to b1,b2                   Bands to write (default: every band with no pointer for this release)
+                               Bands that already hold a newer release are always skipped
+  --platform android|ios|all   Platform to promote (default android)
+  --dry-run                    Print the plan, write nothing
+  --force                      Promote even if the release is halted or has reverts
+  --help                       Show this help
+`;
+function checkFlags(argv, known) {
+    const bad = argv.filter((x) => x.startsWith("--") && !known.includes(x.slice(2)));
+    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(" ")}`);
+    }
+}
+export async function promote(argv, deps = {}) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(PROMOTE_HELP);
+        return;
+    }
+    checkFlags(argv, PROMOTE_FLAGS);
+    const a = parse(argv), cfg = loadConfig();
+    const dry = a["dry-run"] !== undefined, force = a.force !== undefined;
+    const p = (a.platform || "android").toLowerCase();
+    if (p !== "android" && p !== "ios" && p !== "all")
+        throw new Error(`--platform must be android, ios or all (got "${a.platform}")`);
+    const platforms = p === "all" ? ["android", "ios"] : [p];
+    if (a.to === "true")
+        throw new Error("--to needs bands: pass --to b1,b2");
+    const explicit = a.to ? a.to.split(",").map((s) => s.trim()).filter(Boolean) : null;
+    if (explicit) {
+        const bad = explicit.filter((b) => !BANDS.includes(b));
+        if (bad.length)
+            throw new Error(`Unknown band ${bad.join(", ")}. Bands are ${BANDS.join(", ")}.`);
+    }
+    const APP = cfg.appId, MAJOR = cfg.shellMajor;
+    const store = deps.kv ?? kvFor(cfg);
+    // Read every source pointer before touching the network or writing anything.
+    const plans = [];
+    for (const pf of platforms) {
+        let from = "", body = null;
+        const have = new Map();
+        for (const band of BANDS) {
+            const raw = await store.get(pointerKey(APP, MAJOR, band, pf));
+            if (!raw)
+                continue;
+            try {
+                const b = JSON.parse(JSON.parse(raw).body);
+                have.set(band, b.release);
+                if (!body) {
+                    from = band;
+                    body = b;
+                }
+            }
+            catch { /* unreadable pointer: skip */ }
+        }
+        if (!body)
+            throw new Error(`No ${pf} pointer found on any band. Run shipvo publish --bands b0 first.`);
+        const release = body.release;
+        if (explicit && explicit.length && explicit.every((b) => b === from))
+            throw new Error(`${from} is the source band (release ${release}). Pass --to with a different band.`);
+        // Never write an older release over a newer one: promote widens, it does not downgrade. --force does not change this.
+        const cand = (explicit ?? BANDS).filter((b) => b !== from && (explicit || have.get(b) !== release));
+        const newer = cand.filter((b) => (have.get(b) ?? 0) > release).map((b) => [b, have.get(b)]);
+        const targets = cand.filter((b) => !((have.get(b) ?? 0) > release));
+        plans.push({ pf, release, from, body, targets, newer });
+    }
+    if (!force) {
+        const base = cfg.controlPlane.replace(/\/$/, "");
+        let data;
+        try {
+            const r = await (deps.fetchFn ?? fetch)(`${base}/t/${encodeURIComponent(APP)}/summary`);
+            if (!r.ok)
+                throw new Error(`HTTP ${r.status}`);
+            data = (await r.json());
+        }
+        catch (e) {
+            throw new Error(`Could not read the release status from ${base} (${e instanceof Error ? e.message : String(e)}). Try again, or pass --force to promote without the check.`);
+        }
+        for (const { release } of plans) {
+            if (data.halted && typeof data.halted === "object" && data.halted.release === release)
+                throw new Error(`Release ${release} is halted. Publish a new release or run shipvo rollback, or pass --force to promote it anyway.`);
+            const ev = data.releases?.find((r) => r.release === release)?.events ?? {};
+            const n = REVERT_EVENTS.reduce((s, k) => s + (ev[k] ?? 0), 0);
+            if (n > 0)
+                throw new Error(`Release ${release} has ${n} reported revert${n === 1 ? "" : "s"}. Check shipvo status, publish a fix, or pass --force to promote it anyway.`);
+        }
+    }
+    for (const { pf, release, from, body, targets, newer } of plans) {
+        for (const [b, r] of newer)
+            console.log(`Skipped ${b} (${pf}): it already has release ${r}, which is newer than ${release}.`);
+        if (!targets.length && newer.length) {
+            console.log(`Nothing to promote: every other band already has a newer release than ${release} (${pf}).`);
+            continue;
+        }
+        if (!targets.length) {
+            console.log(`Nothing to promote: release ${release} (${pf}) already has a pointer on every band.`);
+            continue;
+        }
+        const issued_at = new Date().toISOString();
+        for (const band of targets) {
+            if (dry) {
+                console.log(`Would write ${band} (${pf}): release ${release}, copied from ${from}`);
+                continue;
+            }
+            const text = JSON.stringify({ ...body, band, issued_at });
+            await store.put(pointerKey(APP, MAJOR, band, pf), JSON.stringify({ body: text, signature: signBytes(new TextEncoder().encode(text), seed()) }), "application/json");
+            console.log(`Wrote ${band} (${pf}): release ${release}, copied from ${from}`);
+        }
+    }
+    if (dry)
+        console.log("Dry run: nothing was written.");
+}

package/dist/publish.d.ts

@@ -1,4 +1,4 @@
-export declare const PUBLISH_HELP = "Usage: shipvo publish [flags]\n\nBuild, sign and publish an over-the-air release.\n\nFlags (write a value after a space, not =):\n  --bands b0,b1,b2             Cohorts to publish to (default b0,b1,b2)\n  --platform android|ios|all   Platform to publish (default android)\n  --release N                  Release number (default: the next one)\n  --min-shell X.Y.Z            Oldest app shell that can run this release (default: version in app.json)\n  --hermes-bytecode-version V  Refuse bundles built for another Hermes version, for example 96 or 96,98\n  --max-bases N                How many older releases to build patches from (default 6)\n  --skip-export true           Reuse the last build in dist-ota/\n  --skip-web true              Do not publish the web copy for the simulator\n  --dry-run                    Build and sign, write files locally, send nothing\n  --out <dir>                  Where --dry-run writes files (default .shipvo/dry-run)\n  --help                       Show this help\n";
+export declare const PUBLISH_HELP = "Usage: shipvo publish [flags]\n\nBuild, sign and publish an over-the-air release.\n\nFlags (write a value after a space, not =; on/off flags can be bare, or true/false):\n  --bands b0,b1,b2             Cohorts to publish to (default b0,b1,b2)\n  --platform android|ios|all   Platform to publish (default android)\n  --release N                  Release number (default: the next one)\n  --min-shell X.Y.Z            Oldest app shell that can run this release (default: version in app.json)\n  --hermes-bytecode-version V  Refuse bundles built for another Hermes version, for example 96 or 96,98\n  --max-bases N                How many older releases to build patches from (default 6)\n  --skip-export               Reuse the last build in dist-ota/\n  --skip-web                  Do not publish the web copy for the simulator\n  --dry-run                    Build and sign, write files locally, send nothing\n  --out <dir>                  Where --dry-run writes files (default .shipvo/dry-run)\n  --help                       Show this help\n";
 export declare function publish(argv: string[]): Promise<void>;
 /** Bytes in plain units: KB below 1 MB, so a small bundle never reads as 0.00 MB. */
 export declare function formatSize(bytes: number): string;