bitfab 0.54.0 → 0.54.2

package/dist/{chunk-CLYCJGJE.js → chunk-ELGX3GWC.js}

@@ -94,7 +94,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.54.0";
+var __version__ = "0.54.2";
 var __packageName__ = "bitfab";
 
 // src/errors.ts
@@ -108,6 +108,193 @@ var BitfabError = class extends Error {
   }
 };
 
+// src/gitCommand.ts
+var EXIT_GRACE_MS = 500;
+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, env) => new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn("git", args, {
+        cwd: dir,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"],
+        ...env ? { env: { ...process.env, ...env } } : {}
+      });
+    } 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);
+    }
+  });
+}
+
+// src/gitState.ts
+var GIT_TIMEOUT_MS = 3e4;
+var GIT_MAX_BUFFER = 1024 * 1024;
+var DISABLE_ENV = "BITFAB_DISABLE_GIT_STATE";
+var SHA_PATTERN = /^[0-9a-f]{40}$/;
+function sha(value) {
+  const trimmed = value?.trim();
+  return trimmed && SHA_PATTERN.test(trimmed) ? trimmed : null;
+}
+function text(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function isEmptyGitState(state) {
+  return Object.values(state).every((value) => value === null);
+}
+async function resolveGitState(cwd) {
+  const git = await gitRunner({
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    keepProcessAlive: true
+  });
+  if (!git) {
+    return null;
+  }
+  const run = async (args, env) => (await git(cwd, args, env))?.trim() ?? null;
+  const [refs, email, branch] = await Promise.all([
+    run(["rev-parse", "--show-toplevel", "HEAD", "HEAD^{tree}"]),
+    run(["config", "user.email"]),
+    run(["symbolic-ref", "--short", "-q", "HEAD"])
+  ]);
+  const [root, commitSha, baseSha] = (refs ?? "").split("\n");
+  if (!root) {
+    return null;
+  }
+  const state = {
+    githubEmail: text(email),
+    branch: text(branch),
+    commitSha: sha(commitSha),
+    baseSha: sha(baseSha),
+    experimentSha: await resolveWorkingTreeSha(run, root.trim())
+  };
+  return isEmptyGitState(state) ? null : state;
+}
+async function resolveWorkingTreeSha(run, root) {
+  let indexPath;
+  let cleanup;
+  try {
+    const { mkdtemp, rm } = await import("fs/promises");
+    const { join } = await import("path");
+    const { tmpdir } = await import("os");
+    const dir = await mkdtemp(join(tmpdir(), "bitfab-git-"));
+    indexPath = join(dir, "index");
+    cleanup = () => rm(dir, { recursive: true, force: true });
+  } catch {
+    return null;
+  }
+  try {
+    const env = { GIT_INDEX_FILE: indexPath };
+    if (await run(["read-tree", "HEAD"], env) === null) {
+      return null;
+    }
+    if (await run(["add", "-A", "--", root], env) === null) {
+      return null;
+    }
+    return sha(await run(["write-tree"], env));
+  } catch {
+    return null;
+  } finally {
+    await cleanup().catch(() => {
+    });
+  }
+}
+function resolvedGitState() {
+  if (typeof process === "undefined" || process.env?.[DISABLE_ENV]) {
+    return Promise.resolve(null);
+  }
+  let cwd;
+  try {
+    cwd = process.cwd?.() ?? ".";
+  } catch {
+    return Promise.resolve(null);
+  }
+  return resolveGitState(cwd).catch(() => null);
+}
+
 // src/asyncStorage.ts
 var AsyncLocalStorageClass = null;
 var initDone = false;
@@ -1906,6 +2093,10 @@ var HttpClient = class {
     if (onlyWithAssertions) {
       payload.onlyWithAssertions = true;
     }
+    const git = await resolvedGitState();
+    if (git && !isEmptyGitState(git)) {
+      payload.git = git;
+    }
     const timeout = includeDbBranchLease ? REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS : 3e4;
     return this.request("/api/sdk/replay/start", payload, {
       timeout
@@ -2073,4 +2264,4 @@ export {
   parseRetryAfterMs,
   HttpClient
 };
-//# sourceMappingURL=chunk-CLYCJGJE.js.map
+//# sourceMappingURL=chunk-ELGX3GWC.js.map