@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-BD3PGW6A.js

@@ -0,0 +1,957 @@
+import {
+  INHERITED_AGENTS_DIRNAME,
+  INHERITED_INSTRUCTIONS_FILENAME,
+  INHERITED_SKILLS_DIRNAME,
+  INHERITED_STEERING_DIRNAME,
+  deliversBuildSet,
+  hasInheritanceDecision,
+  includesAgentGlobals,
+  readInheritanceDir,
+  readLaunchInheritance
+} from "./chunk-43OKHTW4.js";
+import {
+  expandHomeDir
+} from "./chunk-MNOVBYFU.js";
+import {
+  byteLength,
+  sha256Text
+} from "./chunk-RIMARPCF.js";
+import {
+  getDefaultPaths,
+  getStateDir
+} from "./chunk-56WPYDJH.js";
+import {
+  BUILD_CODEX_ISOLATE_HOME,
+  BUILD_WORKTREE,
+  getRuntimeEnv,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/inheritance-delivery.ts
+import { createHash } from "crypto";
+import {
+  appendFileSync,
+  existsSync,
+  lstatSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  readlinkSync,
+  realpathSync
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/core/steering/skills-index.ts
+import { readdirSync, readFileSync } from "fs";
+import { basename, dirname, join } from "path";
+
+// src/core/steering/front-matter.ts
+import { parse as parseYaml } from "yaml";
+var FRONT_MATTER = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+function readFrontMatter(text) {
+  const block = FRONT_MATTER.exec(text)?.[1];
+  if (!block) return {};
+  try {
+    const parsed = parseYaml(block);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function stripFrontMatter(text) {
+  return text.replace(FRONT_MATTER, "");
+}
+function oneLine(value) {
+  return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+}
+
+// src/core/steering/skills-index.ts
+var SKILLS_INDEX_INTRO = "Skills from Build. Each line names a skill, says when to use it, and gives the path of its SKILL.md. When a task matches a skill, read that file and follow it; files it mentions are in the same folder.";
+function readDeliveredSkillFiles(inheritanceDir) {
+  const skillsDir = join(inheritanceDir, INHERITED_SKILLS_DIRNAME);
+  let names;
+  try {
+    names = readdirSync(skillsDir).sort();
+  } catch {
+    return [];
+  }
+  return names.flatMap((name) => {
+    const path3 = join(skillsDir, name, "SKILL.md");
+    try {
+      return [{ path: path3, text: readFileSync(path3, "utf8") }];
+    } catch {
+      return [];
+    }
+  });
+}
+function buildSkillsIndexText(skills) {
+  const lines = skills.map((skill) => {
+    const fields = readFrontMatter(skill.text);
+    const name = oneLine(fields.name) || basename(dirname(skill.path));
+    const description = oneLine(fields.description);
+    return `- ${name}${description ? `: ${description}` : ""} (file: ${skill.path})`;
+  }).sort((a, b) => a.localeCompare(b));
+  return lines.length > 0 ? `${SKILLS_INDEX_INTRO}
+${lines.join("\n")}
+` : "";
+}
+
+// src/core/providers/inheritance-delivery.ts
+var INHERITED_DELIVERIES_FILENAME = "delivered.jsonl";
+var INHERITED_SOURCES_FILENAME = "sources.json";
+var KINDS = ["instructions", "skills", "agents", "steering"];
+var COVERAGES = ["full", "partial", "none"];
+var SOURCE_KINDS = ["floor", "user-global", "project"];
+var KIND_DIRNAMES = {
+  skills: INHERITED_SKILLS_DIRNAME,
+  agents: INHERITED_AGENTS_DIRNAME,
+  steering: INHERITED_STEERING_DIRNAME
+};
+function recordInheritedDelivery(inheritanceDir, entry) {
+  if (!inheritanceDir) return;
+  try {
+    appendFileSync(
+      join2(inheritanceDir, INHERITED_DELIVERIES_FILENAME),
+      `${JSON.stringify(entry)}
+`
+    );
+  } catch {
+  }
+}
+function readTreeFiles(dir, prefix, files) {
+  const walk = (relative) => {
+    const full = relative ? join2(dir, relative) : dir;
+    const stat4 = lstatSync(full);
+    if (stat4.isDirectory()) {
+      for (const name of readdirSync2(full)) walk(relative ? `${relative}/${name}` : name);
+    } else {
+      files.push([
+        prefix && relative ? `${prefix}/${relative}` : prefix || relative,
+        stat4.isSymbolicLink() ? Buffer.from(readlinkSync(full)) : readFileSync2(full)
+      ]);
+    }
+  };
+  walk("");
+}
+function fingerprintFiles(files) {
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for (const [relative, content] of files.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    hash.update(`${relative}\0${content.length}\0`).update(content);
+    bytes += content.length;
+  }
+  return { sha256: hash.digest("hex"), bytes };
+}
+function fingerprintDeliveredTree(dir) {
+  const files = [];
+  try {
+    readTreeFiles(dir, "", files);
+  } catch {
+    return void 0;
+  }
+  return files.length > 0 ? fingerprintFiles(files) : void 0;
+}
+function fingerprintInheritedSet(setText, layout) {
+  const files = [[INHERITED_INSTRUCTIONS_FILENAME, Buffer.from(setText)]];
+  for (const skill of layout.skills) {
+    const folder = realpathSync(dirname2(skill.path));
+    readTreeFiles(folder, `${INHERITED_SKILLS_DIRNAME}/${skill.name}`, files);
+  }
+  for (const [folder, entries] of [
+    [INHERITED_AGENTS_DIRNAME, layout.agents],
+    [INHERITED_STEERING_DIRNAME, layout.steering]
+  ]) {
+    for (const entry of entries)
+      files.push([`${folder}/${entry.name}.md`, readFileSync2(entry.path)]);
+  }
+  return fingerprintFiles(files).sha256;
+}
+function isSteeringSource(value) {
+  if (!value || typeof value !== "object") return false;
+  const source = value;
+  return SOURCE_KINDS.includes(source.kind) && typeof source.sha256 === "string" && typeof source.bytes === "number" && (source.path === void 0 || typeof source.path === "string");
+}
+function readInheritedSources(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync2(join2(dir, INHERITED_SOURCES_FILENAME), "utf8"));
+    return Array.isArray(parsed) ? parsed.filter(isSteeringSource) : [];
+  } catch {
+    return [];
+  }
+}
+function readInheritedSet(env) {
+  const launch = readLaunchInheritance(env);
+  const dir = deliversBuildSet(launch) ? readInheritanceDir(env) : void 0;
+  if (!launch || !dir) return void 0;
+  let text;
+  try {
+    text = readFileSync2(join2(dir, INHERITED_INSTRUCTIONS_FILENAME), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  return {
+    launch,
+    dir,
+    text,
+    skillsIndex: buildSkillsIndexText(readDeliveredSkillFiles(dir)),
+    sources: readInheritedSources(dir),
+    has: {
+      skills: existsSync(join2(dir, KIND_DIRNAMES.skills)),
+      agents: existsSync(join2(dir, KIND_DIRNAMES.agents)),
+      steering: existsSync(join2(dir, KIND_DIRNAMES.steering))
+    }
+  };
+}
+function recordInheritedKind(inheritanceDir, kind, entry) {
+  if (!inheritanceDir) return;
+  const { text, ...delivery } = entry;
+  let fingerprint;
+  if (kind === "instructions") {
+    fingerprint = text === void 0 ? void 0 : { sha256: sha256Text(text), bytes: byteLength(text) };
+  } else {
+    fingerprint = fingerprintDeliveredTree(join2(inheritanceDir, KIND_DIRNAMES[kind]));
+    if (!fingerprint) return;
+  }
+  recordInheritedDelivery(inheritanceDir, {
+    kind,
+    ...delivery,
+    ...delivery.coverage === "none" ? {} : fingerprint
+  });
+}
+function isDelivery(value) {
+  if (!value || typeof value !== "object") return false;
+  const entry = value;
+  return KINDS.includes(entry.kind) && COVERAGES.includes(entry.coverage) && typeof entry.route === "string" && (entry.sha256 === void 0 || typeof entry.sha256 === "string") && (entry.bytes === void 0 || typeof entry.bytes === "number") && (entry.detail === void 0 || typeof entry.detail === "string");
+}
+function readInheritedDeliveries(inheritanceDir) {
+  if (!inheritanceDir) return [];
+  let raw;
+  try {
+    raw = readFileSync2(join2(inheritanceDir, INHERITED_DELIVERIES_FILENAME), "utf8");
+  } catch {
+    return [];
+  }
+  const byKind = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isDelivery(parsed)) continue;
+    const { kind, route, coverage, sha256, bytes, detail } = parsed;
+    byKind.set(kind, {
+      kind,
+      route,
+      coverage,
+      ...sha256 !== void 0 ? { sha256 } : {},
+      ...bytes !== void 0 ? { bytes } : {},
+      ...detail !== void 0 ? { detail } : {}
+    });
+  }
+  return [...byKind.values()];
+}
+function readLaunchInheritanceRecord(provider, launch, bundle, declared) {
+  if (!hasInheritanceDecision(launch)) return void 0;
+  const delivered = readInheritedDeliveries(bundle?.dir);
+  for (const kind of bundle?.set?.kinds ?? []) {
+    const route = declared?.routes[kind];
+    if (typeof route === "string" || delivered.some((entry) => entry.kind === kind)) continue;
+    delivered.push({
+      kind,
+      route: "none",
+      coverage: "none",
+      detail: route?.none ?? "no route yet"
+    });
+  }
+  return {
+    provider,
+    scope: launch.scope,
+    ...launch.mode ? { mode: launch.mode } : {},
+    ...bundle?.set ? { setId: bundle.set.id } : {},
+    delivered
+  };
+}
+
+// src/core/providers/shared/auth-write-back.ts
+import { createHash as createHash2 } from "crypto";
+import * as fs from "fs/promises";
+async function digestIfPresent(filePath) {
+  try {
+    return createHash2("sha256").update(await fs.readFile(filePath)).digest("hex");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function recordAuthCopySeed(canonicalPath, copyPath) {
+  return {
+    canonicalPath,
+    copyPath,
+    canonicalDigest: await digestIfPresent(canonicalPath),
+    copyDigest: await digestIfPresent(copyPath)
+  };
+}
+async function writeBackRefreshedAuth(seed) {
+  try {
+    const copyDigest = await digestIfPresent(seed.copyPath);
+    if (copyDigest === null || copyDigest === seed.copyDigest || seed.canonicalDigest === null) {
+      return "unchanged";
+    }
+    if (await digestIfPresent(seed.canonicalPath) !== seed.canonicalDigest) {
+      return "canonical-changed";
+    }
+    const mode = (await fs.stat(seed.canonicalPath)).mode & 511;
+    const tempPath = `${seed.canonicalPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await fs.copyFile(seed.copyPath, tempPath);
+      await fs.chmod(tempPath, mode);
+      await fs.rename(tempPath, seed.canonicalPath);
+    } catch (error) {
+      await fs.rm(tempPath, { force: true }).catch(() => void 0);
+      throw error;
+    }
+    return "written";
+  } catch {
+    return "failed";
+  }
+}
+async function writeBackRefreshedAuthFiles(seeds) {
+  const outcomes = [];
+  for (const seed of seeds) outcomes.push(await writeBackRefreshedAuth(seed));
+  return outcomes;
+}
+
+// src/core/providers/codex/home-isolation.ts
+import { createHash as createHash3 } from "crypto";
+import * as fs3 from "fs/promises";
+import { homedir } from "os";
+import * as path2 from "path";
+
+// src/core/providers/codex/inherited-home.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+var GLOBAL_INSTRUCTION_FILES = ["AGENTS.override.md", "AGENTS.md"];
+function codexUsesPerRunHome(launch) {
+  if (launch?.scope === "judge") return true;
+  if (!launch?.mode) return false;
+  return !(launch.scope === "ask" && launch.mode === "native");
+}
+async function readTrimmedIfPresent(file) {
+  try {
+    return (await fs2.readFile(file, "utf8")).trim();
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function readUserGlobalInstructions(sourceHome) {
+  for (const name of GLOBAL_INSTRUCTION_FILES) {
+    const text = await readTrimmedIfPresent(path.join(sourceHome, name));
+    if (text) return text;
+  }
+  return "";
+}
+async function writeCodexHomeInstructions(options) {
+  const { home, sourceHome, launch, set } = options;
+  const userGlobal = includesAgentGlobals(launch) ? await readUserGlobalInstructions(sourceHome) : "";
+  const buildSet = set?.text.trim() ?? "";
+  for (const name of GLOBAL_INSTRUCTION_FILES) {
+    await fs2.rm(path.join(home, name), { force: true });
+  }
+  const text = [userGlobal, buildSet].filter(Boolean).join("\n\n");
+  if (!text) return;
+  const written = `${text}
+`;
+  await fs2.writeFile(path.join(home, "AGENTS.md"), written);
+  if (!set || !buildSet) return;
+  recordInheritedKind(set.dir, "instructions", {
+    route: "codex-home",
+    coverage: "full",
+    text: written,
+    ...userGlobal ? { detail: "after the user's own AGENTS.md" } : {}
+  });
+  recordInheritedKind(set.dir, "steering", { route: "codex-home", coverage: "full" });
+}
+function recordCodexSetNotDelivered(set) {
+  for (const kind of ["instructions", "steering", "skills"]) {
+    recordInheritedKind(set?.dir, kind, {
+      route: "codex-home",
+      coverage: "none",
+      detail: "not delivered"
+    });
+  }
+}
+var BUILD_SKILLS_LINK = "build";
+async function visibleNames(dir) {
+  const names = await fs2.readdir(dir).catch(() => []);
+  return names.filter((name) => !name.startsWith(".")).sort();
+}
+async function isDirectory(target) {
+  return (await fs2.stat(target).catch(() => void 0))?.isDirectory() === true;
+}
+async function linkCodexHomeSkills(options) {
+  const { home, sourceHome, launch, set } = options;
+  const skillsDir = path.join(home, "skills");
+  for (const name of await visibleNames(skillsDir)) {
+    const entry = path.join(skillsDir, name);
+    if ((await fs2.lstat(entry)).isSymbolicLink()) await fs2.unlink(entry);
+  }
+  const links = /* @__PURE__ */ new Map();
+  const buildSkills = set?.has.skills ? path.join(set.dir, INHERITED_SKILLS_DIRNAME) : void 0;
+  if (buildSkills) links.set(BUILD_SKILLS_LINK, buildSkills);
+  if (includesAgentGlobals(launch)) {
+    const userSkills = path.join(sourceHome, "skills");
+    for (const name of await visibleNames(userSkills)) {
+      const target = path.join(userSkills, name);
+      if (!links.has(name) && await isDirectory(target)) links.set(name, target);
+    }
+  }
+  let buildLinked = false;
+  for (const [name, target] of links) {
+    const link = path.join(skillsDir, name);
+    if (await fs2.lstat(link).catch(() => void 0)) continue;
+    await fs2.mkdir(skillsDir, { recursive: true });
+    await fs2.symlink(target, link, "dir");
+    buildLinked ||= name === BUILD_SKILLS_LINK && target === buildSkills;
+  }
+  recordInheritedKind(
+    set?.dir,
+    "skills",
+    buildLinked ? { route: "codex-home", coverage: "full" } : { route: "codex-home", coverage: "none", detail: "not delivered" }
+  );
+}
+
+// src/core/providers/codex/home-isolation.ts
+var CODEX_NATIVE_HOME_DIR = ".codex";
+var CODEX_ISOLATED_HOME_RELATIVE_PATH = path2.join(".build-project", "codex-home");
+var MIRROR_FILES = ["auth.json", "config.toml", "models_cache.json"];
+var MIRROR_DIRS = ["rules"];
+var PROFILE_CONFIG_SUFFIX = ".config.toml";
+function getStandardCodexHome() {
+  return path2.join(homedir(), CODEX_NATIVE_HOME_DIR);
+}
+function getIsolatedCodexHomePath(worktreePath) {
+  return path2.resolve(worktreePath, CODEX_ISOLATED_HOME_RELATIVE_PATH);
+}
+function getWorktreeFallbackCodexHome(worktreePath) {
+  const key = createHash3("sha256").update(worktreePath).digest("hex").slice(0, 16);
+  return path2.join(getStateDir(), "codex-homes", key);
+}
+function getXdgCodexHome() {
+  const { userConfigDir } = getDefaultPaths();
+  return path2.join(userConfigDir, "providers", "codex");
+}
+function normalizeCodexHomePath(raw) {
+  let expanded = expandHomeDir(String(raw).trim());
+  if (expanded === "~") {
+    expanded = homedir();
+  } else if (expanded.startsWith("~/") || expanded.startsWith(`~${path2.sep}`)) {
+    expanded = path2.join(homedir(), expanded.slice(2));
+  }
+  if (/^[A-Za-z]:[\\/]/.test(expanded)) {
+    return expanded;
+  }
+  return path2.resolve(expanded);
+}
+function conventionalCodexHomeCandidates() {
+  const homes = /* @__PURE__ */ new Set();
+  homes.add(path2.resolve(homedir()));
+  const envHome = process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+  if (envHome) {
+    try {
+      homes.add(path2.resolve(expandHomeDir(envHome)));
+    } catch {
+    }
+  }
+  return [...homes].map((home) => path2.resolve(path2.join(home, CODEX_NATIVE_HOME_DIR)));
+}
+function isConventionalCodexHome(raw) {
+  if (!raw || !String(raw).trim()) {
+    return false;
+  }
+  try {
+    const candidate = normalizeCodexHomePath(String(raw));
+    const normalizedCandidate = /^[A-Za-z]:[\\/]/.test(candidate) ? candidate.replace(/[\\/]+$/, "") : path2.resolve(candidate);
+    return conventionalCodexHomeCandidates().some((standard) => {
+      if (/^[A-Za-z]:[\\/]/.test(normalizedCandidate) || /^[A-Za-z]:[\\/]/.test(standard)) {
+        return normalizedCandidate.replace(/\\/g, "/").toLowerCase() === standard.replace(/\\/g, "/").toLowerCase();
+      }
+      return normalizedCandidate === standard;
+    });
+  } catch {
+    return false;
+  }
+}
+function isExplicitCustomCodexHome(raw) {
+  if (!raw || !String(raw).trim()) {
+    return false;
+  }
+  return !isConventionalCodexHome(raw);
+}
+function readCodexHomeFromEnv(env) {
+  const fromEnv = env?.CODEX_HOME?.trim() || getRuntimeEnv("CODEX_HOME")?.trim();
+  return fromEnv || void 0;
+}
+function resolveCanonicalCodexHome(options) {
+  if (options?.configDir !== void 0 && String(options.configDir).trim()) {
+    const home = normalizeCodexHomePath(options.configDir);
+    return {
+      home,
+      source: "options",
+      conventional: isConventionalCodexHome(home)
+    };
+  }
+  const envHome = readCodexHomeFromEnv(options?.env);
+  if (envHome) {
+    const home = normalizeCodexHomePath(envHome);
+    return {
+      home,
+      source: "explicit-env",
+      conventional: isConventionalCodexHome(home)
+    };
+  }
+  if (options?.preferStandardWhenUnset !== false) {
+    return {
+      home: path2.resolve(getStandardCodexHome()),
+      source: "standard",
+      conventional: true
+    };
+  }
+  return {
+    home: path2.resolve(getXdgCodexHome()),
+    source: "xdg",
+    conventional: false
+  };
+}
+function isCodexHomeIsolationEnabled(env) {
+  if (env && Object.hasOwn(env, BUILD_CODEX_ISOLATE_HOME.name)) {
+    const raw = env[BUILD_CODEX_ISOLATE_HOME.name];
+    if (raw === void 0 || raw === null || String(raw).trim() === "") {
+      return true;
+    }
+    const normalized = String(raw).trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+      return false;
+    }
+    if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+      return true;
+    }
+  }
+  return readEnv(BUILD_CODEX_ISOLATE_HOME).value !== false;
+}
+function isWorktreeContext(env) {
+  const fromEnv = env?.BUILD_WORKTREE?.trim() || getRuntimeEnv("BUILD_WORKTREE")?.trim();
+  if (fromEnv === "1") {
+    return true;
+  }
+  return Boolean(readEnv(BUILD_WORKTREE).value);
+}
+function shouldIsolateCodexHome(options) {
+  if (!isCodexHomeIsolationEnabled(options.env)) {
+    return false;
+  }
+  const envHome = readCodexHomeFromEnv(options.env);
+  if (envHome && isExplicitCustomCodexHome(envHome)) {
+    if (options.worktreePath && path2.resolve(normalizeCodexHomePath(envHome)) === getIsolatedCodexHomePath(options.worktreePath)) {
+      return true;
+    }
+    return false;
+  }
+  return Boolean(options.force || isWorktreeContext(options.env));
+}
+async function isDirectory2(target) {
+  try {
+    const st = await fs3.stat(target);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function isFile(target) {
+  try {
+    const st = await fs3.stat(target);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+async function refreshCopiedFile(fromPath, toPath) {
+  if (!await isFile(fromPath)) {
+    try {
+      await fs3.rm(toPath, { force: true });
+    } catch {
+    }
+    return;
+  }
+  try {
+    await fs3.rm(toPath, { force: true });
+  } catch {
+  }
+  await fs3.mkdir(path2.dirname(toPath), { recursive: true });
+  await fs3.copyFile(fromPath, toPath);
+}
+async function readDirectoryNamesIfPresent(target) {
+  try {
+    return await fs3.readdir(target);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function refreshProfileConfigFiles(sourceHome, isolatedHome) {
+  const fileNames = /* @__PURE__ */ new Set([
+    ...await readDirectoryNamesIfPresent(sourceHome),
+    ...await readDirectoryNamesIfPresent(isolatedHome)
+  ]);
+  for (const fileName of fileNames) {
+    if (!fileName.endsWith(PROFILE_CONFIG_SUFFIX)) {
+      continue;
+    }
+    await refreshCopiedFile(path2.join(sourceHome, fileName), path2.join(isolatedHome, fileName));
+  }
+}
+async function refreshLinkedDir(fromPath, toPath) {
+  if (!await isDirectory2(fromPath)) {
+    return;
+  }
+  try {
+    const existing = await fs3.lstat(toPath);
+    if (existing.isSymbolicLink()) {
+      await fs3.rm(toPath, { force: true });
+    } else {
+      return;
+    }
+  } catch {
+  }
+  try {
+    await fs3.symlink(fromPath, toPath, "dir");
+  } catch {
+  }
+}
+function resolvePreferredStandardCodexHome(env) {
+  const envHome = env?.HOME?.trim() || env?.USERPROFILE?.trim() || process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+  if (envHome) {
+    return path2.resolve(path2.join(expandHomeDir(envHome), CODEX_NATIVE_HOME_DIR));
+  }
+  return path2.resolve(getStandardCodexHome());
+}
+function resolveSourceHomeForMirror(env) {
+  const envHome = readCodexHomeFromEnv(env);
+  if (envHome && !isConventionalCodexHome(envHome)) {
+    const isolatedHint = CODEX_ISOLATED_HOME_RELATIVE_PATH;
+    if (normalizeCodexHomePath(envHome).includes(path2.normalize(isolatedHint))) {
+      return resolvePreferredStandardCodexHome(env);
+    }
+    return normalizeCodexHomePath(envHome);
+  }
+  if (envHome && isConventionalCodexHome(envHome)) {
+    return normalizeCodexHomePath(envHome);
+  }
+  return resolvePreferredStandardCodexHome(env);
+}
+async function prepareCodexHomeIsolation(options) {
+  const baseEnv = { ...options.env ?? {} };
+  const worktreePath = path2.resolve(options.worktreePath);
+  const worktreePathIsDirectory = await isDirectory2(worktreePath);
+  const launch = readLaunchInheritance(baseEnv);
+  const inheritanceDir = readInheritanceDir(baseEnv);
+  const set = readInheritedSet(baseEnv);
+  const worktreeIsolation = shouldIsolateCodexHome({
+    worktreePath,
+    env: baseEnv,
+    force: options.force,
+    worktreePathIsDirectory
+  });
+  const launchHomeRoot = !worktreeIsolation && codexUsesPerRunHome(launch) && isCodexHomeIsolationEnabled(baseEnv) ? inheritanceDir : void 0;
+  if (!worktreeIsolation && !launchHomeRoot) {
+    recordCodexSetNotDelivered(set);
+    const envHome = readCodexHomeFromEnv(baseEnv);
+    if (envHome) {
+      const home = normalizeCodexHomePath(envHome);
+      return {
+        env: { ...baseEnv, CODEX_HOME: home },
+        codexHome: home,
+        isolated: false
+      };
+    }
+    const fallback = resolveCanonicalCodexHome({ env: baseEnv, preferStandardWhenUnset: true });
+    return {
+      env: baseEnv,
+      codexHome: fallback.home,
+      isolated: false
+    };
+  }
+  const homeRoot = launchHomeRoot ?? inheritanceDir;
+  const isolatedHome = homeRoot ? path2.join(homeRoot, "codex-home") : getWorktreeFallbackCodexHome(worktreePath);
+  const sourceHome = resolveSourceHomeForMirror(baseEnv);
+  let authSeed;
+  try {
+    await fs3.mkdir(isolatedHome, { recursive: true });
+    for (const fileName of MIRROR_FILES) {
+      await refreshCopiedFile(path2.join(sourceHome, fileName), path2.join(isolatedHome, fileName));
+    }
+    authSeed = await recordAuthCopySeed(
+      path2.join(sourceHome, "auth.json"),
+      path2.join(isolatedHome, "auth.json")
+    );
+    await refreshProfileConfigFiles(sourceHome, isolatedHome);
+    for (const dirName of MIRROR_DIRS) {
+      await refreshLinkedDir(path2.join(sourceHome, dirName), path2.join(isolatedHome, dirName));
+    }
+    await writeCodexHomeInstructions({ home: isolatedHome, sourceHome, launch, set });
+    await linkCodexHomeSkills({ home: isolatedHome, sourceHome, launch, set });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[Codex] Failed to provision isolated CODEX_HOME at ${isolatedHome}: ${message}. Refusing to share mutable session/history state under ${sourceHome}. Set a custom CODEX_HOME or BUILD_CODEX_ISOLATE_HOME=0 to opt out.`
+    );
+  }
+  if (isConventionalCodexHome(isolatedHome)) {
+    throw new Error(
+      `[Codex] Isolation resolved to conventional home ${isolatedHome}; refusing to share mutable session/history state.`
+    );
+  }
+  return {
+    env: {
+      ...baseEnv,
+      CODEX_HOME: isolatedHome
+    },
+    codexHome: isolatedHome,
+    isolated: true,
+    sourceHome,
+    authSeed
+  };
+}
+async function resolveCodexRuntimeHome(options) {
+  const isolation = await prepareCodexHomeIsolation({
+    worktreePath: options.workingDir,
+    env: options.env,
+    force: options.forceIsolation
+  });
+  if (isolation.isolated) {
+    return {
+      env: isolation.env,
+      codexHome: isolation.codexHome,
+      isolated: true,
+      authSeed: isolation.authSeed
+    };
+  }
+  const envHome = isolation.env.CODEX_HOME ?? readCodexHomeFromEnv(options.env);
+  if (envHome) {
+    const home = normalizeCodexHomePath(envHome);
+    return {
+      env: { ...options.env ?? {}, CODEX_HOME: home },
+      codexHome: home,
+      isolated: false
+    };
+  }
+  return {
+    env: { ...options.env ?? {} },
+    isolated: false
+  };
+}
+
+// src/core/providers/shared/toml-values.ts
+var Reader = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  pos = 0;
+  get done() {
+    return this.pos >= this.text.length;
+  }
+  peek(offset = 0) {
+    return this.text[this.pos + offset] ?? "";
+  }
+  startsWith(token) {
+    return this.text.startsWith(token, this.pos);
+  }
+  skipSpaces() {
+    while (this.peek() === " " || this.peek() === "	") this.pos++;
+  }
+  skipLine() {
+    const end = this.text.indexOf("\n", this.pos);
+    this.pos = end === -1 ? this.text.length : end + 1;
+  }
+  /** Skip spaces, newlines, and comments (inside arrays, between entries). */
+  skipBlank() {
+    for (; ; ) {
+      this.skipSpaces();
+      if (this.peek() === "#") this.skipLine();
+      else if (this.peek() === "\n" || this.peek() === "\r") this.pos++;
+      else return;
+    }
+  }
+};
+function unescapeBasic(raw) {
+  return raw.replace(
+    /\\(?:u([0-9a-fA-F]{4})|U([0-9a-fA-F]{8})|([btnfr"\\])|\r?\n[ \t\r\n]*)/g,
+    (match, u4, u8, simple) => {
+      if (u4 || u8) return String.fromCodePoint(Number.parseInt(u4 ?? u8 ?? "0", 16));
+      if (simple) {
+        const map = {
+          b: "\b",
+          t: "	",
+          n: "\n",
+          f: "\f",
+          r: "\r",
+          '"': '"',
+          "\\": "\\"
+        };
+        return map[simple] ?? match;
+      }
+      return "";
+    }
+  );
+}
+function readString(reader) {
+  for (const quote2 of ['"""', "'''"]) {
+    if (!reader.startsWith(quote2)) continue;
+    reader.pos += 3;
+    if (reader.peek() === "\n") reader.pos++;
+    else if (reader.startsWith("\r\n")) reader.pos += 2;
+    let end = reader.text.indexOf(quote2, reader.pos);
+    while (quote2 === '"""' && end > 0 && isEscaped(reader.text, end)) {
+      end = reader.text.indexOf(quote2, end + 1);
+    }
+    if (end === -1) return void 0;
+    while (reader.text[end + 3] === quote2[0]) end++;
+    const raw2 = reader.text.slice(reader.pos, end);
+    reader.pos = end + 3;
+    return quote2 === '"""' ? unescapeBasic(raw2) : raw2;
+  }
+  const quote = reader.peek();
+  if (quote !== '"' && quote !== "'") return void 0;
+  reader.pos++;
+  let raw = "";
+  while (!reader.done && reader.peek() !== quote && reader.peek() !== "\n") {
+    if (quote === '"' && reader.peek() === "\\") {
+      raw += reader.peek() + reader.peek(1);
+      reader.pos += 2;
+      continue;
+    }
+    raw += reader.peek();
+    reader.pos++;
+  }
+  if (reader.peek() !== quote) return void 0;
+  reader.pos++;
+  return quote === '"' ? unescapeBasic(raw) : raw;
+}
+function isEscaped(text, index) {
+  let slashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) slashes++;
+  return slashes % 2 === 1;
+}
+function readKey(reader) {
+  const parts = [];
+  for (; ; ) {
+    reader.skipSpaces();
+    const quoted = reader.peek() === '"' || reader.peek() === "'" ? readString(reader) : void 0;
+    if (quoted !== void 0) {
+      parts.push(quoted);
+    } else {
+      const match = /^[A-Za-z0-9_-]+/.exec(reader.text.slice(reader.pos, reader.pos + 256));
+      if (!match) return void 0;
+      parts.push(match[0]);
+      reader.pos += match[0].length;
+    }
+    reader.skipSpaces();
+    if (reader.peek() !== ".") return parts;
+    reader.pos++;
+  }
+}
+function readStringArray(reader) {
+  reader.pos++;
+  const values = [];
+  let valid = true;
+  for (; ; ) {
+    reader.skipBlank();
+    if (reader.done) return void 0;
+    if (reader.peek() === "]") {
+      reader.pos++;
+      return valid ? values : void 0;
+    }
+    const value = readString(reader);
+    if (value === void 0) {
+      valid = false;
+      while (!reader.done && !",]\n".includes(reader.peek())) reader.pos++;
+    } else {
+      values.push(value);
+    }
+    reader.skipBlank();
+    if (reader.peek() === ",") reader.pos++;
+  }
+}
+function readValue(reader) {
+  reader.skipSpaces();
+  if (reader.peek() === '"' || reader.peek() === "'") return readString(reader);
+  if (reader.peek() === "[") return readStringArray(reader);
+  const match = /^(true|false)\b/.exec(reader.text.slice(reader.pos, reader.pos + 6));
+  if (match) {
+    reader.pos += match[0].length;
+    return match[0] === "true";
+  }
+  const integer = /^[+-]?\d(?:_?\d)*(?=\s*(?:#|\r?\n|$))/.exec(reader.text.slice(reader.pos));
+  if (integer) {
+    const value = Number(integer[0].replaceAll("_", ""));
+    if (Number.isSafeInteger(value)) {
+      reader.pos += integer[0].length;
+      return value;
+    }
+  }
+  return void 0;
+}
+function readTomlValues(text) {
+  const values = /* @__PURE__ */ new Map();
+  const reader = new Reader(text);
+  let table = [];
+  while (!reader.done) {
+    reader.skipBlank();
+    if (reader.done) break;
+    if (reader.peek() === "[") {
+      const arrayTable = reader.peek(1) === "[";
+      reader.pos += arrayTable ? 2 : 1;
+      const key2 = readKey(reader);
+      table = arrayTable ? void 0 : key2;
+      reader.skipLine();
+      continue;
+    }
+    const key = readKey(reader);
+    reader.skipSpaces();
+    if (!key || reader.peek() !== "=") {
+      reader.skipLine();
+      continue;
+    }
+    reader.pos++;
+    const value = readValue(reader);
+    if (value !== void 0 && table) values.set([...table, ...key].join("."), value);
+    reader.skipLine();
+  }
+  return values;
+}
+
+export {
+  readTomlValues,
+  readFrontMatter,
+  stripFrontMatter,
+  oneLine,
+  INHERITED_SOURCES_FILENAME,
+  fingerprintInheritedSet,
+  readInheritedSet,
+  recordInheritedKind,
+  readLaunchInheritanceRecord,
+  recordAuthCopySeed,
+  writeBackRefreshedAuth,
+  writeBackRefreshedAuthFiles,
+  getIsolatedCodexHomePath,
+  normalizeCodexHomePath,
+  resolveSourceHomeForMirror,
+  resolveCodexRuntimeHome
+};
+//# sourceMappingURL=chunk-BD3PGW6A.js.map