@bitfab/sdk 0.52.4 → 0.52.5

package/dist/{http-UA54C2J2.js → http-6Y3IQQ2Z.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-MM4A6UWJ.js";
+} from "./chunk-VAIXHJ7O.js";
 export {
   BitfabError,
   HttpClient,
@@ -16,4 +16,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-UA54C2J2.js.map
+//# sourceMappingURL=http-6Y3IQQ2Z.js.map

package/dist/{http-WBNDRQIV.js → http-KZU56HZA.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-OF5GWNGU.js";
+} from "./chunk-IHAB7SPF.js";
 import "./chunk-H6LZRFMN.js";
 export {
   BitfabError,
@@ -17,4 +17,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-WBNDRQIV.js.map
+//# sourceMappingURL=http-KZU56HZA.js.map

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.52.4";
+    __version__ = "0.52.5";
     __packageName__ = "@bitfab/sdk";
   }
 });
@@ -1121,7 +1121,7 @@ var init_otel = __esm({
         if (this.onDelivered === void 0) {
           return;
         }
-        const refs = spans.map((span) => span.ref).filter((ref) => ref !== void 0);
+        const refs = spans.map((span) => span.ref).filter((ref2) => ref2 !== void 0);
         if (refs.length === 0) {
           return;
         }
@@ -1378,9 +1378,9 @@ function parseRetryAfterMs(header) {
   }
   return Math.max(0, at - Date.now());
 }
-function carrierMeta(operation, payload, ref) {
+function carrierMeta(operation, payload, ref2) {
   return {
-    ref,
+    ref: ref2,
     name: carrierName(operation, payload),
     startTime: payloadTimestamp(payload, "started_at"),
     endTime: payloadTimestamp(payload, "ended_at"),
@@ -1625,22 +1625,22 @@ var init_http = __esm({
         return reports;
       }
       /** Build a carrier's meta and record what it adds to its trace's expected set. */
-      recordedMeta(operation, payload, ref) {
-        this.recordSubmittedCarrier(ref);
-        return carrierMeta(operation, payload, ref);
+      recordedMeta(operation, payload, ref2) {
+        this.recordSubmittedCarrier(ref2);
+        return carrierMeta(operation, payload, ref2);
       }
-      recordSubmittedCarrier(ref) {
-        if (ref === void 0) {
+      recordSubmittedCarrier(ref2) {
+        if (ref2 === void 0) {
           return;
         }
-        const delivery = this.traceDeliveries.get(ref.traceId);
+        const delivery = this.traceDeliveries.get(ref2.traceId);
         if (delivery === void 0) {
           return;
         }
-        if (ref.spanId === void 0) {
+        if (ref2.spanId === void 0) {
           delivery.closed = true;
         } else {
-          delivery.submittedSpanIds.add(ref.spanId);
+          delivery.submittedSpanIds.add(ref2.spanId);
         }
       }
       /**
@@ -1666,15 +1666,15 @@ var init_http = __esm({
         }
       }
       recordDeliveredCarriers(refs) {
-        for (const ref of refs) {
-          const delivery = this.traceDeliveries.get(ref.traceId);
+        for (const ref2 of refs) {
+          const delivery = this.traceDeliveries.get(ref2.traceId);
           if (delivery === void 0) {
             continue;
           }
-          if (ref.spanId === void 0) {
+          if (ref2.spanId === void 0) {
             delivery.closingAcked = true;
           } else {
-            delivery.ackedSpanIds.add(ref.spanId);
+            delivery.ackedSpanIds.add(ref2.spanId);
           }
         }
       }
@@ -1704,9 +1704,9 @@ var init_http = __esm({
        */
       async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
         const deadline = Date.now() + Math.max(timeoutMs, 0);
-        const settled = await this.settleDeferredWork(timeoutMs);
+        const settled2 = await this.settleDeferredWork(timeoutMs);
         const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
-        return settled && flushed;
+        return settled2 && flushed;
       }
       /**
        * Flush and permanently close this client's tracing transport. Idempotent:
@@ -1719,14 +1719,14 @@ var init_http = __esm({
         }
         const deadline = Date.now() + Math.max(timeoutMs, 0);
         this.closing = (async () => {
-          const settled = await this.settleDeferredWork(
+          const settled2 = await this.settleDeferredWork(
             Math.max(0, deadline - Date.now())
           );
           this.closed = true;
           const transport = this.traceTransport;
           this.traceTransport = void 0;
           const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-          return settled && shutdownOk;
+          return settled2 && shutdownOk;
         })();
         return this.closing;
       }
@@ -2337,6 +2337,112 @@ var init_randomUuid = __esm({
   }
 });
 
+// src/gitCommand.ts
+function isUnrefable(value) {
+  return typeof value === "object" && value !== null && "unref" in value && typeof value.unref === "function";
+}
+function unrefStream(stream) {
+  if (isUnrefable(stream)) {
+    stream.unref();
+  }
+}
+function terminate(child) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+      child.kill("SIGTERM");
+      return;
+    }
+  }
+  child.kill("SIGTERM");
+}
+async function gitRunner(options) {
+  let spawn;
+  try {
+    ;
+    ({ spawn } = await import("child_process"));
+  } catch {
+    return null;
+  }
+  return (dir, args) => new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn("git", args, {
+        cwd: dir,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const chunks = [];
+    let size = 0;
+    let overflow = false;
+    let exitCode = null;
+    let done = false;
+    const timers = [];
+    const schedule = (callback, ms) => {
+      const timer = setTimeout(callback, ms);
+      if (!options.keepProcessAlive) {
+        timer.unref();
+      }
+      timers.push(timer);
+    };
+    const finish = () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      for (const timer of timers) {
+        clearTimeout(timer);
+      }
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve(
+        exitCode === 0 && !overflow ? Buffer.concat(chunks).toString("utf8") : null
+      );
+    };
+    child.stdout?.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > options.maxBuffer) {
+        overflow = true;
+        terminate(child);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stderr?.resume();
+    child.on("error", () => {
+      exitCode = null;
+      finish();
+    });
+    child.on("exit", (code) => {
+      exitCode = code;
+      schedule(finish, EXIT_GRACE_MS);
+    });
+    child.on("close", (code) => {
+      exitCode = code ?? exitCode;
+      finish();
+    });
+    schedule(() => terminate(child), options.timeoutMs);
+    if (!options.keepProcessAlive) {
+      child.unref();
+      unrefStream(child.stdout);
+      unrefStream(child.stderr);
+    }
+  });
+}
+var EXIT_GRACE_MS;
+var init_gitCommand = __esm({
+  "src/gitCommand.ts"() {
+    "use strict";
+    EXIT_GRACE_MS = 500;
+  }
+});
+
 // src/mockOverride.ts
 function resolveMockValue(value, ctx) {
   return typeof value === "function" ? value(ctx) : value;
@@ -2393,37 +2499,33 @@ async function readCodeChangeFile() {
   }
 }
 async function captureCodeChangeFromGit(cwd, label) {
-  let execFile;
   let readFile;
   try {
     ;
-    ({ execFile } = await import("child_process"));
     ({ readFile } = await import("fs/promises"));
   } catch {
     return null;
   }
-  const git = (dir, args) => new Promise((resolve) => {
-    execFile(
-      "git",
-      args,
-      // 30s timeout so a hung git (e.g. a network-touching ref op) can't
-      // block the whole replay indefinitely.
-      { cwd: dir, maxBuffer: 64 * 1024 * 1024, timeout: 3e4 },
-      (err, stdout) => resolve(err ? null : stdout)
-    );
+  const git = await gitRunner({
+    timeoutMs: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    keepProcessAlive: true
   });
+  if (!git) {
+    return null;
+  }
   try {
     const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
     if (!root) {
       return null;
     }
-    const resolved = await resolveBase(git, root);
-    if (!resolved) {
+    const resolved2 = await resolveBase(git, root);
+    if (!resolved2) {
       return null;
     }
-    const { base, fromTrunk } = resolved;
-    const blobBytes = async (ref, path) => {
-      const out = await git(root, ["cat-file", "-s", `${ref}:${path}`]);
+    const { base, fromTrunk } = resolved2;
+    const blobBytes = async (ref2, path) => {
+      const out = await git(root, ["cat-file", "-s", `${ref2}:${path}`]);
       const n = out ? Number.parseInt(out.trim(), 10) : Number.NaN;
       return Number.isFinite(n) ? n : 0;
     };
@@ -2515,8 +2617,8 @@ async function resolveBase(git, root) {
   }
   return await refExists(git, root, "HEAD") ? { base: "HEAD", fromTrunk: false } : null;
 }
-async function refExists(git, root, ref) {
-  return await git(root, ["rev-parse", "--verify", `${ref}^{object}`]) !== null;
+async function refExists(git, root, ref2) {
+  return await git(root, ["rev-parse", "--verify", `${ref2}^{object}`]) !== null;
 }
 async function readWorkingFile(readFile, root, path) {
   try {
@@ -2551,6 +2653,7 @@ var MAX_FILES, MAX_FILE_BYTES, MAX_TOTAL_BYTES, TRUNK_CANDIDATES, NUL;
 var init_codeChange = __esm({
   "src/codeChange.ts"() {
     "use strict";
+    init_gitCommand();
     MAX_FILES = 60;
     MAX_FILE_BYTES = 5e5;
     MAX_TOTAL_BYTES = 2e6;
@@ -2755,9 +2858,9 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
     if (includeDbBranchLease && !lease && !leaseError) {
-      let resolved;
+      let resolved2;
       try {
-        resolved = await httpClient.resolveDbBranchLease(
+        resolved2 = await httpClient.resolveDbBranchLease(
           testRunId,
           originalTraceId,
           dbBranchSettings,
@@ -2771,10 +2874,10 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
           cause
         );
       }
-      lease = resolved.lease ?? void 0;
-      leaseError = resolved.leaseError ?? void 0;
-      dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
-      dbBranchTimings = resolved.timings ?? dbBranchTimings;
+      lease = resolved2.lease ?? void 0;
+      leaseError = resolved2.leaseError ?? void 0;
+      dbSnapshotRef = resolved2.dbSnapshotRef ?? dbSnapshotRef;
+      dbBranchTimings = resolved2.timings ?? dbBranchTimings;
     }
     if (leaseError) {
       throw new DbBranchReplayError(
@@ -4550,24 +4653,239 @@ function mixedTracingError(enteredApi, entered, enclosing, traceFunctionKey) {
     `opt-in and opt-out tracing can't be mixed in one call stack: ${enteredApi} (${entered})${subject} was entered inside a ${SURFACE_API[enclosing]} call (${enclosing}). ${MIXED_SURFACE_REMEDY[entered]}`
   );
 }
-function assertSurfacesCompatible(requested, resolved, parentSurface, traceFunctionKey) {
+function assertSurfacesCompatible(requested, resolved2, parentSurface, traceFunctionKey) {
   if (requested === "inherit" || requested === "neutral") {
     return;
   }
-  if (resolved === void 0 || parentSurface === void 0) {
+  if (resolved2 === void 0 || parentSurface === void 0) {
     return;
   }
-  if (parentSurface === resolved) {
+  if (parentSurface === resolved2) {
     return;
   }
   throw mixedTracingError(
-    SURFACE_API[resolved],
-    resolved,
+    SURFACE_API[resolved2],
+    resolved2,
     parentSurface,
     traceFunctionKey
   );
 }
 
+// src/commitRef.ts
+init_gitCommand();
+init_readEnv();
+var EXPLICIT_SHA_ENV = "BITFAB_COMMIT_SHA";
+var DISABLE_ENV = "BITFAB_DISABLE_COMMIT_REF";
+var GIT_TIMEOUT_MS = 2e3;
+var GIT_MAX_BUFFER = 1024 * 1024;
+var VERCEL_PROVIDER_HOSTS = {
+  github: "github.com",
+  gitlab: "gitlab.com",
+  bitbucket: "bitbucket.org"
+};
+function read(env, name) {
+  if (name === null) {
+    return null;
+  }
+  const value = env(name)?.trim();
+  return value ? value : null;
+}
+function remoteFrom(...names) {
+  return (env) => {
+    const parts = names.map((name) => read(env, name));
+    if (parts.some((part) => part === null)) {
+      return null;
+    }
+    return normalizeRemote(parts.join("/"));
+  };
+}
+function vercelRemote(env) {
+  const provider = read(env, "VERCEL_GIT_PROVIDER")?.toLowerCase() ?? "";
+  const host = VERCEL_PROVIDER_HOSTS[provider];
+  const owner = read(env, "VERCEL_GIT_REPO_OWNER");
+  const slug = read(env, "VERCEL_GIT_REPO_SLUG");
+  if (!host || !owner || !slug) {
+    return null;
+  }
+  return `${host}/${owner}/${slug}`;
+}
+function noRemote() {
+  return null;
+}
+var PLATFORM_ENVS = [
+  ["VERCEL_GIT_COMMIT_SHA", "VERCEL_GIT_COMMIT_REF", vercelRemote],
+  [
+    "GITHUB_SHA",
+    "GITHUB_REF_NAME",
+    remoteFrom("GITHUB_SERVER_URL", "GITHUB_REPOSITORY")
+  ],
+  ["RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH", noRemote],
+  ["RENDER_GIT_COMMIT", "RENDER_GIT_BRANCH", noRemote],
+  ["SOURCE_VERSION", null, noRemote],
+  ["CF_PAGES_COMMIT_SHA", "CF_PAGES_BRANCH", noRemote],
+  ["CI_COMMIT_SHA", "CI_COMMIT_REF_NAME", remoteFrom("CI_REPOSITORY_URL")],
+  [
+    "BUILD_SOURCEVERSION",
+    "BUILD_SOURCEBRANCHNAME",
+    remoteFrom("BUILD_REPOSITORY_URI")
+  ],
+  ["CIRCLE_SHA1", "CIRCLE_BRANCH", remoteFrom("CIRCLE_REPOSITORY_URL")]
+];
+var COMMIT_REF_ENV_NAMES = [
+  EXPLICIT_SHA_ENV,
+  DISABLE_ENV,
+  ...PLATFORM_ENVS.flatMap(
+    ([sha, branch]) => branch === null ? [sha] : [sha, branch]
+  ),
+  "GITHUB_SERVER_URL",
+  "GITHUB_REPOSITORY",
+  "CI_REPOSITORY_URL",
+  "BUILD_REPOSITORY_URI",
+  "CIRCLE_REPOSITORY_URL",
+  "VERCEL_GIT_PROVIDER",
+  "VERCEL_GIT_REPO_OWNER",
+  "VERCEL_GIT_REPO_SLUG"
+];
+function normalizeRemote(raw) {
+  const value = raw?.trim();
+  if (!value) {
+    return null;
+  }
+  let host = "";
+  let path = value;
+  if (value.includes("://")) {
+    try {
+      const parsed = new URL(value);
+      host = parsed.hostname;
+      path = parsed.pathname;
+    } catch {
+      return null;
+    }
+  } else {
+    const separator = value.indexOf(":");
+    if (separator !== -1) {
+      const head = value.slice(0, separator);
+      host = head.slice(head.lastIndexOf("@") + 1);
+      path = value.slice(separator + 1);
+    }
+  }
+  path = path.replace(/^\/+|\/+$/g, "");
+  if (path.endsWith(".git")) {
+    path = path.slice(0, -".git".length).replace(/\/+$/, "");
+  }
+  if (!host) {
+    return path || null;
+  }
+  return path ? `${host}/${path}` : host;
+}
+function resolveCommitRefFromEnv(env) {
+  const explicit = read(env, EXPLICIT_SHA_ENV);
+  const platform = PLATFORM_ENVS.find(([sha]) => read(env, sha) !== null);
+  if (!platform) {
+    if (explicit === null) {
+      return null;
+    }
+    return {
+      sha: explicit,
+      branch: null,
+      dirty: null,
+      remote: null,
+      rootSha: null
+    };
+  }
+  const [shaEnv, branchEnv, readRemote] = platform;
+  return {
+    sha: explicit ?? read(env, shaEnv),
+    branch: read(env, branchEnv),
+    dirty: null,
+    remote: readRemote(env),
+    rootSha: null
+  };
+}
+async function resolveCommitRefFromGit(cwd) {
+  const git = await gitRunner({
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    keepProcessAlive: false
+  });
+  if (!git) {
+    return null;
+  }
+  const run = async (args) => (await git(cwd, args))?.trim() ?? null;
+  const sha = await run(["rev-parse", "HEAD"]);
+  if (!sha) {
+    return null;
+  }
+  const [branch, status, remote, roots] = await Promise.all([
+    run(["symbolic-ref", "--short", "-q", "HEAD"]),
+    run(["status", "--porcelain"]),
+    run(["remote", "get-url", "origin"]),
+    run(["rev-list", "--max-parents=0", "HEAD"])
+  ]);
+  return {
+    sha,
+    branch: branch || null,
+    dirty: status === null ? null : status.length > 0,
+    remote: normalizeRemote(remote),
+    rootSha: roots ? roots.split(/\s+/).sort()[0] ?? null : null
+  };
+}
+function commitRefWire(ref2) {
+  return {
+    sha: ref2.sha,
+    branch: ref2.branch,
+    dirty: ref2.dirty,
+    remote: ref2.remote,
+    root_sha: ref2.rootSha
+  };
+}
+var resolved = false;
+var ref = null;
+var gitStarted = false;
+var settled = Promise.resolve();
+function startCommitRefResolution() {
+  if (resolved || gitStarted) {
+    return;
+  }
+  if (read(readEnv, DISABLE_ENV) !== null) {
+    resolved = true;
+    return;
+  }
+  const fromEnv = resolveCommitRefFromEnv(readEnv);
+  if (fromEnv) {
+    ref = fromEnv;
+    resolved = true;
+    return;
+  }
+  gitStarted = true;
+  if (typeof process === "undefined") {
+    resolved = true;
+    return;
+  }
+  let cwd;
+  try {
+    cwd = process.cwd?.() ?? ".";
+  } catch {
+    resolved = true;
+    return;
+  }
+  settled = resolveCommitRefFromGit(cwd).then(
+    (fromGit) => {
+      if (!resolved) {
+        ref = fromGit;
+        resolved = true;
+      }
+    },
+    () => {
+      resolved = true;
+    }
+  );
+}
+function currentCommitRef() {
+  startCommitRefResolution();
+  return ref;
+}
+
 // src/client.ts
 init_constants();
 
@@ -5060,11 +5378,11 @@ var BitfabLangGraphCallbackHandler = class {
         this.invocations.set(invocation.rootRunId, invocation);
       }
       if (!willHide) {
-        let resolved = parentSpan;
-        while (resolved?.hidden === true) {
-          resolved = resolved.parentId ? this.runToSpan.get(resolved.parentId) : void 0;
+        let resolved2 = parentSpan;
+        while (resolved2?.hidden === true) {
+          resolved2 = resolved2.parentId ? this.runToSpan.get(resolved2.parentId) : void 0;
         }
-        effectiveParentId = resolved ? resolved.spanId : invocation.activeContext?.spanId ?? null;
+        effectiveParentId = resolved2 ? resolved2.spanId : invocation.activeContext?.spanId ?? null;
       } else {
         effectiveParentId = parentRunId ?? null;
       }
@@ -6564,6 +6882,7 @@ var Bitfab = class {
       validateDbSnapshotConfig(config.dbSnapshot);
     }
     this.dbSnapshot = config.dbSnapshot;
+    startCommitRefResolution();
     this.httpClient = new HttpClient({
       apiKey: () => this.resolveApiKey(),
       serviceUrl: this.serviceUrl,
@@ -7657,15 +7976,15 @@ var Bitfab = class {
                 );
               }
               return runWithSpanStack(newStack, async () => {
-                const resolved = await resolution;
-                if (resolved.matched) {
+                const resolved2 = await resolution;
+                if (resolved2.matched) {
                   void sendSpan({
-                    result: resolved.output,
+                    result: resolved2.output,
                     mocked: true,
                     mockTarget: "output",
                     mockSource: "override"
                   });
-                  return resolved.output;
+                  return resolved2.output;
                 }
                 if (shouldMockWithBaseStrategy && !mockSpan) {
                   throw new BitfabError(
@@ -7901,6 +8220,10 @@ var Bitfab = class {
     if (params.dbSnapshotRef) {
       rawTrace.db_snapshot_ref = params.dbSnapshotRef;
     }
+    const commitRef = currentCommitRef();
+    if (commitRef) {
+      rawTrace.commit_ref = commitRefWire(commitRef);
+    }
     if (params.ingestionType) {
       rawTrace.ingestion_type = params.ingestionType;
     }