bitfab 0.52.3 → 0.52.5

package/dist/{chunk-EAET3MSX.js → chunk-EMRHO6YW.js}

@@ -8,13 +8,15 @@ import {
 } from "./chunk-ZUD7OFYB.js";
 import {
   NO_MOCK_OVERRIDE,
+  deserializeInputs,
   deserializeValue,
+  gitRunner,
   randomUuid,
   resolveMockValue,
   serializeValue,
   toJsonSafe,
   toJsonSafeReport
-} from "./chunk-NZGYJWHY.js";
+} from "./chunk-6DRFQJ75.js";
 import {
   BitfabError,
   DEFAULT_SERVICE_URL,
@@ -22,10 +24,11 @@ import {
   MixedTracingError,
   callerTraceMetadata,
   getReplayContext,
+  readEnv,
   recordCallerTraceMetadata,
   retireTraceMetadata,
   warnOnce
-} from "./chunk-XRSOWDOP.js";
+} from "./chunk-CAE7HE4C.js";
 import {
   __privateAdd,
   __privateGet,
@@ -1016,24 +1019,237 @@ 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
+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/datasets.ts
 var DEFAULT_RERUN_TIMEOUT_MS = 9e4;
 var DEFAULT_RERUN_POLL_INTERVAL_MS = 1e3;
@@ -1511,11 +1727,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;
       }
@@ -2947,7 +3163,7 @@ function getCurrentTrace() {
     }
   };
 }
-function readEnv(name) {
+function readEnv2(name) {
   if (typeof process !== "undefined" && process.env) {
     return process.env[name];
   }
@@ -2994,6 +3210,7 @@ var Bitfab = class {
       validateDbSnapshotConfig(config.dbSnapshot);
     }
     this.dbSnapshot = config.dbSnapshot;
+    startCommitRefResolution();
     this.httpClient = new HttpClient({
       apiKey: () => this.resolveApiKey(),
       serviceUrl: this.serviceUrl,
@@ -3329,7 +3546,7 @@ var Bitfab = class {
       return this.resolvedApiKey;
     }
     const fromConfig = typeof this.apiKeyConfig === "function" ? this.apiKeyConfig() : this.apiKeyConfig;
-    const candidate = fromConfig && fromConfig.trim() !== "" ? fromConfig : readEnv("BITFAB_API_KEY");
+    const candidate = fromConfig && fromConfig.trim() !== "" ? fromConfig : readEnv2("BITFAB_API_KEY");
     const key = candidate && candidate.trim() !== "" ? candidate : void 0;
     if (key) {
       this.resolvedApiKey = key;
@@ -4087,15 +4304,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(
@@ -4331,6 +4548,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;
     }
@@ -4576,7 +4797,7 @@ var Bitfab = class {
       await runWithSeedContext({ traceId }, async () => target(...args));
     } finally {
       try {
-        const { flushTraces: flushTraces2 } = await import("./http-HSNLZMNZ.js");
+        const { flushTraces: flushTraces2 } = await import("./http-Q6UEKZRF.js");
         await flushTraces2(3e4);
       } finally {
         unrecorded = activeTraceStates.delete(traceId);
@@ -4590,6 +4811,36 @@ var Bitfab = class {
     }
     return traceId;
   }
+  async reseedTrace(traceFunctionKey, fn, options) {
+    const source = await this.httpClient.getReseedSource(options.traceId);
+    if (source.traceFunctionKey !== traceFunctionKey) {
+      throw new BitfabError(
+        `Trace ${options.traceId} belongs to '${source.traceFunctionKey}', not '${traceFunctionKey}'.`
+      );
+    }
+    const args = deserializeInputs({
+      input: source.input,
+      input_meta: source.inputMeta
+    });
+    const runTraceId = await this.seedTraceByRunning(
+      traceFunctionKey,
+      fn,
+      {
+        args,
+        metadata: source.metadata,
+        ...source.sessionId === null ? {} : { sessionId: source.sessionId },
+        ...source.name === null ? {} : { name: source.name }
+      }
+    );
+    const adopted = await this.httpClient.reseedTrace(
+      options.traceId,
+      runTraceId
+    );
+    return {
+      traceId: adopted.traceId,
+      previousRunTraceId: adopted.previousRunTraceId
+    };
+  }
   async replay(traceFunctionKey, fn, options) {
     const wrappedKey = fn._bitfabTraceFunctionKey;
     let replayFn = fn;
@@ -4605,7 +4856,7 @@ var Bitfab = class {
         `Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`
       );
     }
-    const { replay: doReplay } = await import("./replay-QMA2K5M4.js");
+    const { replay: doReplay } = await import("./replay-UVSZFZW7.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -4841,6 +5092,24 @@ var finalizers = {
 function defineReplayRegistry(registry) {
   return registry;
 }
+async function reseedFromRegistry(registry, pipeline, traceIds) {
+  const registration = registry[pipeline];
+  if (registration === void 0) {
+    throw new BitfabError(
+      `Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`
+    );
+  }
+  const traceFunctionKey = resolveTraceFunctionKey(registration);
+  const reseeded = [];
+  for (const traceId of traceIds) {
+    reseeded.push(
+      await registration.client.reseedTrace(traceFunctionKey, registration.fn, {
+        traceId
+      })
+    );
+  }
+  return { pipeline, traceFunctionKey, reseeded };
+}
 async function seedFromRegistry(registry, pipeline, cases, options = {}) {
   const registration = registry[pipeline];
   if (registration === void 0) {
@@ -4871,7 +5140,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
       sessionId: seedCase.sessionId
     })
   );
-  const { flushTraces: flushTraces2 } = await import("./http-HSNLZMNZ.js");
+  const { flushTraces: flushTraces2 } = await import("./http-Q6UEKZRF.js");
   await flushTraces2(3e4);
   return { pipeline, traceFunctionKey, traceIds };
 }
@@ -4905,6 +5174,7 @@ export {
   BitfabFunction,
   finalizers,
   defineReplayRegistry,
+  reseedFromRegistry,
   seedFromRegistry
 };
-//# sourceMappingURL=chunk-EAET3MSX.js.map
+//# sourceMappingURL=chunk-EMRHO6YW.js.map