@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-YKC75XK4.js

@@ -0,0 +1,147 @@
+// src/telemetry/durable-jsonl.ts
+import fs from "fs";
+import path from "path";
+function fsyncParentDirSync(dirPath) {
+  let dirFd;
+  try {
+    dirFd = fs.openSync(dirPath, "r");
+    fs.fsyncSync(dirFd);
+  } catch (error) {
+    const code = error.code;
+    if (code === "EISDIR" || code === "EINVAL" || code === "EPERM" || code === "ENOTSUP" || code === "EACCES") {
+      return;
+    }
+  } finally {
+    if (dirFd !== void 0) {
+      try {
+        fs.closeSync(dirFd);
+      } catch {
+      }
+    }
+  }
+}
+function appendJsonlDurablySync(filePath, payload) {
+  const parentDir = path.dirname(filePath);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+  const fileIsNew = !fs.existsSync(filePath);
+  const fd = fs.openSync(filePath, "a");
+  try {
+    if (typeof payload === "string") {
+      fs.writeSync(fd, payload, null, "utf-8");
+    } else {
+      fs.writeSync(fd, payload);
+    }
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  if (fileIsNew) {
+    fsyncParentDirSync(parentDir);
+  }
+}
+var LOCK_MAX_WAIT_MS = 5e3;
+var LOCK_RETRY_DELAY_MS = 50;
+var STALE_LOCK_THRESHOLD_MS = 3e4;
+function processExists(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error;
+    return err.code !== "ESRCH";
+  }
+}
+function createPidLockFileSync(lockPath) {
+  const lockFd = fs.openSync(lockPath, "wx");
+  try {
+    fs.writeSync(lockFd, String(process.pid));
+    return lockFd;
+  } catch (error) {
+    try {
+      fs.closeSync(lockFd);
+      fs.unlinkSync(lockPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  const view = new Int32Array(buffer);
+  Atomics.wait(view, 0, 0, ms);
+}
+function appendJsonlWithLockSync(filePath, payload) {
+  const parentDir = path.dirname(filePath);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + LOCK_MAX_WAIT_MS;
+  while (true) {
+    let lockFd;
+    try {
+      lockFd = createPidLockFileSync(lockPath);
+      fsyncParentDirSync(parentDir);
+    } catch (error) {
+      const err = error;
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stats = fs.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
+          try {
+            const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+            const lockPid = Number.parseInt(lockContent, 10);
+            if (Number.isNaN(lockPid) || !processExists(lockPid)) {
+              fs.unlinkSync(lockPath);
+              continue;
+            }
+          } catch {
+            fs.unlinkSync(lockPath);
+            continue;
+          }
+        }
+      } catch (statError) {
+        const statErr = statError;
+        if (statErr.code === "ENOENT") continue;
+      }
+      if (Date.now() >= deadline) {
+        const busy = new Error(`Failed to acquire JSONL lock for ${filePath}: lock already held`);
+        busy.name = "TelemetryLockBusyError";
+        throw busy;
+      }
+      sleepSync(LOCK_RETRY_DELAY_MS);
+      continue;
+    }
+    let appendError;
+    try {
+      appendJsonlDurablySync(filePath, payload);
+    } catch (error) {
+      appendError = error;
+    }
+    try {
+      if (lockFd !== void 0) fs.closeSync(lockFd);
+    } catch {
+    }
+    let unlinkError;
+    try {
+      fs.unlinkSync(lockPath);
+    } catch (error) {
+      const err = error;
+      if (err.code !== "ENOENT") unlinkError = err;
+    }
+    if (appendError) throw appendError;
+    if (unlinkError) throw unlinkError;
+    return;
+  }
+}
+
+export {
+  appendJsonlDurablySync,
+  createPidLockFileSync,
+  sleepSync,
+  appendJsonlWithLockSync
+};
+//# sourceMappingURL=chunk-YKC75XK4.js.map

package/dist/chunk-YKMXFVK7.js

@@ -0,0 +1,27 @@
+// src/core/providers/antigravity/auth.ts
+function hasAntigravityApiKey(env = process.env) {
+  return Boolean(env?.ANTIGRAVITY_API_KEY?.trim());
+}
+async function probeAntigravityAuthState(env) {
+  if (hasAntigravityApiKey(env)) return "yes";
+  return "unknown";
+}
+async function isAuthenticatedTriState(options = {}) {
+  const env = options?.env;
+  return probeAntigravityAuthState(env);
+}
+async function isAuthenticated(options = {}) {
+  const env = options?.env;
+  return await probeAntigravityAuthState(env) !== "no";
+}
+var auth = {
+  isAuthenticated,
+  isAuthenticatedTriState
+};
+
+export {
+  isAuthenticatedTriState,
+  isAuthenticated,
+  auth
+};
+//# sourceMappingURL=chunk-YKMXFVK7.js.map

package/dist/chunk-YO5BAJ55.js

@@ -0,0 +1,225 @@
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  isCommitEligibleStatusEntry,
+  readTrackedToolOutputRoots
+} from "./chunk-5EQN56OZ.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  parsePorcelainRecordsZ
+} from "./chunk-5KQETTNS.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/git/workspace-tree-identity.ts
+import { createHash } from "crypto";
+import { lstat, readFile as readFile2, readlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/core/git/requested-root-markdown.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+var MARKER_NAME = "build-requested-root-markdown.json";
+function extractRequestedRootMarkdown(text) {
+  const names = /* @__PURE__ */ new Set();
+  const pattern = /(?<![\w./\\~-])(?:\.\/)?([A-Za-z0-9][\w.-]*\.md)(?![\w/-])/gi;
+  for (const match of text.matchAll(pattern)) {
+    const name = match[1];
+    if (name) names.add(name.toLowerCase());
+  }
+  return [...names];
+}
+async function markerPath(worktreePath) {
+  try {
+    const result = await execGit(["rev-parse", "--git-path", MARKER_NAME], { cwd: worktreePath });
+    const value = result.exitCode === 0 ? result.stdout.trim() : "";
+    return value ? path.resolve(worktreePath, value) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function recordRequestedRootMarkdown(worktreePath, taskText) {
+  try {
+    const target = await markerPath(worktreePath);
+    if (!target) return;
+    const names = extractRequestedRootMarkdown(taskText);
+    if (names.length === 0) {
+      await rm(target, { force: true });
+      return;
+    }
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, JSON.stringify(names));
+  } catch {
+  }
+}
+async function readRequestedRootMarkdown(worktreePath) {
+  try {
+    const target = await markerPath(worktreePath);
+    if (!target) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(await readFile(target, "utf8"));
+    return new Set(
+      Array.isArray(parsed) ? parsed.filter((n) => typeof n === "string") : []
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/core/git/workspace-tree-identity.ts
+async function partitionOverlayPaths(worktreePath, paths) {
+  const staged = await Promise.all(
+    paths.map(async (relativePath) => {
+      const kind = await lstat(join(worktreePath, relativePath)).then(
+        (stats) => stats.isDirectory() ? "directory" : "entry",
+        (error) => {
+          const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+          if (code === "ENOENT" || code === "ENOTDIR") return "missing";
+          throw error;
+        }
+      );
+      if (kind !== "directory") return kind === "entry";
+      return await lstat(join(worktreePath, relativePath, ".git")).then(
+        () => true,
+        () => false
+      );
+    })
+  );
+  return {
+    stage: paths.filter((_, index) => staged[index]),
+    unstage: paths.filter((_, index) => !staged[index])
+  };
+}
+async function addPathsByNulPathspec(worktreePath, paths, options = {}) {
+  return execGit(
+    [
+      "--literal-pathspecs",
+      "add",
+      "-A",
+      ...options.force ? ["--force"] : [],
+      "--pathspec-from-file=-",
+      "--pathspec-file-nul"
+    ],
+    { cwd: worktreePath, env: options.env, input: `${paths.join("\0")}\0` }
+  );
+}
+async function overlayPathsIntoIndex(worktreePath, paths, env) {
+  const { stage, unstage } = await partitionOverlayPaths(worktreePath, paths);
+  if (unstage.length > 0) {
+    const rm2 = await execGit(
+      [
+        "--literal-pathspecs",
+        "rm",
+        "-q",
+        "--cached",
+        "--ignore-unmatch",
+        "--pathspec-from-file=-",
+        "--pathspec-file-nul"
+      ],
+      { cwd: worktreePath, env, input: `${unstage.join("\0")}\0` }
+    );
+    if (rm2.exitCode !== 0) {
+      throw new Error(rm2.stderr || "could not capture workspace identity removals");
+    }
+  }
+  if (stage.length > 0) {
+    const add = await addPathsByNulPathspec(worktreePath, stage, { force: true, env });
+    if (add.exitCode !== 0) {
+      throw new Error(add.stderr || "could not capture workspace identity contents");
+    }
+  }
+}
+async function captureWorkspaceTreeIdentity(input) {
+  const scratch = await mkBuildTempDir("workspace-tree-identity");
+  const indexPath = join(scratch, "index");
+  const env = { GIT_INDEX_FILE: indexPath };
+  try {
+    const readTree = await execGit(["read-tree", input.headSha], {
+      cwd: input.worktreePath,
+      env
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(readTree.stderr || "could not seed workspace identity index");
+    }
+    await overlayPathsIntoIndex(input.worktreePath, input.changedPaths, env);
+    const tree = await execGit(["write-tree"], { cwd: input.worktreePath, env });
+    if (tree.exitCode !== 0 || !tree.stdout.trim()) {
+      throw new Error(tree.stderr || "could not write workspace identity tree");
+    }
+    return tree.stdout.trim();
+  } finally {
+    await safeRmDir(scratch, {
+      protectedPaths: [tmpdir()],
+      managedRoots: [tmpdir()]
+    });
+  }
+}
+async function captureCurrentWorkspaceTreeIdentity(worktreePath) {
+  const [head, status, trackedRoots, requestedRootMarkdown] = await Promise.all([
+    execGit(["rev-parse", "HEAD"], { cwd: worktreePath }),
+    execGit(["status", "--porcelain=v1", "--untracked-files=all", "-z"], { cwd: worktreePath }),
+    readTrackedToolOutputRoots(worktreePath),
+    readRequestedRootMarkdown(worktreePath)
+  ]);
+  const headSha = head.stdout.trim();
+  if (head.exitCode !== 0 || !headSha || status.exitCode !== 0) {
+    throw new Error(head.stderr || status.stderr || "workspace identity inputs unavailable");
+  }
+  const changedPaths = parsePorcelainRecordsZ(status.stdout).filter(
+    (record) => isCommitEligibleStatusEntry(
+      {
+        path: record.path,
+        originalPath: record.originalPath,
+        indexStatus: record.status[0] ?? " ",
+        worktreeStatus: record.status[1] ?? " "
+      },
+      trackedRoots,
+      requestedRootMarkdown
+    )
+  ).flatMap(
+    (record) => record.originalPath ? [record.path, record.originalPath] : [record.path]
+  );
+  return await captureWorkspaceTreeIdentity({ worktreePath, headSha, changedPaths });
+}
+async function fingerprintPathState(worktreePath, relativePath) {
+  const absolutePath = join(worktreePath, relativePath);
+  try {
+    const stats = await lstat(absolutePath);
+    const hash = createHash("sha256");
+    const executable = (stats.mode & 73) !== 0 ? "executable" : "regular";
+    if (stats.isSymbolicLink()) {
+      hash.update("symlink\0").update(await readlink(absolutePath));
+    } else if (stats.isFile()) {
+      hash.update(`file:${executable}\0`).update(await readFile2(absolutePath));
+    } else if (stats.isDirectory()) {
+      const nestedHead = await execGit(["rev-parse", "HEAD"], { cwd: absolutePath }).catch(
+        () => void 0
+      );
+      hash.update("directory\0").update(nestedHead?.exitCode === 0 ? nestedHead.stdout.trim() : "unresolved");
+    } else {
+      hash.update(`other:${stats.mode}\0`);
+    }
+    return hash.digest("hex");
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return "missing";
+    }
+    throw error;
+  }
+}
+
+export {
+  recordRequestedRootMarkdown,
+  readRequestedRootMarkdown,
+  addPathsByNulPathspec,
+  overlayPathsIntoIndex,
+  captureWorkspaceTreeIdentity,
+  captureCurrentWorkspaceTreeIdentity,
+  fingerprintPathState
+};
+//# sourceMappingURL=chunk-YO5BAJ55.js.map