@axonpack/preview 0.0.0-stage → 0.1.0

package/build/cli.cjs

@@ -0,0 +1,1465 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = require("node:path");
+var import_node_util2 = require("node:util");
+
+// src/utils/previews/layout.util.ts
+var SCHEMA = 1;
+var PLATFORMS = ["android", "ios"];
+var DEFAULT_COMPATIBILITY = "appVersion";
+var isCompatibility = (value) => value === "appVersion" || value === "fingerprint";
+var compatibilityKey = (compatibility, value) => `${compatibility === "appVersion" ? "version" : "fingerprint"}-${value.replace(/[^A-Za-z0-9._-]/g, "_")}`;
+var BUNDLE_FILE = {
+  android: "index.android.bundle",
+  ios: "main.jsbundle"
+};
+var ROOT_INDEX_KEY = "index.json";
+var fileKey = (sha256) => `files/${sha256}`;
+var platformIndexKey = (platform, key) => `index/${platform}/${key}.json`;
+var manifestKey = (platform, key, id) => `previews/${platform}/${key}/${id}.json`;
+
+// src/services/publish/commands.service.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+
+// ../../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === undefined || value.length === length))
+    return value;
+  if (length !== undefined)
+    anumber(length, "length");
+  const bytes = isBytes(value);
+  const ofLen = length !== undefined ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new TypeError("expected hash wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+  if (h.outputLen < 1 || h.blockLen < 1)
+    throw new Error("hash blockLen / outputLen must be >= 1");
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, undefined, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0;i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new TypeError("string expected");
+  const encoded = new TextEncoder().encode(str);
+  try {
+    return new Uint8Array(encoded);
+  } finally {
+    clean(encoded);
+  }
+}
+function checkOpts(defaults, opts, title = "opts") {
+  aopts(defaults, "defaults");
+  if (opts !== undefined)
+    aopts(opts, title);
+  const merged = Object.assign(Object.create(null), defaults, opts);
+  return merged;
+}
+function createHasher(hashCons, info = {}) {
+  if (typeof hashCons !== "function")
+    throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+  info = checkOpts({}, info, "info");
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(undefined);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// ../../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/hmac.js
+class _HMAC {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  canXOF = false;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash(hash);
+    abytes(key, undefined, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("expected Hash instance");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0;i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0;i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const buf = out.subarray(0, this.outputLen);
+    this.iHash.digestInto(buf);
+    this.oHash.update(buf);
+    this.oHash.digestInto(buf);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.canXOF = canXOF;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}
+var hmac = /* @__PURE__ */ (() => {
+  const hmac_ = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+  hmac_.create = (hash, key) => new _HMAC(hash, key);
+  return hmac_;
+})();
+
+// ../../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_u64.js
+var fromNumH = (n) => n / 2 ** 32 | 0;
+var fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE) {
+  const h = fromNumH(n);
+  const l = fromNumL(n);
+  view.setUint32(byteOffset, isLE ? l : h, isLE);
+  view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+
+// ../../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+
+class HashMD {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    let processed = false;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        processed = true;
+        continue;
+      }
+      buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+        processed = true;
+      }
+    }
+    this.length += data.length;
+    if (processed)
+      this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    buffer.fill(0, pos);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      buffer.fill(0);
+    }
+    setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+    this.process(view, 0);
+    this.roundClean();
+    const oview = out === buffer ? view : createView(out);
+    const len = this.outputLen;
+    const outLen = len / 4;
+    const state = this.get();
+    if (len % 4 || outLen > state.length)
+      throw new Error("invalid outputLen");
+    for (let i = 0;i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneIntoMeta(to) {
+    const { buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (pos)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+class SHA2_32B extends HashMD {
+  A = 0;
+  B = 0;
+  C = 0;
+  D = 0;
+  E = 0;
+  F = 0;
+  G = 0;
+  H = 0;
+  constructor(outputLen, IV) {
+    super(64, outputLen, 8, false);
+    this.A = IV[0] | 0;
+    this.B = IV[1] | 0;
+    this.C = IV[2] | 0;
+    this.D = IV[3] | 0;
+    this.E = IV[4] | 0;
+    this.F = IV[5] | 0;
+    this.G = IV[6] | 0;
+    this.H = IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  _cloneInto(to) {
+    (to ||= new this.constructor).set(...this.get());
+    return this._cloneIntoMeta(to);
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16;i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0;i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+
+class _SHA256 extends SHA2_32B {
+  constructor() {
+    super(32, SHA256_IV);
+  }
+}
+var sha256 = /* @__PURE__ */ createHasher(() => new _SHA256, /* @__PURE__ */ oidNist(1));
+
+// src/utils/s3/sigv4.util.ts
+var EMPTY_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var sha256Hex = (data) => bytesToHex(sha256(typeof data === "string" ? utf8ToBytes(data) : data));
+var hmacBytes = (key, data) => hmac(sha256, typeof key === "string" ? utf8ToBytes(key) : key, utf8ToBytes(data));
+var encode = (value) => encodeURIComponent(value).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+var canonicalPath = (pathname) => pathname.split("/").map((segment) => encode(decodeURIComponent(segment))).join("/") || "/";
+var canonicalQuery = (search) => [...search.entries()].map(([key, value]) => [encode(key), encode(value)]).sort(([ak, av], [bk, bv]) => ak === bk ? av < bv ? -1 : 1 : ak < bk ? -1 : 1).map(([key, value]) => `${key}=${value}`).join("&");
+var amzDate = (date) => date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+function signRequest(input) {
+  const url = new URL(input.url);
+  const service = input.service ?? "s3";
+  const payloadHash = input.payloadHash ?? EMPTY_SHA256;
+  const timestamp = amzDate(input.date ?? new Date);
+  const day = timestamp.slice(0, 8);
+  const headers = { ...input.headers };
+  headers["x-amz-date"] = timestamp;
+  if (input.addContentSha256 ?? true)
+    headers["x-amz-content-sha256"] = payloadHash;
+  if (input.credentials.sessionToken) {
+    headers["x-amz-security-token"] = input.credentials.sessionToken;
+  }
+  const signed = new Map;
+  signed.set("host", url.host);
+  for (const [name, value] of Object.entries(headers)) {
+    signed.set(name.toLowerCase(), value.trim().replace(/\s+/g, " "));
+  }
+  const names = [...signed.keys()].sort();
+  const signedHeaders = names.join(";");
+  const canonicalRequest = [
+    input.method.toUpperCase(),
+    canonicalPath(url.pathname),
+    canonicalQuery(url.searchParams),
+    names.map((name) => `${name}:${signed.get(name)}
+`).join(""),
+    signedHeaders,
+    payloadHash
+  ].join(`
+`);
+  const scope = `${day}/${input.region}/${service}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    timestamp,
+    scope,
+    sha256Hex(canonicalRequest)
+  ].join(`
+`);
+  let key = hmacBytes(`AWS4${input.credentials.secretAccessKey}`, day);
+  key = hmacBytes(key, input.region);
+  key = hmacBytes(key, service);
+  key = hmacBytes(key, "aws4_request");
+  const signature = bytesToHex(hmacBytes(key, stringToSign));
+  headers.Authorization = `AWS4-HMAC-SHA256 Credential=${input.credentials.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return headers;
+}
+
+// src/services/s3/s3.service.ts
+var DEFAULT_REGION = "us-east-1";
+var trimSlash = (s) => s.replace(/\/+$/, "");
+var encodeKey = (key) => key.split("/").map(encodeURIComponent).join("/");
+function parseBucketUrl(value) {
+  const match = /^([a-z][a-z0-9+.-]*):\/\/([^/?#]+)([^?#]*)/i.exec(value.trim());
+  if (!match)
+    throw new Error(`${value} is not a URL: use <endpoint>/<bucket>`);
+  const [, scheme, host, path] = match;
+  const [bucket, ...rest] = path.split("/").filter(Boolean);
+  if (!bucket)
+    throw new Error(`${value} has no bucket: use <endpoint>/<bucket>`);
+  return {
+    endpoint: `${scheme.toLowerCase()}://${host}`,
+    bucket,
+    prefix: rest.length > 0 ? rest.join("/") : undefined
+  };
+}
+var withPrefix = (config, key) => config.prefix ? `${config.prefix}/${key}` : key;
+var bucketUrl = (config) => config.bucket ? `${trimSlash(config.endpoint)}/${config.bucket}` : trimSlash(config.endpoint);
+var objectUrl = (config, key) => `${bucketUrl(config)}/${encodeKey(withPrefix(config, key))}`;
+
+class S3Error extends Error {
+  status;
+  key;
+  constructor(status, key, body) {
+    super(`S3 ${status} for ${key}: ${body.slice(0, 300)}`);
+    this.status = status;
+    this.key = key;
+  }
+}
+async function s3Fetch(config, request) {
+  const base = request.key === undefined ? bucketUrl(config) : objectUrl(config, request.key);
+  const url = new URL(base);
+  for (const [k, v] of Object.entries(request.query ?? {}))
+    url.searchParams.set(k, v);
+  let headers = { ...config.headers, ...request.headers };
+  if (config.credentials) {
+    headers = signRequest({
+      method: request.method,
+      url: url.toString(),
+      region: config.region,
+      credentials: config.credentials,
+      headers,
+      payloadHash: request.body === undefined ? EMPTY_SHA256 : sha256Hex(request.body)
+    });
+  }
+  return fetch(url, {
+    method: request.method,
+    headers,
+    body: request.body
+  });
+}
+async function getJson(config, key) {
+  const res = await s3Fetch(config, { method: "GET", key });
+  if (res.status === 404 || res.status === 403 && !config.credentials)
+    return null;
+  const body = await res.text();
+  if (!res.ok)
+    throw new S3Error(res.status, key, body);
+  try {
+    return { data: JSON.parse(body), etag: res.headers.get("etag") };
+  } catch {
+    throw new Error(notJsonMessage(objectUrl(config, key), res, body));
+  }
+}
+function notJsonMessage(url, res, body) {
+  const type = res.headers.get("content-type")?.split(";")[0];
+  const got = type || JSON.stringify(body.trim().slice(0, 80));
+  const redirected = res.url && res.url !== url ? `, redirected to ${res.url}` : "";
+  return `Expected JSON from ${url} but got ${got} (status ${res.status}${redirected}). Is the URL public, or does it need a read key or headers?`;
+}
+async function putObject(config, key, body, options = {}) {
+  const headers = {
+    "content-type": options.contentType ?? "application/octet-stream"
+  };
+  if (options.etag !== undefined) {
+    if (options.etag === null)
+      headers["if-none-match"] = "*";
+    else
+      headers["if-match"] = options.etag;
+  }
+  const res = await s3Fetch(config, { method: "PUT", key, body, headers });
+  if (res.status === 412 || res.status === 409)
+    return false;
+  if (!res.ok)
+    throw new S3Error(res.status, key, await res.text());
+  return true;
+}
+async function exists(config, key) {
+  const res = await s3Fetch(config, { method: "HEAD", key });
+  if (res.status === 404)
+    return false;
+  if (!res.ok)
+    throw new S3Error(res.status, key, "");
+  return true;
+}
+async function deleteObject(config, key) {
+  const res = await s3Fetch(config, { method: "DELETE", key });
+  if (!res.ok && res.status !== 404)
+    throw new S3Error(res.status, key, await res.text());
+}
+var unescapeXml = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+async function listKeys(config, prefix) {
+  const keys = [];
+  const strip = config.prefix ? config.prefix.length + 1 : 0;
+  let token;
+  do {
+    const query = {
+      "list-type": "2",
+      prefix: withPrefix(config, prefix)
+    };
+    if (token)
+      query["continuation-token"] = token;
+    const res = await s3Fetch(config, { method: "GET", query });
+    const xml = await res.text();
+    if (!res.ok)
+      throw new S3Error(res.status, prefix, xml);
+    for (const match of xml.matchAll(/<Key>([^<]*)<\/Key>/g))
+      keys.push(unescapeXml(match[1]).slice(strip));
+    token = /<IsTruncated>true<\/IsTruncated>/.test(xml) ? unescapeXml(/<NextContinuationToken>([^<]*)</.exec(xml)?.[1] ?? "") : undefined;
+  } while (token);
+  return keys;
+}
+
+// src/utils/previews/preview-title.util.ts
+function previewTitle(branch) {
+  const words = branch.replace(/[-_/]+/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+// src/services/publish/bundle.service.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var walk = (dir) => import_node_fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? walk(import_node_path.join(dir, entry.name)) : [import_node_path.join(dir, entry.name)]);
+var HERMES_MAGIC = Buffer.from([
+  198,
+  31,
+  188,
+  3,
+  193,
+  3,
+  25,
+  31
+]);
+var hermesVersion = (bundle) => bundle.length >= 12 && bundle.subarray(0, 8).equals(HERMES_MAGIC) ? bundle.readUInt32LE(8) : null;
+function buildBundle(projectRoot, platform, entryFile) {
+  const out = import_node_fs.mkdtempSync(import_node_path.join(import_node_os.tmpdir(), `preview-${platform}-`));
+  const args = [
+    "expo",
+    "export:embed",
+    "--platform",
+    platform,
+    "--dev",
+    "false",
+    "--bytecode",
+    "--bundle-output",
+    import_node_path.join(out, BUNDLE_FILE[platform]),
+    "--assets-dest",
+    out
+  ];
+  if (entryFile)
+    args.push("--entry-file", entryFile);
+  import_node_child_process.execFileSync("npx", args, { cwd: projectRoot, stdio: "inherit" });
+  const files = walk(out).map((absolutePath) => {
+    const data = import_node_fs.readFileSync(absolutePath);
+    return {
+      absolutePath,
+      path: import_node_path.relative(out, absolutePath).split(import_node_path.sep).join("/"),
+      sha256: import_node_crypto.createHash("sha256").update(data).digest("hex"),
+      size: import_node_fs.statSync(absolutePath).size
+    };
+  });
+  const bundle = import_node_fs.readFileSync(import_node_path.join(out, BUNDLE_FILE[platform]));
+  return { files, hermesVersion: hermesVersion(bundle) };
+}
+
+// src/utils/publish/changelog.util.ts
+function changelogFromSubjects(subjects) {
+  return subjects.map((s) => s.trim()).filter(Boolean).map((s) => `- ${s}`).join(`
+`);
+}
+function shortChangelog(changelog, maxLines = 3, maxChars = 280) {
+  const lines = changelog.split(`
+`).filter((l) => l.trim());
+  let short = lines.slice(0, maxLines).join(`
+`);
+  if (short.length > maxChars)
+    short = `${short.slice(0, maxChars - 1).trimEnd()}…`;
+  else if (lines.length > maxLines)
+    short += `
+… ${lines.length - maxLines} more`;
+  return short;
+}
+
+// src/utils/publish/indexes.util.ts
+var newestFirst = (a, b) => b.publishedAt.localeCompare(a.publishedAt);
+function upsertPreview(index, platform, build, entry, now) {
+  const others = (index?.previews ?? []).filter((p) => p.id !== entry.id);
+  return {
+    schema: SCHEMA,
+    platform,
+    key: build.key,
+    compatibility: build.compatibility,
+    updatedAt: now,
+    previews: [...others, entry].sort(newestFirst)
+  };
+}
+function removePreview(index, id, now) {
+  return {
+    ...index,
+    updatedAt: now,
+    previews: index.previews.filter((p) => p.id !== id)
+  };
+}
+function syncRootVersion(root, index, now) {
+  const versions = (root?.versions ?? []).filter((v) => !(v.platform === index.platform && v.key === index.key));
+  if (index.previews.length > 0) {
+    const latest = index.previews[0];
+    const version = {
+      platform: index.platform,
+      key: index.key,
+      compatibility: index.compatibility,
+      appVersion: latest.appVersion,
+      buildNumber: latest.buildNumber,
+      fingerprint: latest.fingerprint,
+      count: index.previews.length,
+      updatedAt: now,
+      index: platformIndexKey(index.platform, index.key),
+      previews: index.previews.map(({ id, title, publishedAt }) => ({
+        id,
+        title,
+        publishedAt
+      }))
+    };
+    versions.push(version);
+  }
+  versions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return { schema: SCHEMA, updatedAt: now, versions };
+}
+var indexesListing = (root, id) => (root?.versions ?? []).filter((v) => v.previews.some((p) => p.id === id)).map((v) => v.index);
+
+// src/utils/config/expo-config.util.ts
+var PLUGIN_NAME = "@axonpack/preview";
+function compatibilityOf(config) {
+  for (const plugin of config.plugins ?? []) {
+    if (Array.isArray(plugin) && plugin[0] === PLUGIN_NAME) {
+      const option = plugin[1]?.compatibility;
+      if (option === undefined)
+        break;
+      if (!isCompatibility(option)) {
+        throw new Error(`${PLUGIN_NAME}: compatibility must be "appVersion" or "fingerprint"`);
+      }
+      return option;
+    }
+  }
+  return DEFAULT_COMPATIBILITY;
+}
+var appVersionOf = (config, platform) => String(config[platform]?.version ?? config.version ?? "");
+var buildNumberOf = (config, platform) => String((platform === "ios" ? config.ios?.buildNumber : config.android?.versionCode) ?? "");
+function resolveCompatibility(fromApp, flag) {
+  if (flag !== undefined && !isCompatibility(flag)) {
+    throw new Error(`--compatibility must be appVersion or fingerprint, not ${flag}`);
+  }
+  const compatibility = flag ?? fromApp;
+  const warnings = [];
+  if (compatibility !== fromApp) {
+    warnings.push(`--compatibility ${compatibility} differs from the app config (${fromApp}), so a build of this app will not list this preview.`);
+  }
+  if (compatibility === "appVersion") {
+    warnings.push("Matched by app version: a native change without a version bump is not detected. Bump the version after native changes, or use fingerprint.");
+  }
+  return { compatibility, warnings };
+}
+
+// src/services/cli/project.service.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_module = require("node:module");
+var import_node_path2 = require("node:path");
+var git = (cwd, args) => {
+  try {
+    return import_node_child_process2.execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+};
+var appRequire = (projectRoot) => {
+  const expo = import_node_module.createRequire(import_node_path2.join(projectRoot, "package.json")).resolve("expo/package.json");
+  return import_node_module.createRequire(expo);
+};
+function appConfig(projectRoot) {
+  const { getConfig } = appRequire(projectRoot)("@expo/config");
+  return getConfig(projectRoot, { skipSDKVersionRequirement: true }).exp;
+}
+async function fingerprint(projectRoot, platform) {
+  const { createFingerprintAsync } = appRequire(projectRoot)("@expo/fingerprint");
+  const result = await createFingerprintAsync(projectRoot, {
+    platforms: [platform],
+    silent: true
+  });
+  return result.hash;
+}
+function gitInfo(projectRoot, {
+  id,
+  env = process.env
+} = {}) {
+  const ref = git(projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? "";
+  return {
+    branch: ref === "HEAD" ? env.GITHUB_HEAD_REF || id || "" : ref,
+    commit: git(projectRoot, ["rev-parse", "--short", "HEAD"]) ?? "",
+    author: git(projectRoot, ["log", "-1", "--format=%an"]) ?? git(projectRoot, ["config", "user.name"]) ?? ""
+  };
+}
+var gitTopLevel = (projectRoot) => git(projectRoot, ["rev-parse", "--show-toplevel"]);
+function defaultBase(projectRoot) {
+  const head = git(projectRoot, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (head)
+    return head;
+  for (const name of ["main", "master"]) {
+    if (git(projectRoot, ["rev-parse", "--verify", "--quiet", name]) !== null)
+      return name;
+  }
+  return null;
+}
+function changelogSince(projectRoot, base) {
+  if (!base)
+    return "";
+  const forkPoint = git(projectRoot, ["merge-base", "HEAD", base]);
+  if (!forkPoint)
+    return "";
+  const subjects = git(projectRoot, [
+    "log",
+    "--format=%s",
+    `${forkPoint}..HEAD`
+  ]);
+  return changelogFromSubjects(subjects ? subjects.split(`
+`) : []);
+}
+
+// src/services/publish/commands.service.ts
+var log = (message) => process.stdout.write(`${message}
+`);
+async function updateJson(s3, key, change, attempts = 8) {
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    const current = await getJson(s3, key);
+    const next = change(current?.data ?? null);
+    const written = await putObject(s3, key, JSON.stringify(next, null, 2), {
+      contentType: "application/json",
+      etag: current?.etag ?? null
+    });
+    if (written)
+      return next;
+    await new Promise((r) => setTimeout(r, 100 * attempt + Math.random() * 200));
+  }
+  throw new Error(`Gave up writing ${key}: it kept changing under us`);
+}
+async function publish(options) {
+  const { s3, id } = options;
+  const title = options.title || previewTitle(id);
+  const publishedAt = new Date().toISOString();
+  for (const platform of options.platforms) {
+    log(`
+${platform}: building ${id}`);
+    const { files, hermesVersion } = buildBundle(options.projectRoot, platform, options.entryFile);
+    const fp = await fingerprint(options.projectRoot, platform);
+    const version = appVersionOf(options.config, platform);
+    const key = compatibilityKey(options.compatibility, options.compatibility === "appVersion" ? version : fp);
+    let uploaded = 0;
+    for (const file of files) {
+      if (await exists(s3, fileKey(file.sha256)))
+        continue;
+      await putObject(s3, fileKey(file.sha256), import_node_fs2.readFileSync(file.absolutePath));
+      uploaded++;
+    }
+    log(`${platform}: ${files.length} files, ${uploaded} new`);
+    const info = {
+      id,
+      title,
+      branch: options.branch,
+      commit: options.commit,
+      author: options.author,
+      publishedAt,
+      appVersion: version,
+      buildNumber: buildNumberOf(options.config, platform),
+      compatibility: options.compatibility,
+      fingerprint: fp
+    };
+    const manifest = {
+      schema: SCHEMA,
+      ...info,
+      platform,
+      key,
+      bundle: BUNDLE_FILE[platform],
+      hermesVersion,
+      changelog: options.changelog,
+      files: files.map(({ path, sha256, size }) => ({ path, sha256, size }))
+    };
+    const manifestPath = manifestKey(platform, key, id);
+    await putObject(s3, manifestPath, JSON.stringify(manifest, null, 2), {
+      contentType: "application/json"
+    });
+    const entry = {
+      ...info,
+      revision: import_node_crypto2.createHash("sha256").update(manifest.files.map((f) => `${f.path}:${f.sha256}`).sort().join(`
+`)).digest("hex").slice(0, 16),
+      size: files.reduce((sum, f) => sum + f.size, 0),
+      changelog: shortChangelog(options.changelog),
+      manifest: manifestPath
+    };
+    const index = await updateJson(s3, platformIndexKey(platform, key), (current) => upsertPreview(current, platform, { key, compatibility: options.compatibility }, entry, publishedAt));
+    await updateJson(s3, ROOT_INDEX_KEY, (root) => syncRootVersion(root, index, publishedAt));
+    log(`${platform}: published ${id} for build ${key}`);
+    log(`${platform}: ${objectUrl(s3, platformIndexKey(platform, key))}`);
+  }
+}
+async function unpublish(s3, id) {
+  const root = await getJson(s3, ROOT_INDEX_KEY);
+  const keys = indexesListing(root?.data ?? null, id);
+  if (keys.length === 0) {
+    log(`${id} is not published`);
+    return;
+  }
+  const now = new Date().toISOString();
+  for (const key of keys) {
+    const index = await updateJson(s3, key, (current) => {
+      if (!current)
+        throw new Error(`${key} is listed in ${ROOT_INDEX_KEY} but missing`);
+      return removePreview(current, id, now);
+    });
+    await deleteObject(s3, manifestKey(index.platform, index.key, id));
+    await updateJson(s3, ROOT_INDEX_KEY, (current) => syncRootVersion(current, index, now));
+    log(`unpublished ${id} from ${key}`);
+  }
+}
+async function prune(s3) {
+  const referenced = new Set;
+  for (const key of await listKeys(s3, "previews/")) {
+    const manifest = await getJson(s3, key);
+    manifest?.data.files.forEach((f) => referenced.add(fileKey(f.sha256)));
+  }
+  let removed = 0;
+  for (const key of await listKeys(s3, "files/")) {
+    if (referenced.has(key))
+      continue;
+    await deleteObject(s3, key);
+    removed++;
+  }
+  log(`pruned ${removed} files, kept ${referenced.size}`);
+}
+
+// src/services/publish/eas-env.service.ts
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path3 = require("node:path");
+var import_node_util = require("node:util");
+function pullEasEnv(projectRoot, environment) {
+  const dir = import_node_fs3.mkdtempSync(import_node_path3.join(import_node_os2.tmpdir(), "preview-eas-env-"));
+  const file = import_node_path3.join(dir, ".env");
+  try {
+    import_node_child_process3.execFileSync("eas", [
+      "env:pull",
+      "--environment",
+      environment,
+      "--non-interactive",
+      "--path",
+      file
+    ], { cwd: projectRoot, encoding: "utf8", stdio: "pipe" });
+    return import_node_util.parseEnv(import_node_fs3.readFileSync(file, "utf8"));
+  } catch (error) {
+    throw easError(error, environment);
+  } finally {
+    import_node_fs3.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function easError(error, environment) {
+  const e = error;
+  if (e.code === "ENOENT")
+    return new Error("--environment needs eas-cli: npm install -g eas-cli, then eas login.");
+  const output = `${e.stdout ?? ""}${e.stderr ?? ""}`;
+  if (output.includes("An Expo user account is required"))
+    return new Error("--environment needs an Expo login: run eas login, or set EXPO_TOKEN in CI.");
+  if (output.includes("eas init"))
+    return new Error("--environment needs the project linked to EAS: run eas init in the app's root.");
+  return new Error(`eas env:pull --environment ${environment} failed:
+${output.trim() || String(error)}`);
+}
+function applyEasEnv(projectRoot, environment, env = process.env) {
+  for (const [name, value] of Object.entries(pullEasEnv(projectRoot, environment)))
+    if (env[name] === undefined)
+      env[name] = value;
+}
+
+// src/constants/dev-preview-servers/dev-preview-servers.const.ts
+var DEFAULT_REGISTRY_PORT = 19150;
+var DEFAULT_PORT_RANGE = [8081, 8099];
+var HEARTBEAT_MS = 5000;
+var SERVER_TTL_MS = 15000;
+
+// src/services/cli/config.service.ts
+var import_node_path4 = require("node:path");
+var ENV = {
+  url: "PREVIEW_S3_URL",
+  accessKeyId: "PREVIEW_S3_ACCESS_KEY_ID",
+  secretAccessKey: "PREVIEW_S3_SECRET_ACCESS_KEY",
+  region: "PREVIEW_S3_REGION"
+};
+var expoEnvFiles = (projectRoot, env) => appRequire(projectRoot)("@expo/env").parseProjectEnv(projectRoot, {
+  mode: "production",
+  silent: true,
+  systemEnv: env
+}).env;
+function readConfig(projectRoot, env = process.env) {
+  env = { ...expoEnvFiles(projectRoot, env), ...env };
+  const missing = [ENV.url, ENV.accessKeyId, ENV.secretAccessKey].filter((name) => !env[name]);
+  if (missing.length > 0) {
+    throw new Error(`Set ${missing.join(", ")} in the environment (CI secrets), or locally in ${import_node_path4.join(projectRoot, ".env.local")}. Any env file Expo loads for a release build works, but keep the write key out of a committed .env.`);
+  }
+  return {
+    ...parseBucketUrl(env[ENV.url]),
+    region: env[ENV.region] || DEFAULT_REGION,
+    credentials: {
+      accessKeyId: env[ENV.accessKeyId],
+      secretAccessKey: env[ENV.secretAccessKey]
+    }
+  };
+}
+
+// src/services/registry/registry.service.ts
+var import_node_http = require("node:http");
+class ServerList {
+  ttlMs;
+  entries = new Map;
+  constructor(ttlMs = SERVER_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  upsert(server, now) {
+    this.entries.set(server.id, { server, lastSeen: now });
+  }
+  remove(id) {
+    this.entries.delete(id);
+  }
+  alive(now) {
+    for (const [id, entry] of this.entries) {
+      if (now - entry.lastSeen > this.ttlMs)
+        this.entries.delete(id);
+    }
+    return [...this.entries.values()].map((e) => e.server).sort((a, b) => a.port - b.port);
+  }
+}
+var readBody = (req) => new Promise((resolve, reject) => {
+  let body = "";
+  req.on("data", (chunk) => body += chunk);
+  req.on("end", () => resolve(body));
+  req.on("error", reject);
+});
+function createRegistry(options = {}) {
+  const now = options.now ?? Date.now;
+  const list = new ServerList(options.ttlMs);
+  let emptySince = now();
+  const server = import_node_http.createServer(async (req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, {
+        "content-type": "application/json",
+        "cache-control": "no-store"
+      });
+      res.end(body === undefined ? "" : JSON.stringify(body));
+    };
+    try {
+      if (req.method === "GET" && req.url === "/servers") {
+        send(200, { servers: list.alive(now()) });
+      } else if (req.method === "POST" && req.url === "/servers") {
+        const entry = JSON.parse(await readBody(req));
+        if (typeof entry.id !== "string" || typeof entry.port !== "number") {
+          send(400, { error: "id and port are required" });
+          return;
+        }
+        list.upsert(entry, now());
+        send(204);
+      } else if (req.method === "DELETE" && req.url?.startsWith("/servers/")) {
+        list.remove(decodeURIComponent(req.url.slice("/servers/".length)));
+        send(204);
+      } else {
+        send(404, { error: "not found" });
+      }
+    } catch (error) {
+      send(400, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  if (options.onIdle) {
+    const timer = setInterval(() => {
+      if (list.alive(now()).length > 0)
+        emptySince = now();
+      else if (now() - emptySince > (options.idleExitMs ?? 30000))
+        options.onIdle?.();
+    }, 1000);
+    timer.unref();
+    server.on("close", () => clearInterval(timer));
+  }
+  return { server, list };
+}
+
+// src/services/start/start.service.ts
+var import_node_child_process4 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_net = require("node:net");
+var log2 = (message) => process.stdout.write(`preview: ${message}
+`);
+var portIsFree = (port) => new Promise((resolve) => {
+  const probe = import_node_net.createServer();
+  probe.once("error", () => resolve(false));
+  probe.once("listening", () => probe.close(() => resolve(true)));
+  probe.listen(port);
+});
+async function freePort([from, to], claimed = new Set) {
+  for (let port = from;port <= to; port++) {
+    if (claimed.has(port))
+      continue;
+    if (await portIsFree(port))
+      return port;
+  }
+  throw new Error(`No free port between ${from} and ${to}; pass --ports <from>-<to>.`);
+}
+function registration(input) {
+  const { config } = input;
+  const compatibility = compatibilityOf(config);
+  const keys = {};
+  for (const platform of PLATFORMS) {
+    const value = compatibility === "appVersion" ? appVersionOf(config, platform) : input.fingerprints?.[platform];
+    if (value)
+      keys[platform] = compatibilityKey(compatibility, value);
+  }
+  return {
+    id: `${input.port}-${import_node_crypto3.randomUUID().slice(0, 8)}`,
+    port: input.port,
+    title: input.title || (input.branch ? previewTitle(input.branch) : config.name ?? ""),
+    branch: input.branch,
+    worktree: input.worktree,
+    slug: config.slug ?? "",
+    name: config.name ?? "",
+    iosBundleIdentifier: config.ios?.bundleIdentifier,
+    androidPackage: config.android?.package,
+    compatibility,
+    keys,
+    startedAt: new Date().toISOString()
+  };
+}
+var registryUp = async (registry) => {
+  try {
+    return (await fetch(`${registry}/servers`, { signal: AbortSignal.timeout(500) })).ok;
+  } catch {
+    return false;
+  }
+};
+async function ensureRegistry(registryPort, bin) {
+  const registry = `http://127.0.0.1:${registryPort}`;
+  if (await registryUp(registry))
+    return registry;
+  import_node_child_process4.spawn(process.execPath, [bin, "registry", "--port", String(registryPort)], {
+    detached: true,
+    stdio: "ignore"
+  }).unref();
+  for (let i = 0;i < 30; i++) {
+    if (await registryUp(registry))
+      return registry;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`The registry did not start on port ${registryPort}.`);
+}
+function adbReverse(ports) {
+  let devices;
+  try {
+    devices = import_node_child_process4.execFileSync("adb", ["devices"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).split(`
+`).slice(1).filter((line) => line.endsWith("\tdevice")).map((line) => line.split("\t")[0]);
+  } catch {
+    return;
+  }
+  for (const serial of devices) {
+    for (const port of ports) {
+      try {
+        import_node_child_process4.execFileSync("adb", ["-s", serial, "reverse", `tcp:${port}`, `tcp:${port}`], { stdio: "ignore" });
+      } catch {}
+    }
+  }
+}
+async function start(options) {
+  const registry = await ensureRegistry(options.registryPort, options.bin);
+  const claimed = await fetch(`${registry}/servers`).then((res) => res.json()).then(({ servers }) => new Set(servers.map((s) => s.port))).catch(() => new Set);
+  const port = await freePort(options.ports, claimed);
+  const fingerprints = {};
+  if (compatibilityOf(options.config) === "fingerprint") {
+    for (const platform of PLATFORMS) {
+      fingerprints[platform] = await fingerprint(options.projectRoot, platform);
+    }
+  }
+  const server = registration({ ...options, port, fingerprints });
+  adbReverse([options.registryPort, port]);
+  const post = () => fetch(`${registry}/servers`, {
+    method: "POST",
+    body: JSON.stringify(server)
+  });
+  const register = () => post().catch(() => ensureRegistry(options.registryPort, options.bin).then(post)).catch(() => {});
+  const unregister = () => fetch(`${registry}/servers/${encodeURIComponent(server.id)}`, {
+    method: "DELETE"
+  }).catch(() => {
+    return;
+  });
+  await register();
+  log2(`${server.title || server.name} on port ${port}, announced on ${registry}`);
+  let beats = 0;
+  const heartbeat = setInterval(() => {
+    register();
+    if (++beats % 6 === 0)
+      adbReverse([options.registryPort, port]);
+  }, HEARTBEAT_MS);
+  const child = import_node_child_process4.spawn("npx", ["expo", "start", "--port", String(port), ...options.expoArgs], {
+    cwd: options.projectRoot,
+    stdio: "inherit"
+  });
+  let stopping = false;
+  const stop = async (code) => {
+    if (stopping)
+      return;
+    stopping = true;
+    clearInterval(heartbeat);
+    await unregister();
+    process.exit(code);
+  };
+  child.on("exit", (code) => stop(code ?? 0));
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => {
+      child.kill(signal);
+      stop(0);
+    });
+  }
+}
+
+// src/services/cli/title.service.ts
+var import_node_readline = require("node:readline");
+async function askTitle(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  if (options.given)
+    return options.given;
+  if (!input.isTTY || !output.isTTY)
+    return options.fallback;
+  const rl = import_node_readline.createInterface({ input, output });
+  try {
+    const answer = new Promise((resolve) => rl.question("Name in the app: ", resolve));
+    rl.write(options.fallback);
+    return (await answer).trim() || options.fallback;
+  } finally {
+    rl.close();
+  }
+}
+
+// src/cli.ts
+var HELP = `preview <command> [options]
+
+  publish            build this app's JS bundle and upload it as a preview
+    --id <id>          preview id (default: the git branch)
+    --title <title>    name QA sees; without it a terminal asks, prefilled with a readable
+                       form of the id (Enter keeps it). No prompt without a terminal (CI)
+    --platform <p>     android, ios or all (default: all)
+    --base <branch>    branch the changelog counts from (default: the repo's default branch)
+    --changelog=<text> changelog text instead of the commit subjects (use = when it starts
+                       with a dash, as a "- item" list does)
+    --changelog-file <path>
+    --entry-file <path>
+    --compatibility <c> appVersion or fingerprint; overrides the app config's plugin option
+    --environment <name> build with this EAS environment's variables, like eas update
+                       (needs eas-cli and a project linked to EAS; shell variables win)
+  unpublish <id>     remove a preview from every build's list
+  prune              delete files no preview uses any more
+  start [-- <expo start args>]
+                     run Metro on a free port and announce it to the app's Dev preview servers
+    --title <title>    name the app's list shows; asked like publish, prefilled with a
+                       readable form of the branch
+    --ports <from>-<to> ports to pick from (default 8081-8099)
+
+  --project <dir>    the app's root (default: the current folder)
+
+Where to publish comes from the environment (the shell, or CI secrets). For local use they can
+also go in the app's .env.local, or any env file Expo loads for a release build; the environment
+wins over them. Keep the write key out of a committed .env:
+  PREVIEW_S3_URL                 <endpoint>/<bucket>[/<folder>], e.g. http://localhost:9000/previews-public
+  PREVIEW_S3_ACCESS_KEY_ID       the write key
+  PREVIEW_S3_SECRET_ACCESS_KEY
+  PREVIEW_S3_REGION              optional, default us-east-1`;
+async function main() {
+  const argv = process.argv.slice(2);
+  const dash = argv.indexOf("--");
+  const passThrough = dash >= 0 ? argv.slice(dash + 1) : [];
+  const { values, positionals } = import_node_util2.parseArgs({
+    args: dash >= 0 ? argv.slice(0, dash) : argv,
+    allowPositionals: true,
+    options: {
+      id: { type: "string" },
+      title: { type: "string" },
+      platform: { type: "string", default: "all" },
+      base: { type: "string" },
+      changelog: { type: "string" },
+      "changelog-file": { type: "string" },
+      "entry-file": { type: "string" },
+      compatibility: { type: "string" },
+      environment: { type: "string" },
+      project: { type: "string" },
+      port: { type: "string" },
+      ports: { type: "string" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  const [command, arg] = positionals;
+  if (values.help || !command) {
+    process.stdout.write(`${HELP}
+`);
+    return;
+  }
+  const projectRoot = import_node_path5.resolve(values.project ?? process.cwd());
+  const s3 = () => readConfig(projectRoot);
+  if (command === "publish") {
+    if (values.environment)
+      applyEasEnv(projectRoot, values.environment);
+    const git = gitInfo(projectRoot, { id: values.id });
+    const id = values.id ?? git.branch;
+    if (!id)
+      throw new Error("No git branch to name the preview after; pass --id.");
+    const platforms = values.platform === "all" ? PLATFORMS : [values.platform];
+    if (!platforms.every((p) => PLATFORMS.includes(p))) {
+      throw new Error(`--platform must be android, ios or all`);
+    }
+    const changelog = values.changelog ?? (values["changelog-file"] ? import_node_fs4.readFileSync(import_node_path5.resolve(values["changelog-file"]), "utf8").trim() : changelogSince(projectRoot, values.base ?? defaultBase(projectRoot)));
+    const config = appConfig(projectRoot);
+    const { compatibility, warnings } = resolveCompatibility(compatibilityOf(config), values.compatibility);
+    for (const warning of warnings)
+      process.stderr.write(`warning: ${warning}
+`);
+    await publish({
+      projectRoot,
+      config,
+      compatibility,
+      s3: s3(),
+      platforms,
+      id,
+      title: await askTitle({
+        given: values.title,
+        fallback: previewTitle(id)
+      }),
+      ...git,
+      changelog,
+      entryFile: values["entry-file"]
+    });
+  } else if (command === "unpublish") {
+    if (!arg)
+      throw new Error("Which preview? preview unpublish <id>");
+    await unpublish(s3(), arg);
+  } else if (command === "prune") {
+    await prune(s3());
+  } else if (command === "start") {
+    const [from, to] = (values.ports ?? `${DEFAULT_PORT_RANGE[0]}-${DEFAULT_PORT_RANGE[1]}`).split("-").map(Number);
+    if (!from || !to || from > to)
+      throw new Error("--ports must look like 8081-8099");
+    const config = appConfig(projectRoot);
+    const branch = gitInfo(projectRoot).branch;
+    const title = await askTitle({
+      given: values.title,
+      fallback: branch ? previewTitle(branch) : ""
+    });
+    await start({
+      projectRoot,
+      config,
+      branch,
+      title,
+      worktree: gitTopLevel(projectRoot) ?? projectRoot,
+      ports: [from, to],
+      registryPort: DEFAULT_REGISTRY_PORT,
+      expoArgs: passThrough,
+      bin: process.argv[1]
+    });
+  } else if (command === "registry") {
+    const port = Number(values.port ?? DEFAULT_REGISTRY_PORT);
+    const { server } = createRegistry({ onIdle: () => process.exit(0) });
+    server.listen(port);
+  } else {
+    throw new Error(`Unknown command ${command}.
+
+${HELP}`);
+  }
+}
+main().catch((error) => {
+  process.stderr.write(`preview: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});