@observerkit/metro 0.2.0

package/README.md

@@ -0,0 +1,118 @@
+# @observerkit/metro
+
+Metro plugin for ObserverKit: injects debug IDs into React Native bundles and uploads source maps so production stack traces symbolicate, including Hermes builds.
+
+## Install
+
+```bash
+npm install --save-dev @observerkit/metro
+```
+
+## 1. Wrap your Metro config
+
+```js
+// metro.config.js
+const { getDefaultConfig } = require("@react-native/metro-config")
+const withObserverkit = require("@observerkit/metro")
+
+module.exports = withObserverkit(getDefaultConfig(__dirname))
+```
+
+Debug-id injection only runs for release bundles; dev builds are untouched.
+
+## 2. Upload source maps from your native builds
+
+The `observerkit-upload` CLI reads the project key from `--project-key` or the `OBSERVERKIT_PROJECT_KEY` environment variable.
+
+### Expo
+
+Add the config plugin; prebuild wires both native builds automatically:
+
+```json
+{
+  "expo": {
+    "plugins": [["@observerkit/metro/expo", { "projectKey": "YOUR_PROJECT_KEY" }]]
+  }
+}
+```
+
+For EAS Update bundles, upload after export:
+
+```bash
+npx expo export && npx observerkit-upload --dir dist
+```
+
+### Bare React Native: iOS
+
+Edit the "Bundle React Native code and images" build phase so a source map is emitted and uploaded:
+
+```sh
+export SOURCEMAP_FILE="$DERIVED_FILE_DIR/main.jsbundle.map"
+set -e
+WITH_ENVIRONMENT="../node_modules/react-native/scripts/xcode/with-environment.sh"
+REACT_NATIVE_XCODE="../node_modules/react-native/scripts/react-native-xcode.sh"
+/bin/sh -c "$WITH_ENVIRONMENT $REACT_NATIVE_XCODE"
+if [ -f "$SOURCEMAP_FILE" ]; then
+  npx observerkit-upload --map "$SOURCEMAP_FILE" --bundle "$CONFIGURATION_BUILD_DIR/main.jsbundle" --project-key "YOUR_PROJECT_KEY" || echo "[ObserverKit] source map upload failed"
+fi
+```
+
+`--bundle` points at the pre-Hermes JS bundle, which is where `observerkit-upload` finds the debugId on iOS (see Hermes below). The `|| echo` makes sure a failed upload never fails the archive, since this phase runs under `set -e`.
+
+### Bare React Native: Android
+
+Append to `android/app/build.gradle`:
+
+```groovy
+tasks.configureEach { task ->
+    def matcher = task.name =~ /^createBundle(\w*)ReleaseJsAndAssets$/
+    if (matcher.matches()) {
+        task.doLast {
+            def flavor = matcher.group(1)
+            def variant = flavor.isEmpty()
+                ? "release"
+                : flavor.substring(0, 1).toLowerCase() + flavor.substring(1) + "Release"
+            def mapFile = file("$buildDir/generated/sourcemaps/react/" + variant + "/index.android.bundle.map")
+            def packagerMapFile = file("$buildDir/intermediates/sourcemaps/react/" + variant + "/index.android.bundle.packager.map")
+            if (mapFile.exists()) {
+                def result = exec {
+                    workingDir rootProject.projectDir.parentFile
+                    environment "OBSERVERKIT_PROJECT_KEY", "YOUR_PROJECT_KEY"
+                    commandLine "npx", "observerkit-upload", "--map", mapFile.absolutePath, "--packager-map", packagerMapFile.absolutePath
+                    ignoreExitValue true
+                }
+                if (result.exitValue != 0) {
+                    logger.warn("[ObserverKit] source map upload failed")
+                }
+            } else {
+                logger.warn("[ObserverKit] No source map found at " + mapFile + ", skipping upload")
+            }
+        }
+    }
+}
+```
+
+The composed map lands in `generated/sourcemaps/react/<variant>/`, while the pre-compose packager map (needed to restore the `debugId`, see Hermes below) stays behind in `intermediates/sourcemaps/react/<variant>/`. `ignoreExitValue` plus the logged warning make sure a failed upload never fails `assembleRelease`.
+
+## Hermes
+
+Symbolication support targets Hermes, the React Native default JS engine; JSC is not supported.
+
+Hermes release builds compose the Metro source map with the bytecode map, which drops the `debugId` field. `observerkit-upload` restores it automatically:
+
+- On Android, from the packager map (`<bundle>.packager.map` next to the final map by convention, or pass `--packager-map` explicitly). The Gradle plugin keeps this file around after composing.
+- On iOS, `react-native-xcode.sh` deletes the packager map once the final map is composed, so there is nothing to restore it from there. Instead `observerkit-upload` reads the trailing `//# debugId=<uuid>` comment the ObserverKit serializer appends to the pre-Hermes JS bundle (the final map path with `.map` stripped, or pass `--bundle` explicitly).
+
+## CLI reference
+
+```
+observerkit-upload --map <path> [--packager-map <path>] [--bundle <path>]
+observerkit-upload --dir <path>
+
+--project-key <key>   Defaults to $OBSERVERKIT_PROJECT_KEY
+--endpoint <url>      Defaults to $OBSERVERKIT_ENDPOINT or https://ingest.observerkit.com
+```
+
+## pnpm note
+
+If your app uses pnpm and Metro is not a direct dependency, add it (`pnpm add -D metro`) so the plugin can load Metro's default serializer.

package/dist/chunk-6RJOM2CO.cjs

@@ -0,0 +1,199 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// ../plugin-core/src/upload.ts
+var _promises = require('fs/promises');
+var _path = require('path');
+
+// ../plugin-core/src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../plugin-core/src/upload.ts
+var DEFAULT_MAX_FILE_BYTES = 50 * 1024 * 1024;
+var DEFAULT_MAX_BATCH_BYTES = 100 * 1024 * 1024;
+function hasDebugId(content) {
+  if (!content.includes('"debugId"')) return false;
+  try {
+    const parsed = JSON.parse(content.toString("utf-8"));
+    return isJsonObject(parsed) && typeof parsed["debugId"] === "string";
+  } catch (e) {
+    return false;
+  }
+}
+function batchBySize(entries, maxBatchBytes) {
+  const batches = [];
+  let current = [];
+  let currentBytes = 0;
+  for (const entry of entries) {
+    if (current.length > 0 && currentBytes + entry.byteLength > maxBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 0;
+    }
+    current.push(entry);
+    currentBytes += entry.byteLength;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+async function deleteMapFiles(directory, mapFiles) {
+  const results = await Promise.allSettled(
+    mapFiles.map((mapFile) => _promises.unlink.call(void 0, _path.join.call(void 0, directory, mapFile)))
+  );
+  const failures = results.filter((r) => r.status === "rejected");
+  if (failures.length > 0) {
+    console.warn(
+      `[ObserverKit] Failed to delete ${failures.length}/${mapFiles.length} .map files`
+    );
+  }
+  console.log(
+    `[ObserverKit] Deleted ${mapFiles.length - failures.length} .map files from output`
+  );
+}
+async function uploadBatch(batch, options) {
+  const formData = new FormData();
+  for (const [index, entry] of batch.entries()) {
+    const content = await _promises.readFile.call(void 0, _path.join.call(void 0, options.directory, entry.mapFile));
+    formData.append(
+      `file-${index}`,
+      new Blob([new Uint8Array(content)], { type: "application/json" }),
+      entry.mapFile
+    );
+  }
+  const response = await fetch(options.url, {
+    method: "POST",
+    headers: {
+      "X-ObserverKit-Key": options.projectKey,
+      "X-ObserverKit-Plugin-Version": options.pluginVersion,
+      "X-ObserverKit-Plugin-Name": options.pluginName
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(
+      `[ObserverKit] Source map upload failed: ${response.status} ${text}`
+    );
+  }
+}
+var JS_SOURCE_MAPPING_URL = /^\/\/[#@] sourceMappingURL=\S+[ \t]*$/gm;
+var CSS_SOURCE_MAPPING_URL = /^\/\*# sourceMappingURL=\S+[ \t]*\*\/[ \t]*$/gm;
+function isChunkFile(name) {
+  return name.endsWith(".js") || name.endsWith(".mjs") || name.endsWith(".cjs") || name.endsWith(".css");
+}
+async function stripSourceMappingUrls(directory, files) {
+  let stripped = 0;
+  for (const file of files.filter(isChunkFile)) {
+    const path = _path.join.call(void 0, directory, file);
+    try {
+      const content = await _promises.readFile.call(void 0, path, "utf-8");
+      if (!content.includes("sourceMappingURL=")) continue;
+      const next = content.replace(JS_SOURCE_MAPPING_URL, "").replace(CSS_SOURCE_MAPPING_URL, "");
+      if (next !== content) {
+        await _promises.writeFile.call(void 0, path, next);
+        stripped += 1;
+      }
+    } catch (e2) {
+    }
+  }
+  if (stripped > 0) {
+    console.log(
+      `[ObserverKit] Stripped sourceMappingURL comments from ${stripped} file(s)`
+    );
+  }
+}
+async function uploadSourceMaps(options) {
+  const { projectKey, directory, endpoint, deleteAfterUpload, pluginVersion, pluginName } = options;
+  const maxFileBytes = _nullishCoalesce(options.maxFileBytes, () => ( DEFAULT_MAX_FILE_BYTES));
+  const maxBatchBytes = _nullishCoalesce(options.maxBatchBytes, () => ( DEFAULT_MAX_BATCH_BYTES));
+  const allFiles = options.files ? [...options.files] : await _promises.readdir.call(void 0, directory, { recursive: true, encoding: "utf-8" });
+  const allMapFiles = allFiles.filter((f) => f.endsWith(".map"));
+  if (allMapFiles.length === 0) {
+    console.log("[ObserverKit] No .map files found, skipping source map upload");
+    return;
+  }
+  try {
+    const uploadable = [];
+    let skippedNoDebugId = 0;
+    let skippedOversize = 0;
+    let skippedUnreadable = 0;
+    for (const mapFile of allMapFiles) {
+      let content;
+      try {
+        content = await _promises.readFile.call(void 0, _path.join.call(void 0, directory, mapFile));
+      } catch (e3) {
+        skippedUnreadable += 1;
+        continue;
+      }
+      if (!hasDebugId(content)) {
+        skippedNoDebugId += 1;
+        continue;
+      }
+      if (content.byteLength > maxFileBytes) {
+        skippedOversize += 1;
+        continue;
+      }
+      uploadable.push({ mapFile, byteLength: content.byteLength });
+    }
+    if (skippedNoDebugId > 0) {
+      console.log(
+        `[ObserverKit] Skipping ${skippedNoDebugId} source map(s) without a debugId field`
+      );
+    }
+    if (skippedOversize > 0) {
+      console.warn(
+        `[ObserverKit] Skipping ${skippedOversize} source map(s) over the per-file ingest limit`
+      );
+    }
+    if (skippedUnreadable > 0) {
+      console.warn(
+        `[ObserverKit] Skipping ${skippedUnreadable} unreadable source map(s)`
+      );
+    }
+    if (uploadable.length === 0) {
+      console.log(
+        "[ObserverKit] No uploadable source maps found, skipping upload"
+      );
+      return;
+    }
+    const url = `${endpoint.replace(/\/+$/, "")}/v1/sourcemaps`;
+    const batches = batchBySize(uploadable, maxBatchBytes);
+    for (const [index, batch] of batches.entries()) {
+      await uploadBatch(batch, { directory, url, projectKey, pluginVersion, pluginName });
+      console.log(
+        `[ObserverKit] Uploaded batch ${index + 1}/${batches.length} (${batch.length} source maps)`
+      );
+    }
+  } catch (err) {
+    if (deleteAfterUpload) {
+      console.warn(
+        "[ObserverKit] Upload failed \u2014 deleting .map files anyway so they don't ship (set deleteAfterUpload: false to keep them)"
+      );
+    }
+    throw err;
+  } finally {
+    if (deleteAfterUpload) {
+      await deleteMapFiles(directory, allMapFiles);
+      await stripSourceMappingUrls(directory, allFiles);
+    }
+  }
+}
+
+// ../plugin-core/src/debug-id.ts
+var _uuid = require('uuid');
+var OBSERVERKIT_NAMESPACE = "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d";
+function generateDebugId(content) {
+  return _uuid.v5.call(void 0, content, OBSERVERKIT_NAMESPACE);
+}
+
+// ../plugin-core/src/snippet.ts
+function buildStackKeyedDebugIdSnippet(debugId) {
+  const snippet = `globalThis._debugIds = globalThis._debugIds || {}; try { globalThis._debugIds[new Error().stack] = ${JSON.stringify(debugId)}; } catch (e) {}`;
+  return { snippet, lineCount: 1 };
+}
+
+
+
+
+
+
+exports.generateDebugId = generateDebugId; exports.isJsonObject = isJsonObject; exports.buildStackKeyedDebugIdSnippet = buildStackKeyedDebugIdSnippet; exports.uploadSourceMaps = uploadSourceMaps;

package/dist/chunk-AUOVSTQX.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.2_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+
+
+exports.importMetaUrl = importMetaUrl;

package/dist/chunk-DFCKYXBG.js

@@ -0,0 +1,199 @@
+// ../plugin-core/src/upload.ts
+import { readdir, readFile, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+
+// ../plugin-core/src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../plugin-core/src/upload.ts
+var DEFAULT_MAX_FILE_BYTES = 50 * 1024 * 1024;
+var DEFAULT_MAX_BATCH_BYTES = 100 * 1024 * 1024;
+function hasDebugId(content) {
+  if (!content.includes('"debugId"')) return false;
+  try {
+    const parsed = JSON.parse(content.toString("utf-8"));
+    return isJsonObject(parsed) && typeof parsed["debugId"] === "string";
+  } catch {
+    return false;
+  }
+}
+function batchBySize(entries, maxBatchBytes) {
+  const batches = [];
+  let current = [];
+  let currentBytes = 0;
+  for (const entry of entries) {
+    if (current.length > 0 && currentBytes + entry.byteLength > maxBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 0;
+    }
+    current.push(entry);
+    currentBytes += entry.byteLength;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+async function deleteMapFiles(directory, mapFiles) {
+  const results = await Promise.allSettled(
+    mapFiles.map((mapFile) => unlink(join(directory, mapFile)))
+  );
+  const failures = results.filter((r) => r.status === "rejected");
+  if (failures.length > 0) {
+    console.warn(
+      `[ObserverKit] Failed to delete ${failures.length}/${mapFiles.length} .map files`
+    );
+  }
+  console.log(
+    `[ObserverKit] Deleted ${mapFiles.length - failures.length} .map files from output`
+  );
+}
+async function uploadBatch(batch, options) {
+  const formData = new FormData();
+  for (const [index, entry] of batch.entries()) {
+    const content = await readFile(join(options.directory, entry.mapFile));
+    formData.append(
+      `file-${index}`,
+      new Blob([new Uint8Array(content)], { type: "application/json" }),
+      entry.mapFile
+    );
+  }
+  const response = await fetch(options.url, {
+    method: "POST",
+    headers: {
+      "X-ObserverKit-Key": options.projectKey,
+      "X-ObserverKit-Plugin-Version": options.pluginVersion,
+      "X-ObserverKit-Plugin-Name": options.pluginName
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(
+      `[ObserverKit] Source map upload failed: ${response.status} ${text}`
+    );
+  }
+}
+var JS_SOURCE_MAPPING_URL = /^\/\/[#@] sourceMappingURL=\S+[ \t]*$/gm;
+var CSS_SOURCE_MAPPING_URL = /^\/\*# sourceMappingURL=\S+[ \t]*\*\/[ \t]*$/gm;
+function isChunkFile(name) {
+  return name.endsWith(".js") || name.endsWith(".mjs") || name.endsWith(".cjs") || name.endsWith(".css");
+}
+async function stripSourceMappingUrls(directory, files) {
+  let stripped = 0;
+  for (const file of files.filter(isChunkFile)) {
+    const path = join(directory, file);
+    try {
+      const content = await readFile(path, "utf-8");
+      if (!content.includes("sourceMappingURL=")) continue;
+      const next = content.replace(JS_SOURCE_MAPPING_URL, "").replace(CSS_SOURCE_MAPPING_URL, "");
+      if (next !== content) {
+        await writeFile(path, next);
+        stripped += 1;
+      }
+    } catch {
+    }
+  }
+  if (stripped > 0) {
+    console.log(
+      `[ObserverKit] Stripped sourceMappingURL comments from ${stripped} file(s)`
+    );
+  }
+}
+async function uploadSourceMaps(options) {
+  const { projectKey, directory, endpoint, deleteAfterUpload, pluginVersion, pluginName } = options;
+  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  const maxBatchBytes = options.maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES;
+  const allFiles = options.files ? [...options.files] : await readdir(directory, { recursive: true, encoding: "utf-8" });
+  const allMapFiles = allFiles.filter((f) => f.endsWith(".map"));
+  if (allMapFiles.length === 0) {
+    console.log("[ObserverKit] No .map files found, skipping source map upload");
+    return;
+  }
+  try {
+    const uploadable = [];
+    let skippedNoDebugId = 0;
+    let skippedOversize = 0;
+    let skippedUnreadable = 0;
+    for (const mapFile of allMapFiles) {
+      let content;
+      try {
+        content = await readFile(join(directory, mapFile));
+      } catch {
+        skippedUnreadable += 1;
+        continue;
+      }
+      if (!hasDebugId(content)) {
+        skippedNoDebugId += 1;
+        continue;
+      }
+      if (content.byteLength > maxFileBytes) {
+        skippedOversize += 1;
+        continue;
+      }
+      uploadable.push({ mapFile, byteLength: content.byteLength });
+    }
+    if (skippedNoDebugId > 0) {
+      console.log(
+        `[ObserverKit] Skipping ${skippedNoDebugId} source map(s) without a debugId field`
+      );
+    }
+    if (skippedOversize > 0) {
+      console.warn(
+        `[ObserverKit] Skipping ${skippedOversize} source map(s) over the per-file ingest limit`
+      );
+    }
+    if (skippedUnreadable > 0) {
+      console.warn(
+        `[ObserverKit] Skipping ${skippedUnreadable} unreadable source map(s)`
+      );
+    }
+    if (uploadable.length === 0) {
+      console.log(
+        "[ObserverKit] No uploadable source maps found, skipping upload"
+      );
+      return;
+    }
+    const url = `${endpoint.replace(/\/+$/, "")}/v1/sourcemaps`;
+    const batches = batchBySize(uploadable, maxBatchBytes);
+    for (const [index, batch] of batches.entries()) {
+      await uploadBatch(batch, { directory, url, projectKey, pluginVersion, pluginName });
+      console.log(
+        `[ObserverKit] Uploaded batch ${index + 1}/${batches.length} (${batch.length} source maps)`
+      );
+    }
+  } catch (err) {
+    if (deleteAfterUpload) {
+      console.warn(
+        "[ObserverKit] Upload failed \u2014 deleting .map files anyway so they don't ship (set deleteAfterUpload: false to keep them)"
+      );
+    }
+    throw err;
+  } finally {
+    if (deleteAfterUpload) {
+      await deleteMapFiles(directory, allMapFiles);
+      await stripSourceMappingUrls(directory, allFiles);
+    }
+  }
+}
+
+// ../plugin-core/src/debug-id.ts
+import { v5 } from "uuid";
+var OBSERVERKIT_NAMESPACE = "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d";
+function generateDebugId(content) {
+  return v5(content, OBSERVERKIT_NAMESPACE);
+}
+
+// ../plugin-core/src/snippet.ts
+function buildStackKeyedDebugIdSnippet(debugId) {
+  const snippet = `globalThis._debugIds = globalThis._debugIds || {}; try { globalThis._debugIds[new Error().stack] = ${JSON.stringify(debugId)}; } catch (e) {}`;
+  return { snippet, lineCount: 1 };
+}
+
+export {
+  generateDebugId,
+  isJsonObject,
+  buildStackKeyedDebugIdSnippet,
+  uploadSourceMaps
+};

package/dist/cli.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+"use strict"; function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk6RJOM2COcjs = require('./chunk-6RJOM2CO.cjs');
+require('./chunk-AUOVSTQX.cjs');
+
+// src/cli.ts
+var _util = require('util');
+var _path = require('path');
+
+// src/repair.ts
+var _promises = require('fs/promises');
+var DEBUG_ID_COMMENT_PATTERN = /\/\/# debugId=([0-9a-f-]{36})/;
+function defaultPackagerMapPath(mapPath) {
+  return mapPath.endsWith(".map") ? `${mapPath.slice(0, -".map".length)}.packager.map` : `${mapPath}.packager.map`;
+}
+function defaultBundlePath(mapPath) {
+  return mapPath.endsWith(".map") ? mapPath.slice(0, -".map".length) : mapPath;
+}
+async function readDebugIdFromMap(path) {
+  let content;
+  try {
+    content = await _promises.readFile.call(void 0, path, "utf-8");
+  } catch (e) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (e2) {
+    return null;
+  }
+  if (!_chunk6RJOM2COcjs.isJsonObject.call(void 0, parsed)) return null;
+  return typeof parsed["debugId"] === "string" ? parsed["debugId"] : null;
+}
+async function readDebugIdFromBundle(path) {
+  let content;
+  try {
+    content = await _promises.readFile.call(void 0, path, "utf-8");
+  } catch (e3) {
+    return null;
+  }
+  const match = DEBUG_ID_COMMENT_PATTERN.exec(content);
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _ => _[1]]), () => ( null));
+}
+async function repairDebugId(mapPath, packagerMapPath, bundlePath) {
+  const content = await _promises.readFile.call(void 0, mapPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (e4) {
+    throw new Error(`[ObserverKit] ${mapPath} is not valid JSON`);
+  }
+  if (!_chunk6RJOM2COcjs.isJsonObject.call(void 0, parsed)) {
+    throw new Error(`[ObserverKit] ${mapPath} is not a source map object`);
+  }
+  if (typeof parsed["debugId"] === "string") return;
+  const packagerCandidate = _nullishCoalesce(packagerMapPath, () => ( defaultPackagerMapPath(mapPath)));
+  let debugId = await readDebugIdFromMap(packagerCandidate);
+  const bundleCandidate = _nullishCoalesce(bundlePath, () => ( defaultBundlePath(mapPath)));
+  if (!debugId) {
+    debugId = await readDebugIdFromBundle(bundleCandidate);
+  }
+  if (!debugId) {
+    throw new Error(
+      `[ObserverKit] ${mapPath} has no debugId and none was found in ${packagerCandidate} or ${bundleCandidate}. Is withObserverkit applied in metro.config.js? For Hermes iOS builds, pass --bundle pointing at the pre-Hermes JS bundle (e.g. $CONFIGURATION_BUILD_DIR/main.jsbundle).`
+    );
+  }
+  await _promises.writeFile.call(void 0, mapPath, JSON.stringify({ ...parsed, debugId }));
+}
+
+// src/cli.ts
+var PLUGIN_VERSION = "0.2.0";
+var USAGE = `Usage:
+  observerkit-upload --map <path> [--packager-map <path>] [--bundle <path>]
+  observerkit-upload --dir <path>
+
+Options:
+  --map <path>           Final source map to upload (repairs debugId first)
+  --packager-map <path>  Pre-compose Metro map to copy the debugId from
+  --bundle <path>        Pre-Hermes JS bundle to read a trailing
+                         "//# debugId=<uuid>" comment from, used when no
+                         packager map is available (Hermes iOS builds)
+  --dir <path>           Upload every debug-id source map in a directory
+                         (e.g. an expo export output)
+  --project-key <key>    Defaults to $OBSERVERKIT_PROJECT_KEY
+  --endpoint <url>       Defaults to $OBSERVERKIT_ENDPOINT or
+                         https://ingest.observerkit.com`;
+async function main() {
+  const { values } = _util.parseArgs.call(void 0, {
+    options: {
+      map: { type: "string" },
+      "packager-map": { type: "string" },
+      bundle: { type: "string" },
+      dir: { type: "string" },
+      "project-key": { type: "string" },
+      endpoint: { type: "string" }
+    }
+  });
+  const projectKey = _nullishCoalesce(values["project-key"], () => ( process.env["OBSERVERKIT_PROJECT_KEY"]));
+  if (!projectKey) {
+    console.error(
+      "[ObserverKit] Missing project key: pass --project-key or set OBSERVERKIT_PROJECT_KEY"
+    );
+    process.exit(1);
+  }
+  const endpoint = _nullishCoalesce(_nullishCoalesce(values.endpoint, () => ( process.env["OBSERVERKIT_ENDPOINT"])), () => ( "https://ingest.observerkit.com"));
+  if (!values.map && !values.dir) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+  if (values.dir && (values["packager-map"] || values.bundle)) {
+    console.error(
+      "[ObserverKit] --packager-map and --bundle are ignored when --dir is set"
+    );
+  }
+  if (values.map) {
+    if (!values.map.endsWith(".map")) {
+      console.error(`[ObserverKit] --map must point at a .map file, got "${values.map}"`);
+      process.exit(1);
+    }
+    const mapPath = _path.resolve.call(void 0, values.map);
+    const packagerMap = values["packager-map"];
+    const bundle = values.bundle;
+    await repairDebugId(
+      mapPath,
+      packagerMap ? _path.resolve.call(void 0, packagerMap) : void 0,
+      bundle ? _path.resolve.call(void 0, bundle) : void 0
+    );
+    await _chunk6RJOM2COcjs.uploadSourceMaps.call(void 0, {
+      projectKey,
+      directory: _path.dirname.call(void 0, mapPath),
+      endpoint,
+      deleteAfterUpload: false,
+      pluginVersion: PLUGIN_VERSION,
+      pluginName: "metro",
+      files: [_path.basename.call(void 0, mapPath)]
+    });
+    return;
+  }
+  if (values.dir) {
+    await _chunk6RJOM2COcjs.uploadSourceMaps.call(void 0, {
+      projectKey,
+      directory: _path.resolve.call(void 0, values.dir),
+      endpoint,
+      deleteAfterUpload: false,
+      pluginVersion: PLUGIN_VERSION,
+      pluginName: "metro"
+    });
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node