@autter/runtime-cli 0.0.0-stage → 1.0.0

package/dist/chunk-SIRFO2QU.js

@@ -0,0 +1,524 @@
+// src/debug-id.ts
+import { createHash } from "crypto";
+var DEBUG_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function normalizeDebugId(value) {
+  if (typeof value !== "string") return null;
+  const id = value.trim().toLowerCase();
+  return DEBUG_ID_RE.test(id) ? id : null;
+}
+function debugIdFor(bytes) {
+  const hash = createHash("sha256").update(bytes).digest();
+  hash[6] = hash[6] & 15 | 64;
+  hash[8] = hash[8] & 63 | 128;
+  const hex = hash.subarray(0, 16).toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+var DEBUG_ID_COMMENT_RE = /^\/\/# debugId=([0-9a-fA-F-]{36})[ \t]*\r?$/gm;
+function readDebugIdComment(code) {
+  let found = null;
+  for (const match of code.matchAll(DEBUG_ID_COMMENT_RE)) found = normalizeDebugId(match[1]) ?? found;
+  return found;
+}
+var DEBUG_ID_REGISTRY = "_autterDebugIds";
+function debugIdSnippet(id) {
+  return `;!function(){try{var g="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},s=(new g.Error).stack;s&&((g.${DEBUG_ID_REGISTRY}=g.${DEBUG_ID_REGISTRY}||{})[s]="${id}")}catch(e){}}();`;
+}
+var SNIPPET_RE = /\(g\._autterDebugIds=g\._autterDebugIds\|\|\{\}\)\[s\]="[0-9a-f]{8}-/;
+function hasDebugIdSnippet(code) {
+  return SNIPPET_RE.test(code);
+}
+
+// src/files.ts
+import { existsSync } from "fs";
+import { readdir, readFile } from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "path";
+var BUNDLE_RE = /\.[cm]?js$/;
+var SOURCE_MAPPING_URL_RE = /^[ \t]*\/\/[#@] sourceMappingURL=([^\s'"]+)[ \t]*\r?$/gm;
+function readSourceMappingUrl(code) {
+  let found = null;
+  for (const match of code.matchAll(SOURCE_MAPPING_URL_RE)) found = match[1];
+  return found;
+}
+function stripSourceMappingUrl(code) {
+  const lines = code.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    if (/^\/\/[#@] sourceMappingURL=/.test(line)) {
+      lines.splice(i, 1);
+      return lines.join("\n");
+    }
+    if (!line.startsWith("//#")) break;
+  }
+  return code;
+}
+function mapPathFor(js, code) {
+  const url = readSourceMappingUrl(code);
+  if (url && !/^[a-z][\w+.-]*:/i.test(url) && !url.startsWith("/")) {
+    let decoded = url.split(/[?#]/)[0];
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+    }
+    const candidate = resolve(dirname(js), decoded);
+    if (existsSync(candidate)) return candidate;
+  }
+  const sibling = `${js}.map`;
+  return existsSync(sibling) ? sibling : null;
+}
+async function walk(dir, out) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name === "node_modules") continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) await walk(full, out);
+    else if (entry.isFile() && BUNDLE_RE.test(entry.name)) out.push(full);
+  }
+}
+async function findBundles(dir, files) {
+  const root = resolve(dir);
+  const candidates = [];
+  if (files) {
+    for (const file of files) if (BUNDLE_RE.test(file)) candidates.push(resolve(root, file));
+  } else {
+    await walk(root, candidates);
+  }
+  const bundles = [];
+  for (const js of [...new Set(candidates)].sort()) {
+    let code;
+    try {
+      code = await readFile(js, "utf8");
+    } catch {
+      continue;
+    }
+    const map = mapPathFor(js, code);
+    if (map) bundles.push({ js, map, path: relative(root, js).split(sep).join("/") });
+  }
+  return bundles;
+}
+
+// src/inject.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+var SNIPPET_LINE_KEY = "x_autter_snippet_line";
+function snippetLine(code) {
+  let line = 0;
+  let i = 0;
+  if (code.startsWith("#!")) {
+    const nl = code.indexOf("\n");
+    if (nl < 0) return -1;
+    line = 1;
+    i = nl + 1;
+  }
+  for (; ; ) {
+    while (i < code.length && /\s/.test(code[i])) i++;
+    if (code.startsWith("//", i)) {
+      const nl = code.indexOf("\n", i);
+      if (nl < 0) return -1;
+      i = nl + 1;
+    } else if (code.startsWith("/*", i)) {
+      const end = code.indexOf("*/", i + 2);
+      if (end < 0) return -1;
+      i = end + 2;
+    } else {
+      break;
+    }
+  }
+  return code[i] === '"' || code[i] === "'" ? -1 : line;
+}
+function shiftMappings(mappings, at, count = 1) {
+  const lines = mappings.split(";");
+  while (lines.length < at) lines.push("");
+  lines.splice(at, 0, ...Array(count).fill(""));
+  return lines.join(";");
+}
+function insertBeforeTrailingComments(code, text) {
+  const lines = code.split("\n");
+  let at = lines.length;
+  while (at > 0) {
+    const line = lines[at - 1].trim();
+    if (line === "" || line.startsWith("//#") || line.startsWith("//@")) at--;
+    else break;
+  }
+  const head = lines.slice(0, at).join("\n");
+  const tail = lines.slice(at).join("\n");
+  return `${head}${head && !head.endsWith("\n") ? "\n" : ""}${text}${tail ? `
+${tail.replace(/^\n+/, "")}` : "\n"}`;
+}
+async function injectBundle(bundle, options = {}) {
+  const bytes = await readFile2(bundle.js);
+  const code = bytes.toString("utf8");
+  const base = { path: bundle.path, js: bundle.js, map: bundle.map };
+  let map;
+  try {
+    map = JSON.parse(await readFile2(bundle.map, "utf8"));
+    if (!map || typeof map !== "object") throw new Error("not an object");
+  } catch {
+    return { ...base, debugId: "", status: "invalid-map" };
+  }
+  const existing = readDebugIdComment(code);
+  const hasSnippet = hasDebugIdSnippet(code);
+  const debugId = existing ?? debugIdFor(bytes);
+  let out = code;
+  let mapDirty = false;
+  if (!hasSnippet) {
+    const shifted = typeof map[SNIPPET_LINE_KEY] === "number" ? map[SNIPPET_LINE_KEY] : null;
+    const line = shifted ?? snippetLine(code);
+    if (line >= 0 && (shifted !== null || typeof map.mappings === "string" && !("sections" in map))) {
+      let offset = 0;
+      for (let n = 0; n < line; n++) offset = out.indexOf("\n", offset) + 1;
+      out = `${out.slice(0, offset)}${debugIdSnippet(debugId)}
+${out.slice(offset)}`;
+      if (shifted === null) {
+        map.mappings = shiftMappings(map.mappings, line);
+        map[SNIPPET_LINE_KEY] = line;
+        mapDirty = true;
+      }
+    } else {
+      out = insertBeforeTrailingComments(out, debugIdSnippet(debugId));
+    }
+  }
+  if (!existing) out = `${out}${out.endsWith("\n") ? "" : "\n"}//# debugId=${debugId}
+`;
+  if (options.stripSourceMappingUrl) out = stripSourceMappingUrl(out);
+  if (map.debugId !== debugId) {
+    map.debugId = debugId;
+    mapDirty = true;
+  }
+  const changed = mapDirty || out !== code;
+  if (changed && !options.dryRun) {
+    if (mapDirty) await writeFile(bundle.map, JSON.stringify(map));
+    if (out !== code) await writeFile(bundle.js, out);
+  }
+  return { ...base, debugId, status: changed ? "injected" : "unchanged" };
+}
+async function injectDir(dir, options = {}) {
+  const results = [];
+  for (const bundle of await findBundles(dir, options.files)) results.push(await injectBundle(bundle, options));
+  return results;
+}
+
+// src/release.ts
+import { execFileSync } from "child_process";
+var RELEASE_RE = /^[a-zA-Z0-9._-]{1,200}$/;
+var RELEASE_ENV_VARS = [
+  "GITHUB_SHA",
+  "VERCEL_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "GIT_SHA"
+];
+function gitHead(cwd = process.cwd()) {
+  try {
+    const sha = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e4
+    }).trim();
+    return /^[0-9a-f]{7,64}$/.test(sha) ? sha : null;
+  } catch {
+    return null;
+  }
+}
+function resolveRelease(explicit, env = process.env, cwd = process.cwd()) {
+  const candidates = [
+    ["--release", explicit],
+    ...RELEASE_ENV_VARS.map((name) => [name, env[name]])
+  ];
+  for (const [source, value] of candidates) {
+    const release = value?.trim();
+    if (!release) continue;
+    if (!RELEASE_RE.test(release)) {
+      throw new Error(
+        `release "${release}" (from ${source}) is not valid: use 1-200 letters, digits, ".", "_" or "-" (a commit SHA works)`
+      );
+    }
+    return { release, source };
+  }
+  const head = gitHead(cwd);
+  if (head) return { release: head, source: "git" };
+  throw new Error(
+    `no release: pass --release <release>, or set one of ${RELEASE_ENV_VARS.join(", ")}, or run inside a git checkout`
+  );
+}
+
+// src/upload.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
+var MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
+var CHECK_BATCH = 500;
+var MAX_ATTEMPTS = 3;
+function resolveEndpoint(flag, env = process.env) {
+  const raw = flag || env.AUTTER_ENDPOINT || env.AUTTER_RUNTIME_ENDPOINT || env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_ENDPOINT;
+  return raw.trim().replace(/\/+$/, "").replace(/\/v1\/[a-z-]+$/, "");
+}
+function servedFilename(urlPrefix, path) {
+  let prefix = (urlPrefix ?? "/").trim() || "/";
+  if (prefix.startsWith("~/")) prefix = prefix.slice(1);
+  if (!/^[a-z][\w+.-]*:\/\//i.test(prefix) && !prefix.startsWith("/")) prefix = `/${prefix}`;
+  return `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function storedMapJson(map) {
+  const { sourcesContent: _omitted, ...safe } = map;
+  return JSON.stringify(safe);
+}
+async function prepare(bundle, urlPrefix, release) {
+  let map;
+  try {
+    map = JSON.parse(await readFile3(bundle.map, "utf8"));
+  } catch {
+    return { error: "map is not valid JSON" };
+  }
+  if (!map || map.version !== 3 || typeof map.mappings !== "string" || !Array.isArray(map.sources)) {
+    return { error: "not a version 3 source map with mappings and sources" };
+  }
+  const code = await readFile3(bundle.js, "utf8");
+  const debugId = readDebugIdComment(code) ?? normalizeDebugId(map.debugId);
+  const json = storedMapJson(map);
+  const filename = servedFilename(urlPrefix, bundle.path);
+  const body = `{"release":${JSON.stringify(release)},"filename":${JSON.stringify(filename)},${debugId ? `"debugId":${JSON.stringify(debugId)},` : ""}"map":${json}}`;
+  return {
+    bundle,
+    body,
+    path: bundle.path,
+    filename,
+    debugId,
+    hash: createHash2("sha256").update(json).digest("hex"),
+    bytes: Buffer.byteLength(body)
+  };
+}
+var FatalUploadError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function uploadDir(dir, options = {}) {
+  const env = options.env ?? process.env;
+  const log = options.log ?? (() => {
+  });
+  const doFetch = options.fetch ?? fetch;
+  const { release, source: releaseSource } = resolveRelease(options.release, env, options.cwd);
+  const endpoint = resolveEndpoint(options.endpoint, env);
+  const summary = {
+    release,
+    releaseSource,
+    endpoint,
+    dryRun: Boolean(options.dryRun),
+    uploaded: [],
+    skipped: [],
+    failed: [],
+    legacyIngester: false,
+    deletedMaps: []
+  };
+  const items = [];
+  for (const bundle of await findBundles(dir, options.files)) {
+    const prepared = await prepare(bundle, options.urlPrefix, release);
+    if ("error" in prepared) {
+      summary.failed.push({ path: bundle.path, filename: servedFilename(options.urlPrefix, bundle.path), error: prepared.error });
+    } else if (prepared.bytes > MAX_UPLOAD_BYTES) {
+      summary.failed.push({
+        path: prepared.path,
+        filename: prepared.filename,
+        error: `map is ${(prepared.bytes / 1048576).toFixed(1)} MB without sourcesContent; the ingester accepts up to 5 MB`
+      });
+    } else {
+      items.push(prepared);
+    }
+  }
+  if (options.dryRun) {
+    summary.uploaded = items.map(strip);
+    return summary;
+  }
+  const key = (options.key ?? env.AUTTER_RUNTIME_KEY ?? "").trim();
+  if (!key) throw new FatalUploadError("no ingest key: set AUTTER_RUNTIME_KEY to a server key (autter_rt_\u2026)");
+  if (key.startsWith("autter_rtc_")) {
+    throw new FatalUploadError("AUTTER_RUNTIME_KEY is a publishable client key (autter_rtc_\u2026); uploads need a server key (autter_rt_\u2026)");
+  }
+  const headers = { "content-type": "application/json", authorization: `Bearer ${key}` };
+  const skipped = /* @__PURE__ */ new Set();
+  for (let start = 0; start < items.length && !summary.legacyIngester; start += CHECK_BATCH) {
+    const batch = items.slice(start, start + CHECK_BATCH);
+    try {
+      const res = await doFetch(`${endpoint}/v1/sourcemaps/check`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          release,
+          files: batch.map((item) => ({ filename: item.filename, ...item.debugId ? { debugId: item.debugId } : {}, hash: item.hash }))
+        })
+      });
+      if (res.status === 404) {
+        summary.legacyIngester = true;
+        log(
+          "warning: this ingester predates 1.6.0, so it stores no debug ids and rejects .mjs/.cjs maps. Upgrade it: docker pull ghcr.io/autter-dev/otlp-ingester:latest"
+        );
+        break;
+      }
+      if (res.status === 401 || res.status === 403) {
+        throw new FatalUploadError(`the ingester rejected the key (${res.status}): ${(await res.text()).slice(0, 300)}`);
+      }
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const body = await res.json();
+      const present = new Set(Array.isArray(body.present) ? body.present : []);
+      batch.forEach((item, index) => {
+        if (present.has(index)) skipped.add(item);
+      });
+    } catch (err) {
+      if (err instanceof FatalUploadError) throw err;
+      log(`warning: could not check which maps the ingester already has (${err.message}); uploading all`);
+    }
+  }
+  const uploaded = [];
+  let fatal = null;
+  const uploadOne = async (item) => {
+    for (let attempt = 1; ; attempt++) {
+      if (fatal) return;
+      let status = 0;
+      let detail = "";
+      try {
+        const res = await doFetch(`${endpoint}/v1/sourcemaps`, { method: "POST", headers, body: item.body });
+        status = res.status;
+        if (res.ok) {
+          uploaded.push(item);
+          return;
+        }
+        detail = (await res.text()).slice(0, 300);
+      } catch (err) {
+        detail = err.message;
+      }
+      if (status === 401 || status === 403) {
+        fatal = new FatalUploadError(`the ingester rejected the key (${status}): ${detail}`);
+        return;
+      }
+      const retryable = status === 0 || status === 429 || status >= 500;
+      if (!retryable || attempt >= MAX_ATTEMPTS) {
+        summary.failed.push({ path: item.path, filename: item.filename, error: status ? `HTTP ${status}: ${detail}` : detail });
+        return;
+      }
+      await sleep(500 * 2 ** (attempt - 1));
+    }
+  };
+  const queue = items.filter((item) => !skipped.has(item));
+  const workers = Array.from({ length: Math.max(1, Math.min(options.concurrency ?? 8, queue.length)) }, async () => {
+    for (let item = queue.shift(); item; item = queue.shift()) await uploadOne(item);
+  });
+  await Promise.all(workers);
+  if (fatal) throw fatal;
+  const order = (a, b) => items.indexOf(a) - items.indexOf(b);
+  uploaded.sort(order);
+  if (options.deleteAfterUpload) {
+    for (const item of [...uploaded, ...skipped]) {
+      await rm(item.bundle.map, { force: true });
+      const code = await readFile3(item.bundle.js, "utf8");
+      const stripped = stripSourceMappingUrl(code);
+      if (stripped !== code) await writeFile2(item.bundle.js, stripped);
+      summary.deletedMaps.push(item.bundle.map);
+    }
+  }
+  summary.uploaded = uploaded.map(strip);
+  summary.skipped = [...skipped].sort(order).map(strip);
+  return summary;
+}
+function strip(item) {
+  const { path, filename, debugId, hash, bytes } = item;
+  return { path, filename, debugId, hash, bytes };
+}
+
+// src/build.ts
+function formatUploadSummary(summary) {
+  const lines = [];
+  const verb = summary.dryRun ? "would upload" : "uploaded";
+  for (const item of summary.uploaded) {
+    lines.push(`${verb} ${item.filename}${item.debugId ? ` (debug id ${item.debugId})` : ""}`);
+  }
+  for (const item of summary.skipped) lines.push(`skipped ${item.filename} (already uploaded)`);
+  for (const item of summary.failed) lines.push(`failed ${item.filename}: ${item.error}`);
+  lines.push(
+    `${summary.uploaded.length} ${verb}, ${summary.skipped.length} already uploaded, ${summary.failed.length} failed (release ${summary.release} from ${summary.releaseSource}, ${summary.endpoint})`
+  );
+  return lines;
+}
+async function processBuildOutput(input) {
+  const { options } = input;
+  const log = (line) => {
+    if (!options.silent) console.log(`[autter-runtime] ${line}`);
+  };
+  const result = { injected: [], upload: null };
+  try {
+    result.injected = await injectDir(input.dir, {
+      files: input.files,
+      dryRun: options.dryRun,
+      stripSourceMappingUrl: input.stripSourceMappingUrl
+    });
+    const changed = result.injected.filter((r) => r.status === "injected").length;
+    if (result.injected.length) {
+      log(`debug ids: ${changed} bundle(s) injected, ${result.injected.length - changed} already had one`);
+    }
+    for (const bad of result.injected.filter((r) => r.status === "invalid-map")) log(`skipped ${bad.path}: its map is not valid JSON`);
+    if (options.upload === false) return result;
+    const key = options.key ?? process.env.AUTTER_RUNTIME_KEY;
+    if (!key && !options.dryRun) {
+      if (result.injected.length) log("AUTTER_RUNTIME_KEY is not set: source maps were not uploaded");
+      return result;
+    }
+    if (!result.injected.some((r) => r.status !== "invalid-map")) return result;
+    result.upload = await uploadDir(input.dir, {
+      files: input.files,
+      release: options.release,
+      urlPrefix: options.urlPrefix ?? input.urlPrefix,
+      endpoint: options.endpoint,
+      key,
+      dryRun: options.dryRun,
+      concurrency: options.concurrency,
+      deleteAfterUpload: options.deleteAfterUpload ?? input.deleteAfterUpload,
+      log
+    });
+    for (const line of formatUploadSummary(result.upload)) log(line);
+    if (result.upload.failed.length && options.failOnError) {
+      throw new Error(`${result.upload.failed.length} source map upload(s) failed`);
+    }
+  } catch (err) {
+    const message = `source maps: ${err instanceof Error ? err.message : String(err)}`;
+    if (options.failOnError) throw new Error(`[autter-runtime] ${message}`);
+    if (!options.silent) console.warn(`[autter-runtime] ${message}`);
+  }
+  return result;
+}
+
+export {
+  DEBUG_ID_RE,
+  normalizeDebugId,
+  debugIdFor,
+  readDebugIdComment,
+  DEBUG_ID_REGISTRY,
+  debugIdSnippet,
+  hasDebugIdSnippet,
+  BUNDLE_RE,
+  readSourceMappingUrl,
+  stripSourceMappingUrl,
+  mapPathFor,
+  findBundles,
+  SNIPPET_LINE_KEY,
+  snippetLine,
+  shiftMappings,
+  injectBundle,
+  injectDir,
+  RELEASE_RE,
+  RELEASE_ENV_VARS,
+  gitHead,
+  resolveRelease,
+  DEFAULT_ENDPOINT,
+  MAX_UPLOAD_BYTES,
+  resolveEndpoint,
+  servedFilename,
+  storedMapJson,
+  FatalUploadError,
+  uploadDir,
+  formatUploadSummary,
+  processBuildOutput
+};