@shipvo/cli 0.1.3 → 0.1.5

package/dist/run.js

@@ -0,0 +1,301 @@
+// `shipvo run android|ios`: build the web export with the simulated device, serve it on a local port and
+// open a phone frame page in the default browser. No browser automation. `--native` runs `npx expo run:<platform>`.
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { join, extname, normalize, resolve, sep } from "node:path";
+import { loadConfig } from "./config.js";
+import { AGENT_PATH, hostAllowed, isAgentRole, isLoopback, originAllowed, tokenMatches } from "./run-protocol.js";
+import { bridgeScript } from "./run-bridge.js";
+import { acceptWebSocket } from "./run-ws.js";
+import { portFree, rebuildInto } from "./sim.js";
+/** Parses `run` arguments. Throws a plain message for anything it does not know. */
+export function parseRunArgs(argv) {
+    let platform;
+    let open = true;
+    let port;
+    let native = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "android" || a === "ios")
+            platform = a;
+        else if (a === "--no-open")
+            open = false;
+        else if (a === "--native")
+            native = true;
+        else if (a === "--port") {
+            const v = argv[++i];
+            if (!v || !/^\d+$/.test(v) || Number(v) > 65535)
+                throw new Error(`--port needs a number from 0 to 65535, got "${v ?? ""}".`);
+            port = Number(v);
+        }
+        else
+            throw new Error(`Unknown argument "${a}". Usage: shipvo run android|ios [--no-open] [--port <n>] [--native]`);
+    }
+    if (!platform)
+        throw new Error("Say which phone: shipvo run android or shipvo run ios.");
+    return { platform, open, port, native };
+}
+/** The command `--native` runs. */
+export const nativeCommand = (p) => ({ cmd: "npx", args: ["expo", `run:${p}`] });
+export const FRAMES = {
+    android: { width: 412, height: 915, radius: 36, label: "Android", sheet: { title: "Allow access?", allow: "While using the app", deny: "Don't allow" } },
+    ios: { width: 393, height: 852, radius: 55, label: "iOS", sheet: { title: "Would Like to Access", allow: "Allow While Using App", deny: "Don't Allow" } },
+};
+/** Loads the frame renderer from @shipvo/sim: the app's install first, then the one next to this CLI. */
+export async function loadFrameRenderer(bases = [process.cwd() + "/package.json", import.meta.url]) {
+    let file;
+    for (const base of bases) {
+        try {
+            file = createRequire(base).resolve("@shipvo/sim/frame.mjs");
+            break;
+        }
+        catch { }
+    }
+    if (!file)
+        throw new Error("@shipvo/sim is not installed in this app. Run `npm i -D @shipvo/sim` (or use your package manager).");
+    const mod = await import(pathToFileURL(file).href);
+    const render = (o) => mod.renderFrame(o);
+    if (typeof mod.statusClientScript === "function")
+        render.statusScript = mod.statusClientScript;
+    return render;
+}
+/** The page that shows the app in an Android or iOS frame at its real logical size, scaled to fit the window. The phone body comes from @shipvo/sim's renderFrame. */
+export function runFramePage(platform, name, render, dark = false, token) {
+    const f = FRAMES[platform];
+    const title = name.replace(/[<>&"']/g, "");
+    const sheet = `<div class="sheet" id="sheet" role="dialog" aria-label="${f.label} system sheet" data-part="system-sheet"><div class="box"><p>${f.sheet.title}</p><button type="button" data-act="allow">${f.sheet.allow}</button><button type="button" data-act="deny">${f.sheet.deny}</button></div></div>`;
+    const frame = render({ skin: platform, dark, screen: `<iframe id="app" src="/app/" title="${title}"></iframe>${sheet}` });
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title} on ${f.label} (simulated)</title>
+<style>
+html,body{margin:0;height:100%;overflow:hidden;background:${dark ? "#15171a" : "#e8eaed"};font:14px system-ui,sans-serif}
+#fit{position:absolute;left:50%;top:50%;transform-origin:center;touch-action:manipulation}
+${frame.css}
+.sheet{position:absolute;inset:0;background:#0007;display:none;align-items:${platform === "ios" ? "center" : "flex-end"};justify-content:center;z-index:5}
+.sheet.open{display:flex}
+.sheet .box{background:#fff;color:#111;width:${platform === "ios" ? "270px" : "100%"};box-sizing:border-box;padding:20px;border-radius:${platform === "ios" ? "14px" : "28px 28px 0 0"};text-align:center}
+.sheet button{display:block;width:100%;margin-top:8px;padding:10px;border:0;border-radius:${platform === "ios" ? "8px" : "20px"};background:#eee;font:inherit;cursor:pointer}
+.sheetbtn{position:fixed;right:12px;top:10px;padding:3px 10px;border-radius:12px;border:0;background:#111;color:#fff;font-size:12px;cursor:pointer}
+.tag{position:fixed;left:12px;top:10px;padding:3px 10px;border-radius:12px;background:#111;color:#fff;font-size:12px}
+</style></head><body>
+<div class="tag" role="status">Simulated ${f.label} (${f.width}x${f.height}). The app's web build on the simulated device.</div>
+<button class="sheetbtn" id="sheetbtn" type="button">Show ${f.label} system sheet</button>
+<div id="fit"><div id="phone" data-platform="${platform}">${frame.html}</div></div>
+<script>
+var sh=document.getElementById("sheet");
+function sheet(on){sh.classList.toggle("open",on)}
+document.getElementById("sheetbtn").onclick=function(){sheet(!sh.classList.contains("open"))};
+sh.onclick=function(e){if(e.target===sh||e.target.getAttribute("data-act"))sheet(false)};
+addEventListener("message",function(e){var d=e.data;if(d&&d.type==="shipvo:system-sheet")sheet(d.open!==false)});
+function fit(){var s=Math.min(1,(innerWidth-24)/${frame.outerWidth},(innerHeight-60)/${frame.outerHeight});var e=document.getElementById("fit");e.style.transform="translate(-50%,-50%) scale("+s+")";e.style.width="${frame.outerWidth}px";e.style.height="${frame.outerHeight}px"}
+addEventListener("resize",fit);fit();
+</script>${render.statusScript ? `<script>${render.statusScript("app", platform).replace(/<\/script/gi, "<\\/script")}</script>` : ""}${token ? `<script src="/__shipvo/bridge.js" data-token="${token}"></script>` : ""}</body></html>`;
+}
+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", ".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",
+};
+/** Adds `.shipvo/` to `<dir>/.gitignore` when it is not already ignored. */
+export function ensureShipvoIgnored(dir) {
+    const path = join(dir, ".gitignore");
+    const text = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (/^\/?\.shipvo\/?\s*$/m.test(text))
+        return;
+    appendFileSync(path, (text && !text.endsWith("\n") ? "\n" : "") + ".shipvo/\n");
+}
+/**
+ * Serves the frame page at `/` and the web export at `/app/` (and its absolute asset paths at `/`).
+ * Port 0 picks a free port. Resolves once listening.
+ * The agent channel is a WebSocket at `/__shipvo/agent?role=screen|driver&token=...`, loopback only. It relays JSON
+ * messages between the `screen` and the `driver`. With `projectDir`, `.shipvo/run.json` describes the session while it runs.
+ */
+export async function startRunServer(opts) {
+    const root = resolve(opts.dir);
+    const token = randomBytes(24).toString("hex");
+    // The page gets its own credential: random, in memory only, never written to run.json, and valid for `screen` only.
+    const pageToken = randomBytes(24).toString("hex");
+    const render = opts.render ?? await loadFrameRenderer();
+    const pages = { light: runFramePage(opts.platform, opts.name, render, false, pageToken), dark: runFramePage(opts.platform, opts.name, render, true, pageToken) };
+    const bridge = bridgeScript();
+    let boundPort = -1; // set once the server listens; Host and Origin must match it
+    const server = createServer((req, res) => {
+        if (!hostAllowed(req.headers.host, boundPort)) {
+            res.writeHead(403);
+            return void res.end("Forbidden");
+        }
+        let path;
+        try {
+            path = decodeURIComponent((req.url ?? "/").split("?")[0]);
+        }
+        catch {
+            res.writeHead(400);
+            return void res.end("Bad request");
+        }
+        if (path === "/app") {
+            res.writeHead(302, { location: "/app/" });
+            return void res.end();
+        }
+        if (path === "/" || path === "/index.html") {
+            const dark = new URL(req.url ?? "/", "http://x").searchParams.get("dark") === "1";
+            res.writeHead(200, { "content-type": TYPES[".html"] });
+            return void res.end(dark ? pages.dark : pages.light);
+        }
+        if (path === "/__shipvo/bridge.js") {
+            res.writeHead(200, { "content-type": TYPES[".js"], "cache-control": "no-store" });
+            return void res.end(bridge);
+        }
+        let rel = path.startsWith("/app/") ? path.slice(4) : path;
+        if (rel.endsWith("/"))
+            rel += "index.html";
+        const file = normalize(join(root, rel));
+        if (file !== root && !file.startsWith(root + sep)) {
+            res.writeHead(403);
+            return void res.end("Forbidden");
+        }
+        let target = file;
+        if (!existsSync(target) || !statSync(target).isFile()) {
+            // A client-side route inside the frame (for example a reload on /app/settings): serve the app shell.
+            const spa = path.startsWith("/app/") && !extname(path) ? join(root, "index.html") : "";
+            if (!spa || !existsSync(spa)) {
+                res.writeHead(404);
+                return void res.end("Not found");
+            }
+            target = spa;
+        }
+        res.writeHead(200, { "content-type": TYPES[extname(target).toLowerCase()] ?? "application/octet-stream" });
+        res.end(readFileSync(target));
+    });
+    const peers = {};
+    server.on("upgrade", (req, socket) => {
+        const refuse = (line) => socket.end(`HTTP/1.1 ${line}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+        const url = new URL(req.url ?? "/", "http://localhost");
+        if (url.pathname !== AGENT_PATH)
+            return refuse("404 Not Found");
+        if (!isLoopback(req.socket.remoteAddress))
+            return refuse("403 Forbidden");
+        if (!hostAllowed(req.headers.host, boundPort) || !originAllowed(req.headers.origin, boundPort))
+            return refuse("403 Forbidden");
+        const given = url.searchParams.get("token");
+        const role = url.searchParams.get("role");
+        const ok = tokenMatches(given, token) || (role === "screen" && tokenMatches(given, pageToken));
+        if (!ok)
+            return refuse("401 Unauthorized");
+        if (!isAgentRole(role))
+            return refuse("400 Bad Request");
+        const other = role === "screen" ? "driver" : "screen";
+        const peer = acceptWebSocket(req, socket, (text) => {
+            try {
+                JSON.parse(text);
+            }
+            catch {
+                return;
+            }
+            peers[other]?.send(text);
+        }, () => { if (peers[role] === peer)
+            delete peers[role]; });
+        if (!peer)
+            return;
+        const old = peers[role]; // a reloaded tab or a restarted agent replaces the old connection
+        peers[role] = peer;
+        old?.close();
+    });
+    const infoPath = opts.projectDir ? join(resolve(opts.projectDir), ".shipvo", "run.json") : undefined;
+    const cleanup = () => { if (infoPath)
+        rmSync(infoPath, { force: true }); };
+    return new Promise((ok, fail) => {
+        server.once("error", fail);
+        server.listen(opts.port ?? 0, "127.0.0.1", () => {
+            const port = server.address().port;
+            boundPort = port;
+            if (infoPath) {
+                const info = { port, platform: opts.platform, app: opts.name, token, pid: process.pid };
+                mkdirSync(join(infoPath, ".."), { recursive: true });
+                writeFileSync(infoPath, JSON.stringify(info, null, 2) + "\n", { mode: 0o600 });
+            }
+            ok({ server, port, token, close: () => new Promise((r) => { cleanup(); for (const p of Object.values(peers))
+                    p?.close(); server.close(() => r()); server.closeAllConnections?.(); }) });
+        });
+    });
+}
+/** Names the module or file a web build failed on, from the build's error output. */
+export function describeWebBuildFailure(output) {
+    const m = /Unable to resolve module ['"]?([^'"\s]+)['"]?(?: from ['"]?([^'":\s]+))?/.exec(output)
+        ?? /Module not found: (?:Error: )?Can't resolve '([^']+)'(?: in '([^']+)')?/.exec(output)
+        ?? /Cannot find module ['"]([^'"]+)['"]/.exec(output);
+    if (m)
+        return `The app cannot build for web: ${m[1]} fails to resolve${m[2] ? ` (from ${m[2]})` : ""}. Fix or stub that module for web, or use \`shipvo run <platform> --native\`.`;
+    const f = /(?:SyntaxError|Error)[^\n]*\n?[^\n]*?(\S+\.(?:tsx?|jsx?|json))/.exec(output) ?? /(\S+\.(?:tsx?|jsx?|json))/.exec(output);
+    const last = output.trim().split("\n").slice(-1)[0] ?? "";
+    return `The app cannot build for web${f ? ` (in ${f[1]})` : ""}: ${last || "see the build output above"}. Use \`shipvo run <platform> --native\` to run it natively.`;
+}
+/** Builds the web export with `rebuildInto` from sim.ts (the same build as `shipvo sim`) into `<root>/sim-dist`. */
+export async function buildWeb(root, command) {
+    try {
+        await rebuildInto({ root, command, echo: true });
+    }
+    catch (e) {
+        throw new Error(describeWebBuildFailure(e.output ?? e.message));
+    }
+}
+function openBrowser(url) {
+    const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+    const p = spawn(cmd, args, { stdio: "ignore", detached: true });
+    p.on("error", () => console.error(`Could not open a browser. Open ${url} yourself.`));
+    p.unref();
+}
+/** Returns the exit code. */
+export async function run(argv) {
+    let o;
+    try {
+        o = parseRunArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    if (o.native) {
+        const { cmd, args } = nativeCommand(o.platform);
+        console.error(`Running natively: ${cmd} ${args.join(" ")} (not the simulated device)`);
+        return spawnSync(cmd, args, { stdio: "inherit" }).status ?? 1;
+    }
+    let name;
+    try {
+        name = loadConfig().name;
+    }
+    catch (e) {
+        console.error(e.message);
+        return 1;
+    }
+    if (o.port !== undefined && o.port !== 0 && !(await portFree(o.port))) {
+        console.error(`Port ${o.port} is in use. Pass another --port <n>.`);
+        return 1;
+    }
+    const out = join(process.cwd(), "sim-dist");
+    console.error(`Building ${name} for web with the simulated device…`);
+    try {
+        await buildWeb(process.cwd());
+    }
+    catch (e) {
+        console.error(e.message);
+        return 1;
+    }
+    try {
+        ensureShipvoIgnored(process.cwd());
+    }
+    catch { /* read-only project: the session still works */ }
+    const s = await startRunServer({ dir: out, platform: o.platform, name, port: o.port, projectDir: process.cwd() });
+    const url = `http://127.0.0.1:${s.port}/`;
+    console.error(`Simulated ${FRAMES[o.platform].label} phone at ${url}  (Ctrl+C to stop)`);
+    if (o.open)
+        openBrowser(url);
+    await new Promise((done) => { for (const sig of ["SIGINT", "SIGTERM"])
+        process.once(sig, done); });
+    await s.close();
+    return 0;
+}

package/dist/sim.d.ts

@@ -1 +1,32 @@
+/** True if nothing is listening on the port (checks by binding, then closing). */
+export declare function portFree(port: number): Promise<boolean>;
+/** Resolves true once something accepts connections on the port, false if `stop` says to give up. */
+export declare function waitListening(port: number, stop: () => boolean): Promise<boolean>;
+/** True if a path (relative to the project) is inside a folder that never triggers a rebuild. */
+export declare const ignoredPath: (rel: string) => boolean;
+/** Turns a build error into a short plain message. Unknown errors keep their first line only. */
+export declare function friendlyBuildError(message: string, verbose?: boolean): string;
+/**
+ * Calls `build` once after changes settle for `debounceMs`. A change during a build queues one more build.
+ * `build` rejects with the build error; it is printed and the caller keeps serving the last good build.
+ * Returns a function that stops watching.
+ */
+export declare function watchAndRebuild(opts: {
+    dir: string;
+    build: () => Promise<void>;
+    debounceMs?: number;
+    log?: (line: string) => void;
+    verbose?: boolean;
+}): () => void;
+/**
+ * Builds into `<root>/.shipvo/sim-next` and swaps it into `<root>/sim-dist` only if the build succeeds.
+ * The old build is moved aside first and moved back if the swap fails.
+ * `command` is the shell command; it gets the output dir as its last argument.
+ * A failed build rejects with an Error whose `output` property holds the last 4000 characters of stdout and stderr.
+ */
+export declare function rebuildInto(opts?: {
+    root?: string;
+    command?: string;
+    echo?: boolean;
+}): Promise<void>;
 export declare function sim(argv: string[]): Promise<void>;

package/dist/sim.js

@@ -1,11 +1,13 @@
 // `shipvo sim`: build the app's web bundle with the simulated device and serve it in the simulator.
 import { execSync, spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, renameSync, rmSync, watch } from "node:fs";
+import { join } from "node:path";
 import { createRequire } from "node:module";
 import { createServer, connect } from "node:net";
+import { ensurePlaywright } from "./ensure-playwright.js";
 import { args as parse, loadConfig } from "./config.js";
 /** True if nothing is listening on the port (checks by binding, then closing). */
-function portFree(port) {
+export function portFree(port) {
     return new Promise((resolve) => {
         const s = createServer();
         s.once("error", () => resolve(false));
@@ -13,7 +15,7 @@ function portFree(port) {
     });
 }
 /** Resolves true once something accepts connections on the port, false if `stop` says to give up. */
-function waitListening(port, stop) {
+export function waitListening(port, stop) {
     return new Promise((resolve) => {
         const tryOnce = () => {
             if (stop())
@@ -25,6 +27,112 @@ function waitListening(port, stop) {
         tryOnce();
     });
 }
+const IGNORED = new Set(["node_modules", "sim-dist", ".shipvo", ".git", ".expo", "dist", "dist-ota", "web-build", "ios", "android"]);
+/** True if a path (relative to the project) is inside a folder that never triggers a rebuild. */
+export const ignoredPath = (rel) => rel.split(/[\\/]/).some((seg) => IGNORED.has(seg));
+/** Turns a build error into a short plain message. Unknown errors keep their first line only. */
+export function friendlyBuildError(message, verbose = false) {
+    if (verbose)
+        return `build failed, still serving the last good build: ${message}`;
+    const m = /in file (\S+\.json) at (\d+):(\d+)/.exec(message);
+    if (m && /Unexpected token|SyntaxError/.test(message)) {
+        const comma = /expected punc [«"']?,/.test(message) || /Unexpected token string/.test(message);
+        const what = comma ? "check for a missing or extra comma" : "a character is missing, extra or in the wrong place";
+        return `Your file ${m[1]} has a mistake at line ${m[2]}, column ${m[3]}: ${what}. The page still shows your last good version.`;
+    }
+    return `build failed, still serving the last good build: ${message.split("\n")[0]} (run with --verbose for details)`;
+}
+/**
+ * Calls `build` once after changes settle for `debounceMs`. A change during a build queues one more build.
+ * `build` rejects with the build error; it is printed and the caller keeps serving the last good build.
+ * Returns a function that stops watching.
+ */
+export function watchAndRebuild(opts) {
+    const { dir, build, debounceMs = 300, log = (l) => console.error(l), verbose = false } = opts;
+    let timer;
+    let running = false;
+    let again = false;
+    let closed = false;
+    const run = async () => {
+        if (running) {
+            again = true;
+            return;
+        }
+        running = true;
+        const t0 = Date.now();
+        try {
+            await build();
+            log(`rebuilt in ${((Date.now() - t0) / 1000).toFixed(1)} s`);
+        }
+        catch (e) {
+            log(friendlyBuildError(e.message, verbose));
+        }
+        running = false;
+        if (again && !closed) {
+            again = false;
+            void run();
+        }
+    };
+    const w = watch(dir, { recursive: true }, (_ev, file) => {
+        if (closed || (file && ignoredPath(String(file))))
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(() => void run(), debounceMs);
+    });
+    const stop = () => { closed = true; clearTimeout(timer); w.close(); };
+    w.on("error", (e) => { log(`file watcher failed, no longer watching: ${e.message}`); stop(); });
+    return stop;
+}
+/**
+ * Builds into `<root>/.shipvo/sim-next` and swaps it into `<root>/sim-dist` only if the build succeeds.
+ * The old build is moved aside first and moved back if the swap fails.
+ * `command` is the shell command; it gets the output dir as its last argument.
+ * A failed build rejects with an Error whose `output` property holds the last 4000 characters of stdout and stderr.
+ */
+export function rebuildInto(opts = {}) {
+    const root = opts.root ?? process.cwd();
+    const command = opts.command ?? "npx expo export --platform web --clear --output-dir";
+    const next = join(root, ".shipvo", "sim-next"), live = join(root, "sim-dist"), prev = join(root, ".shipvo", "sim-prev");
+    return new Promise((resolve, reject) => {
+        mkdirSync(join(root, ".shipvo"), { recursive: true });
+        rmSync(next, { recursive: true, force: true });
+        const p = spawn(`${command} "${next}"`, { cwd: root, shell: true, env: { ...process.env, PN_SIM: "1" }, stdio: ["ignore", "pipe", "pipe"] });
+        let tail = "";
+        // Metro and Expo print resolve errors to either stream, so keep both. `echo` also shows them.
+        for (const [stream, out] of [[p.stdout, process.stdout], [p.stderr, process.stderr]]) {
+            stream.on("data", (d) => { if (opts.echo)
+                out.write(d); tail = (tail + d).slice(-4000); });
+        }
+        p.on("error", (e) => { rmSync(next, { recursive: true, force: true }); reject(e); });
+        p.on("close", (code) => {
+            if (code !== 0) {
+                rmSync(next, { recursive: true, force: true });
+                const err = new Error(tail.trim().split("\n").slice(-5).join("\n") || `build exited with code ${code}`);
+                return reject(Object.assign(err, { output: tail }));
+            }
+            let moved = false;
+            try {
+                rmSync(prev, { recursive: true, force: true });
+                if (existsSync(live)) {
+                    renameSync(live, prev);
+                    moved = true;
+                }
+                renameSync(next, live);
+            }
+            catch (e) {
+                try {
+                    if (moved && !existsSync(live))
+                        renameSync(prev, live);
+                }
+                catch { /* keep the original error */ }
+                rmSync(next, { recursive: true, force: true });
+                return reject(e);
+            }
+            rmSync(prev, { recursive: true, force: true });
+            resolve();
+        });
+    });
+}
 export async function sim(argv) {
     const a = parse(argv);
     const cfg = loadConfig();
@@ -37,18 +145,29 @@ export async function sim(argv) {
         console.error(`Building ${cfg.name} for the simulator…`);
         execSync("PN_SIM=1 npx expo export --platform web --output-dir sim-dist --clear", { stdio: "inherit", env: { ...process.env, PN_SIM: "1" } });
     }
+    try {
+        ensurePlaywright({ cwd: process.cwd() });
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(2);
+    }
     let server;
     try {
         server = createRequire(process.cwd() + "/package.json").resolve("@shipvo/sim/server.mjs");
     }
     catch {
-        console.error("Install @shipvo/sim (and playwright) in this app: npm i -D @shipvo/sim playwright && npx playwright install chromium");
+        console.error("@shipvo/sim is not installed in this app. Run `npm i -D @shipvo/sim` (or use your package manager).");
         process.exit(2);
     }
     const p = spawn(process.execPath, [server, "--port", port, "--app", cfg.appId, ...(a.dir ? ["--dir", a.dir] : [])], { stdio: "inherit", env: { ...process.env, PN_CONTROL: cfg.controlPlane } });
     let exited = false;
     p.on("exit", (c) => { exited = true; process.exit(c ?? 0); });
     if (await waitListening(Number(port), () => exited)) {
-        console.error(`Simulator on http://localhost:${port}  (open_app("${cfg.appId}") from @shipvo/mcp; Ctrl-C to stop)`);
+        console.error(`Simulator on http://localhost:${port}/app/  (open_app("${cfg.appId}") from @shipvo/mcp; Ctrl-C to stop)`);
+        if (a.watch === "true") {
+            watchAndRebuild({ dir: process.cwd(), build: () => rebuildInto(), verbose: a.verbose === "true" });
+            console.error("Watching for changes (ignoring node_modules, sim-dist, .shipvo, .expo, dist, dist-ota, web-build, ios, android)");
+        }
     }
 }

package/dist/status.d.ts

@@ -0,0 +1,64 @@
+type Row = {
+    release: number;
+    events: Record<string, number>;
+    apply_ms_median: number | null;
+    cold_start_ms_median: number | null;
+};
+type AutoHalt = {
+    threshold: number;
+    min_reports: number;
+} | null;
+type Halted = {
+    release: number;
+    reports: number;
+    failed: number;
+    threshold: number;
+};
+/** Plain-text table: one row per release, one column per event name, then the two medians. */
+export declare function formatStatus(releases: Row[]): 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 StatusJson = {
+    ok: boolean;
+    code: "ok" | "no_project" | "no_signing_key" | "release_halted" | "no_release" | "error";
+    summary: string;
+    data: {
+        project: {
+            kind: string;
+            app_id: string | null;
+        };
+        sim: {
+            running: boolean;
+            port: number;
+        };
+        run_server: {
+            running: boolean;
+            port: number | null;
+        };
+        signing_key: {
+            present: boolean;
+        };
+        pending_release: {
+            newest: number | null;
+            halted: Halted | null;
+            auto_halt: AutoHalt | null;
+        } | null;
+        store_step: {
+            id: string;
+            title: string;
+            state: string;
+        } | null;
+    };
+    next: Next[];
+};
+/** `shipvo status --json`: exit 0 ok, 1 action needed, 2 error. */
+export declare function statusJson(appArg: string | undefined, fetchFn: typeof fetch, dir?: string): Promise<{
+    doc: StatusJson;
+    exit: number;
+}>;
+export declare function status(argv: string[], fetchFn?: typeof fetch): Promise<number>;
+export {};