@costrict/csc 4.0.1

package/dist/chunk-pwwa7s62.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  init_worktreeModeEnabled,
+  isWorktreeModeEnabled
+} from "./chunk-cgfdkzhb.js";
+import"./chunk-qp2qdcda.js";
+init_worktreeModeEnabled();
+
+export {
+  isWorktreeModeEnabled
+};

package/dist/chunk-q3j9ktw6.js

@@ -0,0 +1,313 @@
+// @bun
+import {
+  getUserBinDir,
+  getXDGDataHome,
+  init_sanitization,
+  init_xdg,
+  partiallySanitizeUnicode
+} from "./chunk-4nspekjp.js";
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getInitialSettings,
+  init_growthbook,
+  init_settings1 as init_settings
+} from "./chunk-qp1047f9.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-2wz9qb4j.js";
+import {
+  init_which,
+  which
+} from "./chunk-56r79b2b.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  getErrnoCode,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-jaaxk89e.js";
+import {
+  __esm,
+  __export
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/deepLink/parseDeepLink.ts
+function containsControlChars(s) {
+  for (let i = 0;i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code <= 31 || code === 127) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseDeepLink(uri) {
+  const normalized = uri.startsWith(`${DEEP_LINK_PROTOCOL}://`) ? uri : uri.startsWith(`${DEEP_LINK_PROTOCOL}:`) ? uri.replace(`${DEEP_LINK_PROTOCOL}:`, `${DEEP_LINK_PROTOCOL}://`) : null;
+  if (!normalized) {
+    throw new Error(`Invalid deep link: expected ${DEEP_LINK_PROTOCOL}:// scheme, got "${uri}"`);
+  }
+  let url;
+  try {
+    url = new URL(normalized);
+  } catch {
+    throw new Error(`Invalid deep link URL: "${uri}"`);
+  }
+  if (url.hostname !== "open") {
+    throw new Error(`Unknown deep link action: "${url.hostname}"`);
+  }
+  const cwd = url.searchParams.get("cwd") ?? undefined;
+  const repo = url.searchParams.get("repo") ?? undefined;
+  const rawQuery = url.searchParams.get("q");
+  if (cwd && !cwd.startsWith("/") && !/^[a-zA-Z]:[/\\]/.test(cwd)) {
+    throw new Error(`Invalid cwd in deep link: must be an absolute path, got "${cwd}"`);
+  }
+  if (cwd && containsControlChars(cwd)) {
+    throw new Error("Deep link cwd contains disallowed control characters");
+  }
+  if (cwd && cwd.length > MAX_CWD_LENGTH) {
+    throw new Error(`Deep link cwd exceeds ${MAX_CWD_LENGTH} characters (got ${cwd.length})`);
+  }
+  if (repo && !REPO_SLUG_PATTERN.test(repo)) {
+    throw new Error(`Invalid repo in deep link: expected "owner/repo", got "${repo}"`);
+  }
+  let query;
+  if (rawQuery && rawQuery.trim().length > 0) {
+    query = partiallySanitizeUnicode(rawQuery.trim());
+    if (containsControlChars(query)) {
+      throw new Error("Deep link query contains disallowed control characters");
+    }
+    if (query.length > MAX_QUERY_LENGTH) {
+      throw new Error(`Deep link query exceeds ${MAX_QUERY_LENGTH} characters (got ${query.length})`);
+    }
+  }
+  return { query, cwd, repo };
+}
+var DEEP_LINK_PROTOCOL = "claude-cli", REPO_SLUG_PATTERN, MAX_QUERY_LENGTH = 5000, MAX_CWD_LENGTH = 4096;
+var init_parseDeepLink = __esm(() => {
+  init_sanitization();
+  REPO_SLUG_PATTERN = /^[\w.-]+\/[\w.-]+$/;
+});
+
+// src/utils/deepLink/registerProtocol.ts
+var exports_registerProtocol = {};
+__export(exports_registerProtocol, {
+  registerProtocolHandler: () => registerProtocolHandler,
+  isProtocolHandlerCurrent: () => isProtocolHandlerCurrent,
+  ensureDeepLinkProtocolRegistered: () => ensureDeepLinkProtocolRegistered,
+  MACOS_BUNDLE_ID: () => MACOS_BUNDLE_ID
+});
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+function linuxDesktopPath() {
+  return path.join(getXDGDataHome(), "applications", DESKTOP_FILE_NAME);
+}
+function linuxExecLine(claudePath) {
+  return `Exec="${claudePath}" --handle-uri %u`;
+}
+function windowsCommandValue(claudePath) {
+  return `"${claudePath}" --handle-uri "%1"`;
+}
+async function registerMacos(claudePath) {
+  const contentsDir = path.join(MACOS_APP_DIR, "Contents");
+  try {
+    await fs.rm(MACOS_APP_DIR, { recursive: true });
+  } catch (e) {
+    const code = getErrnoCode(e);
+    if (code !== "ENOENT") {
+      throw e;
+    }
+  }
+  await fs.mkdir(path.dirname(MACOS_SYMLINK_PATH), { recursive: true });
+  const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>${MACOS_BUNDLE_ID}</string>
+  <key>CFBundleName</key>
+  <string>${APP_NAME}</string>
+  <key>CFBundleExecutable</key>
+  <string>claude</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>LSBackgroundOnly</key>
+  <true/>
+  <key>CFBundleURLTypes</key>
+  <array>
+    <dict>
+      <key>CFBundleURLName</key>
+      <string>Claude Code Deep Link</string>
+      <key>CFBundleURLSchemes</key>
+      <array>
+        <string>${DEEP_LINK_PROTOCOL}</string>
+      </array>
+    </dict>
+  </array>
+</dict>
+</plist>`;
+  await fs.writeFile(path.join(contentsDir, "Info.plist"), infoPlist);
+  await fs.symlink(claudePath, MACOS_SYMLINK_PATH);
+  const lsregister = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+  await execFileNoThrow(lsregister, ["-R", MACOS_APP_DIR], { useCwd: false });
+  logForDebugging(`Registered ${DEEP_LINK_PROTOCOL}:// protocol handler at ${MACOS_APP_DIR}`);
+}
+async function registerLinux(claudePath) {
+  await fs.mkdir(path.dirname(linuxDesktopPath()), { recursive: true });
+  const desktopEntry = `[Desktop Entry]
+Name=${APP_NAME}
+Comment=Handle ${DEEP_LINK_PROTOCOL}:// deep links for CoStrict
+${linuxExecLine(claudePath)}
+Type=Application
+NoDisplay=true
+MimeType=x-scheme-handler/${DEEP_LINK_PROTOCOL};
+`;
+  await fs.writeFile(linuxDesktopPath(), desktopEntry);
+  const xdgMime = await which("xdg-mime");
+  if (xdgMime) {
+    const { code } = await execFileNoThrow(xdgMime, ["default", DESKTOP_FILE_NAME, `x-scheme-handler/${DEEP_LINK_PROTOCOL}`], { useCwd: false });
+    if (code !== 0) {
+      throw Object.assign(new Error(`xdg-mime exited with code ${code}`), {
+        code: "XDG_MIME_FAILED"
+      });
+    }
+  }
+  logForDebugging(`Registered ${DEEP_LINK_PROTOCOL}:// protocol handler at ${linuxDesktopPath()}`);
+}
+async function registerWindows(claudePath) {
+  for (const args of [
+    ["add", WINDOWS_REG_KEY, "/ve", "/d", `URL:${APP_NAME}`, "/f"],
+    ["add", WINDOWS_REG_KEY, "/v", "URL Protocol", "/d", "", "/f"],
+    [
+      "add",
+      WINDOWS_COMMAND_KEY,
+      "/ve",
+      "/d",
+      windowsCommandValue(claudePath),
+      "/f"
+    ]
+  ]) {
+    const { code } = await execFileNoThrow("reg", args, { useCwd: false });
+    if (code !== 0) {
+      throw Object.assign(new Error(`reg add exited with code ${code}`), {
+        code: "REG_FAILED"
+      });
+    }
+  }
+  logForDebugging(`Registered ${DEEP_LINK_PROTOCOL}:// protocol handler in Windows registry`);
+}
+async function registerProtocolHandler(claudePath) {
+  const resolved = claudePath ?? await resolveClaudePath();
+  switch (process.platform) {
+    case "darwin":
+      await registerMacos(resolved);
+      break;
+    case "linux":
+      await registerLinux(resolved);
+      break;
+    case "win32":
+      await registerWindows(resolved);
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function resolveClaudePath() {
+  const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
+  const stablePath = path.join(getUserBinDir(), binaryName);
+  try {
+    await fs.realpath(stablePath);
+    return stablePath;
+  } catch {
+    return process.execPath;
+  }
+}
+async function isProtocolHandlerCurrent(claudePath) {
+  try {
+    switch (process.platform) {
+      case "darwin": {
+        const target = await fs.readlink(MACOS_SYMLINK_PATH);
+        return target === claudePath;
+      }
+      case "linux": {
+        const content = await fs.readFile(linuxDesktopPath(), "utf8");
+        return content.includes(linuxExecLine(claudePath));
+      }
+      case "win32": {
+        const { stdout, code } = await execFileNoThrow("reg", ["query", WINDOWS_COMMAND_KEY, "/ve"], { useCwd: false });
+        return code === 0 && stdout.includes(windowsCommandValue(claudePath));
+      }
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
+async function ensureDeepLinkProtocolRegistered() {
+  if (getInitialSettings().disableDeepLinkRegistration === "disable") {
+    return;
+  }
+  if (!getFeatureValue_CACHED_MAY_BE_STALE("tengu_lodestone_enabled", false)) {
+    return;
+  }
+  const claudePath = await resolveClaudePath();
+  if (await isProtocolHandlerCurrent(claudePath)) {
+    return;
+  }
+  const failureMarkerPath = path.join(getClaudeConfigHomeDir(), ".deep-link-register-failed");
+  try {
+    const stat = await fs.stat(failureMarkerPath);
+    if (Date.now() - stat.mtimeMs < FAILURE_BACKOFF_MS) {
+      return;
+    }
+  } catch {}
+  try {
+    await registerProtocolHandler(claudePath);
+    logEvent("tengu_deep_link_registered", { success: true });
+    logForDebugging("Auto-registered claude-cli:// deep link protocol handler");
+    await fs.rm(failureMarkerPath, { force: true }).catch(() => {});
+  } catch (error) {
+    const code = getErrnoCode(error);
+    logEvent("tengu_deep_link_registered", {
+      success: false,
+      error_code: code
+    });
+    logForDebugging(`Failed to auto-register deep link protocol handler: ${error instanceof Error ? error.message : String(error)}`, { level: "warn" });
+    if (code === "EACCES" || code === "ENOSPC") {
+      await fs.writeFile(failureMarkerPath, "").catch(() => {});
+    }
+  }
+}
+var MACOS_BUNDLE_ID = "com.anthropic.claude-code-url-handler", APP_NAME = "CoStrict URL Handler", DESKTOP_FILE_NAME = "claude-code-url-handler.desktop", MACOS_APP_NAME = "CoStrict URL Handler.app", MACOS_APP_DIR, MACOS_SYMLINK_PATH, WINDOWS_REG_KEY, WINDOWS_COMMAND_KEY, FAILURE_BACKOFF_MS;
+var init_registerProtocol = __esm(() => {
+  init_parseDeepLink();
+  init_growthbook();
+  init_analytics();
+  init_debug();
+  init_envUtils();
+  init_errors();
+  init_execFileNoThrow();
+  init_settings();
+  init_which();
+  init_xdg();
+  MACOS_APP_DIR = path.join(os.homedir(), "Applications", MACOS_APP_NAME);
+  MACOS_SYMLINK_PATH = path.join(MACOS_APP_DIR, "Contents", "MacOS", "claude");
+  WINDOWS_REG_KEY = `HKEY_CURRENT_USER\\Software\\Classes\\${DEEP_LINK_PROTOCOL}`;
+  WINDOWS_COMMAND_KEY = `${WINDOWS_REG_KEY}\\shell\\open\\command`;
+  FAILURE_BACKOFF_MS = 24 * 60 * 60 * 1000;
+});
+
+export { parseDeepLink, init_parseDeepLink, MACOS_BUNDLE_ID, exports_registerProtocol, init_registerProtocol };

package/dist/chunk-q4t5gjz6.js

@@ -0,0 +1,180 @@
+// @bun
+import {
+  AGENT_COLORS,
+  getTranscriptPath,
+  init_agentColorManager,
+  init_sessionStorage,
+  saveAgentColor
+} from "./chunk-97kwfkef.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-s2jznn2t.js";
+import"./chunk-zejm280k.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-enz148g9.js";
+import"./chunk-jmt3t5ka.js";
+import"./chunk-3x2jaxpw.js";
+import"./chunk-wm26jyc3.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-3vxgde8h.js";
+import"./chunk-9k8qsaph.js";
+import"./chunk-bnrctxq5.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import"./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-3sj7jkgr.js";
+import"./chunk-62xkxk9z.js";
+import"./chunk-ers3hn71.js";
+import"./chunk-5krq9sjq.js";
+import"./chunk-85em0j2s.js";
+import"./chunk-dmfnhfbm.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-ew2qn2ct.js";
+import"./chunk-3bes9fg8.js";
+import"./chunk-ygj29dpk.js";
+import"./chunk-6km733xr.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-z915v06p.js";
+import"./chunk-rw0b3wq4.js";
+import"./chunk-ms3y5kf0.js";
+import"./chunk-pfc94kdv.js";
+import"./chunk-kwdta9bw.js";
+import"./chunk-3dy7fxmg.js";
+import"./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import {
+  init_teammate,
+  isTeammate
+} from "./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-xzc7k2hh.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-yjkamwzv.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-z6e5jp2w.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/color/color.ts
+async function call(onDone, context, args) {
+  if (isTeammate()) {
+    onDone("Cannot set color: This session is a swarm teammate. Teammate colors are assigned by the team leader.", { display: "system" });
+    return null;
+  }
+  if (!args || args.trim() === "") {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Please provide a color. Available colors: ${colorList}, default`, {
+      display: "system"
+    });
+    return null;
+  }
+  const colorArg = args.trim().toLowerCase();
+  if (RESET_ALIASES.includes(colorArg)) {
+    const sessionId2 = getSessionId();
+    const fullPath2 = getTranscriptPath();
+    await saveAgentColor(sessionId2, "default", fullPath2);
+    context.setAppState((prev) => ({
+      ...prev,
+      standaloneAgentContext: {
+        ...prev.standaloneAgentContext,
+        name: prev.standaloneAgentContext?.name ?? "",
+        color: undefined
+      }
+    }));
+    onDone("Session color reset to default", { display: "system" });
+    return null;
+  }
+  if (!AGENT_COLORS.includes(colorArg)) {
+    const colorList = AGENT_COLORS.join(", ");
+    onDone(`Invalid color "${colorArg}". Available colors: ${colorList}, default`, { display: "system" });
+    return null;
+  }
+  const sessionId = getSessionId();
+  const fullPath = getTranscriptPath();
+  await saveAgentColor(sessionId, colorArg, fullPath);
+  context.setAppState((prev) => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: prev.standaloneAgentContext?.name ?? "",
+      color: colorArg
+    }
+  }));
+  onDone(`Session color set to: ${colorArg}`, { display: "system" });
+  return null;
+}
+var RESET_ALIASES;
+var init_color = __esm(() => {
+  init_state();
+  init_agentColorManager();
+  init_sessionStorage();
+  init_teammate();
+  RESET_ALIASES = ["default", "reset", "none", "gray", "grey"];
+});
+init_color();
+
+export {
+  call
+};

package/dist/chunk-q7tpyeb3.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  cacheKeys,
+  init_fileStateCache
+} from "./chunk-j5bth84e.js";
+import"./chunk-qnfx3qtx.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-b81hd3m6.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/files/files.ts
+import { relative } from "path";
+async function call(_args, context) {
+  const files = context.readFileState ? cacheKeys(context.readFileState) : [];
+  if (files.length === 0) {
+    return { type: "text", value: "No files in context" };
+  }
+  const fileList = files.map((file) => relative(getCwd(), file)).join(`
+`);
+  return { type: "text", value: `Files in context:
+${fileList}` };
+}
+var init_files = __esm(() => {
+  init_cwd();
+  init_fileStateCache();
+});
+init_files();
+
+export {
+  call
+};

package/dist/chunk-q82r31er.js

@@ -0,0 +1,151 @@
+// @bun
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-jaaxk89e.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/constants/oauth.ts
+function getOauthConfigType() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.USE_LOCAL_OAUTH)) {
+      return "local";
+    }
+    if (isEnvTruthy(process.env.USE_STAGING_OAUTH)) {
+      return "staging";
+    }
+  }
+  return "prod";
+}
+function fileSuffixForOauthConfig() {
+  if (process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL) {
+    return "-custom-oauth";
+  }
+  switch (getOauthConfigType()) {
+    case "local":
+      return "-local-oauth";
+    case "staging":
+      return "-staging-oauth";
+    case "prod":
+      return "";
+  }
+}
+function getLocalOauthConfig() {
+  const api = process.env.CLAUDE_LOCAL_OAUTH_API_BASE?.replace(/\/$/, "") ?? "http://localhost:8000";
+  const apps = process.env.CLAUDE_LOCAL_OAUTH_APPS_BASE?.replace(/\/$/, "") ?? "http://localhost:4000";
+  const consoleBase = process.env.CLAUDE_LOCAL_OAUTH_CONSOLE_BASE?.replace(/\/$/, "") ?? "http://localhost:3000";
+  return {
+    BASE_API_URL: api,
+    CONSOLE_AUTHORIZE_URL: `${consoleBase}/oauth/authorize`,
+    CLAUDE_AI_AUTHORIZE_URL: `${apps}/oauth/authorize`,
+    CLAUDE_AI_ORIGIN: apps,
+    TOKEN_URL: `${api}/v1/oauth/token`,
+    API_KEY_URL: `${api}/api/oauth/claude_cli/create_api_key`,
+    ROLES_URL: `${api}/api/oauth/claude_cli/roles`,
+    CONSOLE_SUCCESS_URL: `${consoleBase}/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code`,
+    CLAUDEAI_SUCCESS_URL: `${consoleBase}/oauth/code/success?app=claude-code`,
+    MANUAL_REDIRECT_URL: `${consoleBase}/oauth/code/callback`,
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-local-oauth",
+    MCP_PROXY_URL: "http://localhost:8205",
+    MCP_PROXY_PATH: "/v1/toolbox/shttp/mcp/{server_id}"
+  };
+}
+function getOauthConfig() {
+  let config = (() => {
+    switch (getOauthConfigType()) {
+      case "local":
+        return getLocalOauthConfig();
+      case "staging":
+        return STAGING_OAUTH_CONFIG ?? PROD_OAUTH_CONFIG;
+      case "prod":
+        return PROD_OAUTH_CONFIG;
+    }
+  })();
+  const oauthBaseUrl = process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL;
+  if (oauthBaseUrl) {
+    const base = oauthBaseUrl.replace(/\/$/, "");
+    if (!ALLOWED_OAUTH_BASE_URLS.includes(base)) {
+      throw new Error("CLAUDE_CODE_CUSTOM_OAUTH_URL is not an approved endpoint.");
+    }
+    config = {
+      ...config,
+      BASE_API_URL: base,
+      CONSOLE_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_ORIGIN: base,
+      TOKEN_URL: `${base}/v1/oauth/token`,
+      API_KEY_URL: `${base}/api/oauth/claude_cli/create_api_key`,
+      ROLES_URL: `${base}/api/oauth/claude_cli/roles`,
+      CONSOLE_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      CLAUDEAI_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      MANUAL_REDIRECT_URL: `${base}/oauth/code/callback`,
+      OAUTH_FILE_SUFFIX: "-custom-oauth"
+    };
+  }
+  const clientIdOverride = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID;
+  if (clientIdOverride) {
+    config = {
+      ...config,
+      CLIENT_ID: clientIdOverride
+    };
+  }
+  return config;
+}
+var CLAUDE_AI_INFERENCE_SCOPE = "user:inference", CLAUDE_AI_PROFILE_SCOPE = "user:profile", CONSOLE_SCOPE = "org:create_api_key", OAUTH_BETA_HEADER = "oauth-2025-04-20", CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, PROD_OAUTH_CONFIG, MCP_CLIENT_METADATA_URL = "https://claude.ai/oauth/claude-code-client-metadata", STAGING_OAUTH_CONFIG, ALLOWED_OAUTH_BASE_URLS;
+var init_oauth = __esm(() => {
+  init_envUtils();
+  CONSOLE_OAUTH_SCOPES = [
+    CONSOLE_SCOPE,
+    CLAUDE_AI_PROFILE_SCOPE
+  ];
+  CLAUDE_AI_OAUTH_SCOPES = [
+    CLAUDE_AI_PROFILE_SCOPE,
+    CLAUDE_AI_INFERENCE_SCOPE,
+    "user:sessions:claude_code",
+    "user:mcp_servers",
+    "user:file_upload"
+  ];
+  ALL_OAUTH_SCOPES = Array.from(new Set([...CONSOLE_OAUTH_SCOPES, ...CLAUDE_AI_OAUTH_SCOPES]));
+  PROD_OAUTH_CONFIG = {
+    BASE_API_URL: "https://api.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.claude.com/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude.com/cai/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude.ai",
+    TOKEN_URL: "https://platform.claude.com/v1/oauth/token",
+    API_KEY_URL: "https://api.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.claude.com/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.claude.com/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.claude.com/oauth/code/callback",
+    CLIENT_ID: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+    OAUTH_FILE_SUFFIX: "",
+    MCP_PROXY_URL: "https://mcp-proxy.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  };
+  STAGING_OAUTH_CONFIG = process.env.USER_TYPE === "ant" ? {
+    BASE_API_URL: "https://api-staging.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude-ai.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude-ai.staging.ant.dev",
+    TOKEN_URL: "https://platform.staging.ant.dev/v1/oauth/token",
+    API_KEY_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.staging.ant.dev/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.staging.ant.dev/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.staging.ant.dev/oauth/code/callback",
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-staging-oauth",
+    MCP_PROXY_URL: "https://mcp-proxy-staging.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  } : undefined;
+  ALLOWED_OAUTH_BASE_URLS = [
+    "https://beacon.claude-ai.staging.ant.dev",
+    "https://claude.fedstart.com",
+    "https://claude-staging.fedstart.com"
+  ];
+});
+
+export { fileSuffixForOauthConfig, CLAUDE_AI_INFERENCE_SCOPE, CLAUDE_AI_PROFILE_SCOPE, OAUTH_BETA_HEADER, CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, MCP_CLIENT_METADATA_URL, getOauthConfig, init_oauth };