@costrict/csc 4.0.1

package/dist/chunk-j7e5xs2n.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-qp1047f9.js";
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-z6e5jp2w.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-h4b85amj.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-jaaxk89e.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-nh3cd07f.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/releaseNotes.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+function getChangelogCachePath() {
+  return join(getClaudeConfigHomeDir(), "cache", "changelog.md");
+}
+async function migrateChangelogFromConfig() {
+  const config = getGlobalConfig();
+  if (!config.cachedChangelog) {
+    return;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, config.cachedChangelog, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+  } catch {}
+  saveGlobalConfig(({ cachedChangelog: _, ...rest }) => rest);
+}
+async function fetchAndStoreChangelog() {
+  if (getIsNonInteractiveSession()) {
+    return;
+  }
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  const response = await axios_default.get(RAW_CHANGELOG_URL);
+  if (response.status === 200) {
+    const changelogContent = response.data;
+    if (changelogContent === changelogMemoryCache) {
+      return;
+    }
+    const cachePath = getChangelogCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, changelogContent, { encoding: "utf-8" });
+    changelogMemoryCache = changelogContent;
+    const changelogLastFetched = Date.now();
+    saveGlobalConfig((current) => ({
+      ...current,
+      changelogLastFetched
+    }));
+  }
+}
+async function getStoredChangelog() {
+  if (changelogMemoryCache !== null) {
+    return changelogMemoryCache;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    changelogMemoryCache = content;
+    return content;
+  } catch {
+    changelogMemoryCache = "";
+    return "";
+  }
+}
+function getStoredChangelogFromMemory() {
+  return changelogMemoryCache ?? "";
+}
+function parseChangelog(content) {
+  try {
+    if (!content)
+      return {};
+    const releaseNotes = {};
+    const sections = content.split(/^## /gm).slice(1);
+    for (const section of sections) {
+      const lines = section.trim().split(`
+`);
+      if (lines.length === 0)
+        continue;
+      const versionLine = lines[0];
+      if (!versionLine)
+        continue;
+      const version = versionLine.split(" - ")[0]?.trim() || "";
+      if (!version)
+        continue;
+      const notes = lines.slice(1).filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().substring(2).trim()).filter(Boolean);
+      if (notes.length > 0) {
+        releaseNotes[version] = notes;
+      }
+    }
+    return releaseNotes;
+  } catch (error) {
+    logError(toError(error));
+    return {};
+  }
+}
+function getRecentReleaseNotes(currentVersion, previousVersion, changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const baseCurrentVersion = import_semver.coerce(currentVersion);
+    const basePreviousVersion = previousVersion ? import_semver.coerce(previousVersion) : null;
+    if (!basePreviousVersion || baseCurrentVersion && gt(baseCurrentVersion.version, basePreviousVersion.version)) {
+      return Object.entries(releaseNotes).filter(([version]) => !basePreviousVersion || gt(version, basePreviousVersion.version)).sort(([versionA], [versionB]) => gt(versionA, versionB) ? -1 : 1).flatMap(([_, notes]) => notes).filter(Boolean).slice(0, MAX_RELEASE_NOTES_SHOWN);
+    }
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+  return [];
+}
+function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const sortedVersions = Object.keys(releaseNotes).sort((a, b) => gt(a, b) ? 1 : -1);
+    return sortedVersions.map((version) => {
+      const versionNotes = releaseNotes[version];
+      if (!versionNotes || versionNotes.length === 0)
+        return null;
+      const notes = versionNotes.filter(Boolean);
+      if (notes.length === 0)
+        return null;
+      return [version, notes];
+    }).filter((item) => item !== null);
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+}
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = "4.0.1") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const cachedChangelog = await getStoredChangelog();
+  if (lastSeenVersion !== currentVersion || !cachedChangelog) {
+    fetchAndStoreChangelog().catch((error) => logError(toError(error)));
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion, cachedChangelog);
+  const hasReleaseNotes = releaseNotes.length > 0;
+  return {
+    hasReleaseNotes,
+    releaseNotes
+  };
+}
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "4.0.1") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion);
+  return {
+    hasReleaseNotes: releaseNotes.length > 0,
+    releaseNotes
+  };
+}
+var import_semver, MAX_RELEASE_NOTES_SHOWN = 5, CHANGELOG_URL = "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md", RAW_CHANGELOG_URL = "https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/CHANGELOG.md", changelogMemoryCache = null;
+var init_releaseNotes = __esm(() => {
+  init_axios();
+  init_state();
+  init_config();
+  init_envUtils();
+  init_errors();
+  init_log();
+  init_privacyLevel();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+export { CHANGELOG_URL, migrateChangelogFromConfig, fetchAndStoreChangelog, getStoredChangelog, getStoredChangelogFromMemory, parseChangelog, getAllReleaseNotes, checkForReleaseNotes, checkForReleaseNotesSync, init_releaseNotes };

package/dist/chunk-j9gxwbe3.js

@@ -0,0 +1,349 @@
+// @bun
+import {
+  djb2Hash,
+  init_hash
+} from "./chunk-8tnsngw2.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-jaaxk89e.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/getWorktreePathsPortable.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+async function getWorktreePathsPortable(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"], { cwd, timeout: 5000 });
+    if (!stdout)
+      return [];
+    return stdout.split(`
+`).filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).normalize("NFC"));
+  } catch {
+    return [];
+  }
+}
+var execFileAsync;
+var init_getWorktreePathsPortable = __esm(() => {
+  execFileAsync = promisify(execFileCb);
+});
+
+// src/utils/sessionStoragePortable.ts
+import { open as fsOpen, readdir, realpath, stat } from "fs/promises";
+import { join } from "path";
+function validateUuid(maybeUuid) {
+  if (typeof maybeUuid !== "string")
+    return null;
+  return uuidRegex.test(maybeUuid) ? maybeUuid : null;
+}
+function unescapeJsonString(raw) {
+  if (!raw.includes("\\"))
+    return raw;
+  try {
+    return JSON.parse(`"${raw}"`);
+  } catch {
+    return raw;
+  }
+}
+function extractJsonStringField(text, key) {
+  const patterns = [`"${key}":"`, `"${key}": "`];
+  for (const pattern of patterns) {
+    const idx = text.indexOf(pattern);
+    if (idx < 0)
+      continue;
+    const valueStart = idx + pattern.length;
+    let i = valueStart;
+    while (i < text.length) {
+      if (text[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (text[i] === '"') {
+        return unescapeJsonString(text.slice(valueStart, i));
+      }
+      i++;
+    }
+  }
+  return;
+}
+function extractLastJsonStringField(text, key) {
+  const patterns = [`"${key}":"`, `"${key}": "`];
+  let lastValue;
+  for (const pattern of patterns) {
+    let searchFrom = 0;
+    while (true) {
+      const idx = text.indexOf(pattern, searchFrom);
+      if (idx < 0)
+        break;
+      const valueStart = idx + pattern.length;
+      let i = valueStart;
+      while (i < text.length) {
+        if (text[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (text[i] === '"') {
+          lastValue = unescapeJsonString(text.slice(valueStart, i));
+          break;
+        }
+        i++;
+      }
+      searchFrom = i + 1;
+    }
+  }
+  return lastValue;
+}
+async function readHeadAndTail(filePath, fileSize, buf) {
+  try {
+    const fh = await fsOpen(filePath, "r");
+    try {
+      const headResult = await fh.read(buf, 0, LITE_READ_BUF_SIZE, 0);
+      if (headResult.bytesRead === 0)
+        return { head: "", tail: "" };
+      const head = buf.toString("utf8", 0, headResult.bytesRead);
+      const tailOffset = Math.max(0, fileSize - LITE_READ_BUF_SIZE);
+      let tail = head;
+      if (tailOffset > 0) {
+        const tailResult = await fh.read(buf, 0, LITE_READ_BUF_SIZE, tailOffset);
+        tail = buf.toString("utf8", 0, tailResult.bytesRead);
+      }
+      return { head, tail };
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return { head: "", tail: "" };
+  }
+}
+function simpleHash(str) {
+  return Math.abs(djb2Hash(str)).toString(36);
+}
+function sanitizePath(name) {
+  const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-");
+  if (sanitized.length <= MAX_SANITIZED_LENGTH) {
+    return sanitized;
+  }
+  const hash = typeof Bun !== "undefined" ? Bun.hash(name).toString(36) : simpleHash(name);
+  return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${hash}`;
+}
+function getProjectsDir() {
+  return join(getClaudeConfigHomeDir(), "projects");
+}
+function compactBoundaryMarker() {
+  return _compactBoundaryMarker ??= Buffer.from('"compact_boundary"');
+}
+function parseBoundaryLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.type !== "system" || parsed.subtype !== "compact_boundary") {
+      return null;
+    }
+    return {
+      hasPreservedSegment: Boolean(parsed.compactMetadata?.preservedSegment)
+    };
+  } catch {
+    return null;
+  }
+}
+function sinkWrite(s, src, start, end) {
+  const n = end - start;
+  if (n <= 0)
+    return;
+  if (s.len + n > s.buf.length) {
+    const grown = Buffer.allocUnsafe(Math.min(Math.max(s.buf.length * 2, s.len + n), s.cap));
+    s.buf.copy(grown, 0, 0, s.len);
+    s.buf = grown;
+  }
+  src.copy(s.buf, s.len, start, end);
+  s.len += n;
+}
+function hasPrefix(src, prefix, at, end) {
+  return end - at >= prefix.length && src.compare(prefix, 0, prefix.length, at, at + prefix.length) === 0;
+}
+function processStraddle(s, chunk, bytesRead) {
+  s.straddleSnapCarryLen = 0;
+  s.straddleSnapTailEnd = 0;
+  if (s.carryLen === 0)
+    return 0;
+  const cb = s.carryBuf;
+  const firstNl = chunk.indexOf(LF);
+  if (firstNl === -1 || firstNl >= bytesRead)
+    return 0;
+  const tailEnd = firstNl + 1;
+  if (hasPrefix(cb, ATTR_SNAP_PREFIX, 0, s.carryLen)) {
+    s.straddleSnapCarryLen = s.carryLen;
+    s.straddleSnapTailEnd = tailEnd;
+    s.lastSnapSrc = null;
+  } else if (s.carryLen < ATTR_SNAP_PREFIX.length) {
+    return 0;
+  } else {
+    if (hasPrefix(cb, SYSTEM_PREFIX, 0, s.carryLen)) {
+      const hit = parseBoundaryLine(cb.toString("utf-8", 0, s.carryLen) + chunk.toString("utf-8", 0, firstNl));
+      if (hit?.hasPreservedSegment) {
+        s.hasPreservedSegment = true;
+      } else if (hit) {
+        s.out.len = 0;
+        s.boundaryStartOffset = s.bufFileOff;
+        s.hasPreservedSegment = false;
+        s.lastSnapSrc = null;
+      }
+    }
+    sinkWrite(s.out, cb, 0, s.carryLen);
+    sinkWrite(s.out, chunk, 0, tailEnd);
+  }
+  s.bufFileOff += s.carryLen + tailEnd;
+  s.carryLen = 0;
+  return tailEnd;
+}
+function scanChunkLines(s, buf, boundaryMarker) {
+  let boundaryAt = buf.indexOf(boundaryMarker);
+  let runStart = 0;
+  let lineStart = 0;
+  let lastSnapStart = -1;
+  let lastSnapEnd = -1;
+  let nl = buf.indexOf(LF);
+  while (nl !== -1) {
+    const lineEnd = nl + 1;
+    if (boundaryAt !== -1 && boundaryAt < lineStart) {
+      boundaryAt = buf.indexOf(boundaryMarker, lineStart);
+    }
+    if (hasPrefix(buf, ATTR_SNAP_PREFIX, lineStart, lineEnd)) {
+      sinkWrite(s.out, buf, runStart, lineStart);
+      lastSnapStart = lineStart;
+      lastSnapEnd = lineEnd;
+      runStart = lineEnd;
+    } else if (boundaryAt >= lineStart && boundaryAt < Math.min(lineStart + BOUNDARY_SEARCH_BOUND, lineEnd)) {
+      const hit = parseBoundaryLine(buf.toString("utf-8", lineStart, nl));
+      if (hit?.hasPreservedSegment) {
+        s.hasPreservedSegment = true;
+      } else if (hit) {
+        s.out.len = 0;
+        s.boundaryStartOffset = s.bufFileOff + lineStart;
+        s.hasPreservedSegment = false;
+        s.lastSnapSrc = null;
+        lastSnapStart = -1;
+        s.straddleSnapCarryLen = 0;
+        runStart = lineStart;
+      }
+      boundaryAt = buf.indexOf(boundaryMarker, boundaryAt + boundaryMarker.length);
+    }
+    lineStart = lineEnd;
+    nl = buf.indexOf(LF, lineStart);
+  }
+  sinkWrite(s.out, buf, runStart, lineStart);
+  return { lastSnapStart, lastSnapEnd, trailStart: lineStart };
+}
+function captureSnap(s, buf, chunk, lastSnapStart, lastSnapEnd) {
+  if (lastSnapStart !== -1) {
+    s.lastSnapLen = lastSnapEnd - lastSnapStart;
+    if (s.lastSnapBuf === undefined || s.lastSnapLen > s.lastSnapBuf.length) {
+      s.lastSnapBuf = Buffer.allocUnsafe(s.lastSnapLen);
+    }
+    buf.copy(s.lastSnapBuf, 0, lastSnapStart, lastSnapEnd);
+    s.lastSnapSrc = s.lastSnapBuf;
+  } else if (s.straddleSnapCarryLen > 0) {
+    s.lastSnapLen = s.straddleSnapCarryLen + s.straddleSnapTailEnd;
+    if (s.lastSnapBuf === undefined || s.lastSnapLen > s.lastSnapBuf.length) {
+      s.lastSnapBuf = Buffer.allocUnsafe(s.lastSnapLen);
+    }
+    s.carryBuf.copy(s.lastSnapBuf, 0, 0, s.straddleSnapCarryLen);
+    chunk.copy(s.lastSnapBuf, s.straddleSnapCarryLen, 0, s.straddleSnapTailEnd);
+    s.lastSnapSrc = s.lastSnapBuf;
+  }
+}
+function captureCarry(s, buf, trailStart) {
+  s.carryLen = buf.length - trailStart;
+  if (s.carryLen > 0) {
+    if (s.carryBuf === undefined || s.carryLen > s.carryBuf.length) {
+      s.carryBuf = Buffer.allocUnsafe(s.carryLen);
+    }
+    buf.copy(s.carryBuf, 0, trailStart, buf.length);
+  }
+}
+function finalizeOutput(s) {
+  if (s.carryLen > 0) {
+    const cb = s.carryBuf;
+    if (hasPrefix(cb, ATTR_SNAP_PREFIX, 0, s.carryLen)) {
+      s.lastSnapSrc = cb;
+      s.lastSnapLen = s.carryLen;
+    } else {
+      sinkWrite(s.out, cb, 0, s.carryLen);
+    }
+  }
+  if (s.lastSnapSrc) {
+    if (s.out.len > 0 && s.out.buf[s.out.len - 1] !== LF) {
+      sinkWrite(s.out, LF_BYTE, 0, 1);
+    }
+    sinkWrite(s.out, s.lastSnapSrc, 0, s.lastSnapLen);
+  }
+}
+async function readTranscriptForLoad(filePath, fileSize) {
+  const boundaryMarker = compactBoundaryMarker();
+  const CHUNK_SIZE = TRANSCRIPT_READ_CHUNK_SIZE;
+  const s = {
+    out: {
+      buf: Buffer.allocUnsafe(Math.min(fileSize, 8 * 1024 * 1024)),
+      len: 0,
+      cap: fileSize + 1
+    },
+    boundaryStartOffset: 0,
+    hasPreservedSegment: false,
+    lastSnapSrc: null,
+    lastSnapLen: 0,
+    lastSnapBuf: undefined,
+    bufFileOff: 0,
+    carryLen: 0,
+    carryBuf: undefined,
+    straddleSnapCarryLen: 0,
+    straddleSnapTailEnd: 0
+  };
+  const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
+  const fd = await fsOpen(filePath, "r");
+  try {
+    let filePos = 0;
+    while (filePos < fileSize) {
+      const { bytesRead } = await fd.read(chunk, 0, Math.min(CHUNK_SIZE, fileSize - filePos), filePos);
+      if (bytesRead === 0)
+        break;
+      filePos += bytesRead;
+      const chunkOff = processStraddle(s, chunk, bytesRead);
+      let buf;
+      if (s.carryLen > 0) {
+        const bufLen = s.carryLen + (bytesRead - chunkOff);
+        buf = Buffer.allocUnsafe(bufLen);
+        s.carryBuf.copy(buf, 0, 0, s.carryLen);
+        chunk.copy(buf, s.carryLen, chunkOff, bytesRead);
+      } else {
+        buf = chunk.subarray(chunkOff, bytesRead);
+      }
+      const r = scanChunkLines(s, buf, boundaryMarker);
+      captureSnap(s, buf, chunk, r.lastSnapStart, r.lastSnapEnd);
+      captureCarry(s, buf, r.trailStart);
+      s.bufFileOff += r.trailStart;
+    }
+    finalizeOutput(s);
+  } finally {
+    await fd.close();
+  }
+  return {
+    boundaryStartOffset: s.boundaryStartOffset,
+    postBoundaryBuf: s.out.buf.subarray(0, s.out.len),
+    hasPreservedSegment: s.hasPreservedSegment
+  };
+}
+var LITE_READ_BUF_SIZE = 65536, uuidRegex, MAX_SANITIZED_LENGTH = 200, TRANSCRIPT_READ_CHUNK_SIZE, SKIP_PRECOMPACT_THRESHOLD, _compactBoundaryMarker, ATTR_SNAP_PREFIX, SYSTEM_PREFIX, LF = 10, LF_BYTE, BOUNDARY_SEARCH_BOUND = 256;
+var init_sessionStoragePortable = __esm(() => {
+  init_envUtils();
+  init_getWorktreePathsPortable();
+  init_hash();
+  uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  TRANSCRIPT_READ_CHUNK_SIZE = 1024 * 1024;
+  SKIP_PRECOMPACT_THRESHOLD = 5 * 1024 * 1024;
+  ATTR_SNAP_PREFIX = Buffer.from('{"type":"attribution-snapshot"');
+  SYSTEM_PREFIX = Buffer.from('{"type":"system"');
+  LF_BYTE = Buffer.from([LF]);
+});
+
+export { getWorktreePathsPortable, init_getWorktreePathsPortable, LITE_READ_BUF_SIZE, validateUuid, extractJsonStringField, extractLastJsonStringField, readHeadAndTail, sanitizePath, getProjectsDir, SKIP_PRECOMPACT_THRESHOLD, readTranscriptForLoad, init_sessionStoragePortable };

package/dist/chunk-jaaxk89e.js

@@ -0,0 +1,113 @@
+// @bun
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-vf612n57.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/protectedNamespace.ts
+var exports_protectedNamespace = {};
+__export(exports_protectedNamespace, {
+  checkProtectedNamespace: () => checkProtectedNamespace
+});
+var checkProtectedNamespace = () => false;
+var init_protectedNamespace = () => {};
+
+// src/utils/envUtils.ts
+import { homedir } from "os";
+import { join } from "path";
+function getTeamsDir() {
+  return join(getClaudeConfigHomeDir(), "teams");
+}
+function hasNodeOption(flag) {
+  const nodeOptions = process.env.NODE_OPTIONS;
+  if (!nodeOptions) {
+    return false;
+  }
+  return nodeOptions.split(/\s+/).includes(flag);
+}
+function isEnvTruthy(envVar) {
+  if (!envVar)
+    return false;
+  if (typeof envVar === "boolean")
+    return envVar;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
+function isEnvDefinedFalsy(envVar) {
+  if (envVar === undefined)
+    return false;
+  if (typeof envVar === "boolean")
+    return !envVar;
+  if (!envVar)
+    return false;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["0", "false", "no", "off"].includes(normalizedValue);
+}
+function isBareMode() {
+  return isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) || process.argv.includes("--bare");
+}
+function parseEnvVars(rawEnvArgs) {
+  const parsedEnv = {};
+  if (rawEnvArgs) {
+    for (const envStr of rawEnvArgs) {
+      const [key, ...valueParts] = envStr.split("=");
+      if (!key || valueParts.length === 0) {
+        throw new Error(`Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`);
+      }
+      parsedEnv[key] = valueParts.join("=");
+    }
+  }
+  return parsedEnv;
+}
+function getAWSRegion() {
+  return process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+}
+function getDefaultVertexRegion() {
+  return process.env.CLOUD_ML_REGION || "us-east5";
+}
+function shouldMaintainProjectWorkingDir() {
+  return isEnvTruthy(process.env.CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR);
+}
+function isRunningOnHomespace() {
+  return process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.COO_RUNNING_ON_HOMESPACE);
+}
+function isInProtectedNamespace() {
+  if (process.env.USER_TYPE === "ant") {
+    return (init_protectedNamespace(), __toCommonJS(exports_protectedNamespace)).checkProtectedNamespace();
+  }
+  return false;
+}
+function getVertexRegionForModel(model) {
+  if (model) {
+    const match = VERTEX_REGION_OVERRIDES.find(([prefix]) => model.startsWith(prefix));
+    if (match) {
+      return process.env[match[1]] || getDefaultVertexRegion();
+    }
+  }
+  return getDefaultVertexRegion();
+}
+var getClaudeConfigHomeDir, VERTEX_REGION_OVERRIDES;
+var init_envUtils = __esm(() => {
+  init_memoize();
+  getClaudeConfigHomeDir = memoize_default(() => {
+    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC");
+  }, () => process.env.CLAUDE_CONFIG_DIR);
+  VERTEX_REGION_OVERRIDES = [
+    ["claude-haiku-4-5", "VERTEX_REGION_CLAUDE_HAIKU_4_5"],
+    ["claude-3-5-haiku", "VERTEX_REGION_CLAUDE_3_5_HAIKU"],
+    ["claude-3-5-sonnet", "VERTEX_REGION_CLAUDE_3_5_SONNET"],
+    ["claude-3-7-sonnet", "VERTEX_REGION_CLAUDE_3_7_SONNET"],
+    ["claude-opus-4-1", "VERTEX_REGION_CLAUDE_4_1_OPUS"],
+    ["claude-opus-4", "VERTEX_REGION_CLAUDE_4_0_OPUS"],
+    ["claude-sonnet-4-6", "VERTEX_REGION_CLAUDE_4_6_SONNET"],
+    ["claude-sonnet-4-5", "VERTEX_REGION_CLAUDE_4_5_SONNET"],
+    ["claude-sonnet-4", "VERTEX_REGION_CLAUDE_4_0_SONNET"]
+  ];
+});
+
+export { getClaudeConfigHomeDir, getTeamsDir, hasNodeOption, isEnvTruthy, isEnvDefinedFalsy, isBareMode, parseEnvVars, getAWSRegion, getDefaultVertexRegion, shouldMaintainProjectWorkingDir, isRunningOnHomespace, isInProtectedNamespace, getVertexRegionForModel, init_envUtils };