@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-ALDTFNZ3.js

@@ -0,0 +1,150 @@
+// src/utils/safe-rm.ts
+import { lstatSync, realpathSync } from "fs";
+import { lstat, rm, unlink } from "fs/promises";
+import { isAbsolute, relative, resolve } from "path";
+function canonicalizePath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+}
+function isLexicallyWithin(candidate, root) {
+  const rel = relative(resolve(root), resolve(candidate));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function isPathContainedIn(candidatePath, protectedPath) {
+  const normalizedCandidate = resolve(candidatePath);
+  const normalizedProtected = resolve(protectedPath);
+  const rel = relative(normalizedCandidate, normalizedProtected);
+  if (rel === "") return true;
+  if (rel.startsWith("..")) return false;
+  if (resolve(rel) === rel) return false;
+  return true;
+}
+function isDualContainedInManagedRoots(candidate, managedRoots) {
+  if (managedRoots.length === 0) {
+    return false;
+  }
+  const lexical = resolve(candidate);
+  const canonical = canonicalizePath(candidate);
+  return managedRoots.some((root) => {
+    const lexicalRoot = resolve(root);
+    const canonicalRoot = canonicalizePath(root);
+    return (isLexicallyWithin(lexical, lexicalRoot) || isLexicallyWithin(lexical, canonicalRoot)) && isLexicallyWithin(canonical, canonicalRoot);
+  });
+}
+function refuseProtected(candidate, protectedPaths) {
+  for (const protectedPath of protectedPaths) {
+    const lexicalProtected = resolve(protectedPath);
+    const canonicalProtected = canonicalizePath(protectedPath);
+    if (isPathContainedIn(candidate, lexicalProtected) || isPathContainedIn(candidate, canonicalProtected)) {
+      return {
+        deleted: false,
+        reason: `Refusing to delete ${candidate}: it is the same as or an ancestor of protected path ${canonicalProtected}`
+      };
+    }
+  }
+  return null;
+}
+async function safeRmDir(targetPath, options) {
+  const lexical = resolve(targetPath);
+  const managedRoots = options.managedRoots ?? [];
+  if (managedRoots.length === 0) {
+    return {
+      deleted: false,
+      reason: `Refusing to delete ${lexical}: recursive deletion requires an explicit managed root`
+    };
+  }
+  let initialStat = null;
+  try {
+    initialStat = lstatSync(lexical);
+  } catch {
+    initialStat = null;
+  }
+  if (initialStat?.isSymbolicLink()) {
+    const underManaged = managedRoots.some((root) => isLexicallyWithin(lexical, resolve(root)));
+    if (!underManaged) {
+      return {
+        deleted: false,
+        reason: `Refusing to unlink symlink ${lexical}: path is not lexically contained in any managed root`
+      };
+    }
+    const protectedHit = refuseProtected(lexical, options.protectedPaths);
+    if (protectedHit) {
+      return protectedHit;
+    }
+    if (!options.dryRun) {
+      await unlink(lexical);
+    }
+    return { deleted: true };
+  }
+  if (!isDualContainedInManagedRoots(lexical, managedRoots)) {
+    return {
+      deleted: false,
+      reason: `Refusing to delete ${lexical}: lexical path and canonical realpath must both be contained in an explicit managed root`
+    };
+  }
+  const canonical = canonicalizePath(lexical);
+  for (const candidate of /* @__PURE__ */ new Set([lexical, canonical])) {
+    const protectedHit = refuseProtected(candidate, options.protectedPaths);
+    if (protectedHit) {
+      return protectedHit;
+    }
+  }
+  if (!options.dryRun) {
+    let preDeleteStat;
+    try {
+      preDeleteStat = await lstat(lexical);
+    } catch (error) {
+      return {
+        deleted: false,
+        reason: `Refusing to delete ${lexical}: path disappeared before removal (${error instanceof Error ? error.message : String(error)})`
+      };
+    }
+    if (preDeleteStat.isSymbolicLink()) {
+      const underManaged = managedRoots.some((root) => isLexicallyWithin(lexical, resolve(root)));
+      if (!underManaged) {
+        return {
+          deleted: false,
+          reason: `Refusing to unlink symlink ${lexical}: path is not lexically contained in any managed root`
+        };
+      }
+      const protectedHit = refuseProtected(lexical, options.protectedPaths);
+      if (protectedHit) {
+        return protectedHit;
+      }
+      await unlink(lexical);
+      return { deleted: true };
+    }
+    if (!isDualContainedInManagedRoots(lexical, managedRoots)) {
+      return {
+        deleted: false,
+        reason: `Refusing to delete ${lexical}: containment check failed immediately before removal`
+      };
+    }
+    const deletionCanonical = canonicalizePath(lexical);
+    if (deletionCanonical !== canonical) {
+      return {
+        deleted: false,
+        reason: `Refusing to delete ${targetPath}: canonical path changed from ${canonical} to ${deletionCanonical}`
+      };
+    }
+    for (const candidate of /* @__PURE__ */ new Set([lexical, deletionCanonical])) {
+      const protectedHit = refuseProtected(candidate, options.protectedPaths);
+      if (protectedHit) {
+        return protectedHit;
+      }
+    }
+    await rm(lexical, { recursive: true, force: true });
+  }
+  return { deleted: true };
+}
+
+export {
+  canonicalizePath,
+  isLexicallyWithin,
+  isDualContainedInManagedRoots,
+  safeRmDir
+};
+//# sourceMappingURL=chunk-ALDTFNZ3.js.map

package/dist/chunk-ARARVIZK.js

@@ -0,0 +1,281 @@
+import {
+  ConfigManager
+} from "./chunk-W4BAIQ6L.js";
+import {
+  normalizeJudgeModel
+} from "./chunk-PFCXFO7A.js";
+import {
+  DEPRECATED_JUDGE_MODELS_ALIASES,
+  JUDGE_SPECIFICITY,
+  JUDGE_TYPE_TO_CONFIG_KEY,
+  reconcileJudgePair,
+  resolveCanonicalJudgeRoles,
+  resolveCanonicalJudgeTier,
+  resolveDefaultJudgeProvider,
+  resolveJudgeConfig
+} from "./chunk-C3DH3NCY.js";
+import {
+  JUDGE_SCORING_CONFIG
+} from "./chunk-SVUNZOPG.js";
+import {
+  ProviderRegistry,
+  isConfigValidityError
+} from "./chunk-QJ6OEH4K.js";
+import {
+  BUILD_JUDGE_MODEL,
+  BUILD_JUDGE_PROVIDER,
+  debugLog,
+  isDebugMode,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/judge-tier-selector.ts
+function normalizeExplicitJudgeModel(model, cwd = process.cwd()) {
+  if (typeof model !== "string" || model.trim().length === 0) return void 0;
+  const input = model.trim();
+  const { model: normalized, warnings, provider } = normalizeJudgeModel(input, process.env, cwd);
+  if (warnings.length > 0) {
+    console.warn(
+      `[AI Judge Model] provider=${provider ?? "unknown"} input=${input} warnings=${warnings.join("; ")}`
+    );
+  }
+  return normalized;
+}
+function canFillArbiterRoles(providerId) {
+  const caps = ProviderRegistry.getJudgeCapabilities(providerId);
+  return caps.canJudge && caps.canArbitrate;
+}
+function availableJudgeModelsHint() {
+  const capable = ProviderRegistry.getEnabledProviders().filter((provider) => canFillArbiterRoles(provider.id)).map((provider) => provider.id);
+  const aliases = DEPRECATED_JUDGE_MODELS_ALIASES.filter((alias) => canFillArbiterRoles(alias));
+  if (capable.length > 0 && aliases.length > 0) {
+    return `${capable.join(", ")} (deprecated aliases: ${aliases.join(", ")})`;
+  }
+  if (capable.length > 0) {
+    return capable.join(", ");
+  }
+  if (aliases.length > 0) {
+    return `deprecated aliases: ${aliases.join(", ")}`;
+  }
+  return "(none)";
+}
+function parseJudgeModelsShorthand(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    throw new Error(
+      `Unknown judge models "${value}". Available values: ${availableJudgeModelsHint()}`
+    );
+  }
+  if (canFillArbiterRoles(normalized)) {
+    return normalized;
+  }
+  throw new Error(
+    `Unknown judge models "${value}". Available values: ${availableJudgeModelsHint()}`
+  );
+}
+function shorthandFromEnv() {
+  if (readEnv(BUILD_JUDGE_PROVIDER).value || readEnv(BUILD_JUDGE_MODEL).value) return void 0;
+  return process.env.BUILD_JUDGE_MODELS;
+}
+function getConfiguredJudgeModels(value, cwd) {
+  if (process.env.BUILD_JUDGE_MODEL_PLAN) {
+    throw new Error(
+      "BUILD_JUDGE_MODEL_PLAN has been removed. Use BUILD_JUDGE_MODELS with a registered judge-capable provider (deprecated aliases: claude, codex)."
+    );
+  }
+  const explicit = value ?? shorthandFromEnv();
+  const configuredDefault = JUDGE_SCORING_CONFIG.defaultJudgeModels;
+  const raw = explicit ?? (configuredDefault === "auto" ? resolveDefaultJudgeProvider(void 0, cwd).value : configuredDefault);
+  return {
+    judgeModels: parseJudgeModelsShorthand(raw),
+    source: explicit ? "shorthand" : "default"
+  };
+}
+var OVERRIDE_ROLE_BY_TYPE = {
+  ai: "ai",
+  "multi-lens": "multi-lens"
+};
+var ROLE_BY_TYPE = {
+  ai: "ai-primary",
+  "multi-lens": "multi-lens-technical"
+};
+function scopedOverrideFor(judgeType, options) {
+  const role = OVERRIDE_ROLE_BY_TYPE[judgeType];
+  return options.scopedModelOverrides?.filter((override) => override.role === role).at(-1);
+}
+function explicitAiModel(judgeType, options) {
+  if (judgeType !== "ai") return void 0;
+  return options.normalizeExplicitModel ? options.normalizeExplicitModel(options.explicitModel) : options.explicitModel;
+}
+function judgeCliOverlay(judgeType, options = {}) {
+  const override = scopedOverrideFor(judgeType, options);
+  if (override) {
+    return {
+      judgeProvider: override.provider,
+      judgeModel: ProviderRegistry.resolveModel(override.provider, override.model)
+    };
+  }
+  const shorthand = options.judgeModels ?? shorthandFromEnv();
+  const provider = shorthand === void 0 ? void 0 : parseJudgeModelsShorthand(shorthand);
+  const model = explicitAiModel(judgeType, options);
+  if (!provider || !model) {
+    return {
+      ...provider ? { judgeProvider: provider } : {},
+      ...model ? { judgeModel: model } : {}
+    };
+  }
+  const reconciled = reconcileJudgePair(
+    { value: provider, specificity: JUDGE_SPECIFICITY.plan },
+    { value: model, specificity: JUDGE_SPECIFICITY.cli }
+  );
+  return { judgeProvider: reconciled.provider, judgeModel: reconciled.model ?? model };
+}
+function isTierSpecificPath(path, judgeType) {
+  return path?.includes(`judge.${JUDGE_TYPE_TO_CONFIG_KEY[judgeType]}.`) === true;
+}
+function configFollowOverlay(options) {
+  if (scopedOverrideFor("ai", options) || explicitAiModel("ai", options)) return void 0;
+  const cwd = options.cwd ?? process.cwd();
+  const ai = resolveJudgeConfig(judgeCliOverlay("ai", options), cwd, "ai");
+  if (!isTierSpecificPath(ai.provider.sourcePath, "ai") && !isTierSpecificPath(ai.model.sourcePath, "ai") && !isTierSpecificPath(ai.reasoningEffort?.sourcePath, "ai")) {
+    return void 0;
+  }
+  const own = resolveJudgeConfig(judgeCliOverlay("multi-lens", options), cwd, "multi-lens");
+  if (isTierSpecificPath(own.provider.sourcePath, "multi-lens") || isTierSpecificPath(own.model.sourcePath, "multi-lens")) {
+    return void 0;
+  }
+  const ownEffort = isTierSpecificPath(own.reasoningEffort?.sourcePath, "multi-lens");
+  return {
+    judgeProvider: ai.provider.value,
+    judgeModel: ai.model.value,
+    ...ai.reasoningEffort && !ownEffort ? { judgeReasoningEffort: ai.reasoningEffort.value } : {}
+  };
+}
+function resolveTierBinding(judgeType, options) {
+  const followed = judgeType === "multi-lens" && !scopedOverrideFor("multi-lens", options) ? configFollowOverlay(options) : void 0;
+  const cli = followed ?? judgeCliOverlay(judgeType, options);
+  const cwd = options.cwd ?? process.cwd();
+  const resolved = resolveJudgeConfig(cli, cwd, judgeType);
+  const fromDefault = resolved.provider.sourcePath?.startsWith("judge-default:") === true;
+  const source = scopedOverrideFor(judgeType, options) ? "scoped_override" : explicitAiModel(judgeType, options) ? "legacy_ai_judge_model" : resolved.provider.source === "cli" && !followed ? "shorthand" : fromDefault ? "default" : "config";
+  const provider = resolved.provider.value;
+  const explicit = resolved.model.source !== "registry" && resolved.model.source !== "fallback";
+  const reasoningEffort = resolved.reasoningEffort?.value;
+  return {
+    spec: { provider, modelRole: "judge_primary", model: resolved.model.value, source, explicit },
+    ...reasoningEffort ? { reasoningEffort } : {}
+  };
+}
+function inheritedMultiLensOverride(options) {
+  if (scopedOverrideFor("multi-lens", options)) return void 0;
+  if (!scopedOverrideFor("ai", options) && !explicitAiModel("ai", options)) return void 0;
+  const { spec } = resolveTierBinding("ai", options);
+  return spec.model ? `multi-lens=${spec.provider}:${spec.model}` : void 0;
+}
+function resolveJudgeTierProvider(judgeType, options = {}) {
+  return resolveTierBinding(judgeType, options).spec.provider;
+}
+function toCanonicalOptions(options, judgeTypes) {
+  const configured = getConfiguredJudgeModels(options.judgeModels, options.cwd ?? process.cwd());
+  const plan = {};
+  const efforts = {};
+  for (const judgeType of judgeTypes) {
+    const { spec, reasoningEffort } = resolveTierBinding(judgeType, options);
+    plan[ROLE_BY_TYPE[judgeType]] = spec;
+    if (reasoningEffort) efforts[judgeType] = reasoningEffort;
+  }
+  return {
+    canonical: {
+      planId: configured.judgeModels,
+      planSource: configured.source,
+      plan,
+      explicitModel: options.explicitModel,
+      normalizeExplicitModel: options.normalizeExplicitModel,
+      scopedModelOverrides: options.scopedModelOverrides,
+      allowUnsafeModel: options.allowUnsafeModel,
+      activeJudgeTypes: judgeTypes
+    },
+    efforts
+  };
+}
+var ALL_JUDGE_TYPES = ["ai", "multi-lens"];
+function resolveJudgeModelRoles(options = {}) {
+  const { canonical } = toCanonicalOptions(options, options.activeJudgeTypes ?? ALL_JUDGE_TYPES);
+  const resolved = resolveCanonicalJudgeRoles(canonical);
+  return {
+    ...resolved,
+    judgeModels: resolved.judgeModels
+  };
+}
+function judgeRunOptions(settings) {
+  return {
+    provider: settings.provider,
+    model: settings.model,
+    thinkingBudgetTokens: settings.thinkingBudgetTokens,
+    requireThinking: settings.requireThinking,
+    binding: settings.provider && settings.model ? {
+      provider: settings.provider,
+      model: settings.model,
+      ...settings.reasoningEffort ? { reasoningEffort: settings.reasoningEffort } : {}
+    } : void 0
+  };
+}
+async function loadJudgeConfig(cwd) {
+  const existingLoad = inFlightJudgeConfigLoads.get(cwd);
+  if (existingLoad) return existingLoad;
+  if (judgeConfigManagerState?.cwd !== cwd) {
+    judgeConfigManagerState = {
+      cwd,
+      manager: new ConfigManager({ cwd, enableCache: true })
+    };
+  }
+  const load = loadJudgeConfigWithManager(judgeConfigManagerState.manager);
+  inFlightJudgeConfigLoads.set(cwd, load);
+  try {
+    return await load;
+  } finally {
+    if (inFlightJudgeConfigLoads.get(cwd) === load) {
+      inFlightJudgeConfigLoads.delete(cwd);
+    }
+  }
+}
+var judgeConfigManagerState;
+var inFlightJudgeConfigLoads = /* @__PURE__ */ new Map();
+async function loadJudgeConfigWithManager(manager) {
+  try {
+    const resolved = await manager.loadConfig();
+    return resolved.config.judge;
+  } catch (error) {
+    if (isConfigValidityError(error)) {
+      throw error;
+    }
+    if (isDebugMode()) {
+      debugLog(
+        `[JudgeCoordinator] Failed to load judge config: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return void 0;
+  }
+}
+async function resolveJudgeTierSettings(judgeType, options = {}) {
+  const judgeConfig = await loadJudgeConfig(options.cwd ?? process.cwd());
+  const { canonical, efforts } = toCanonicalOptions(options, [judgeType]);
+  return resolveCanonicalJudgeTier({
+    ...canonical,
+    judgeType,
+    judgeConfig,
+    reasoningEffort: efforts[judgeType]
+  });
+}
+
+export {
+  normalizeExplicitJudgeModel,
+  parseJudgeModelsShorthand,
+  judgeCliOverlay,
+  inheritedMultiLensOverride,
+  resolveJudgeTierProvider,
+  resolveJudgeModelRoles,
+  judgeRunOptions,
+  resolveJudgeTierSettings
+};
+//# sourceMappingURL=chunk-ARARVIZK.js.map

package/dist/chunk-ATBM6AW5.js

@@ -0,0 +1,53 @@
+import {
+  collectDeclaredStageTargets
+} from "./chunk-45KUJBDI.js";
+
+// src/automation/flywheel-safety.ts
+function extractStageFootprint(stage) {
+  return { declaredPaths: collectDeclaredStageTargets(stage) };
+}
+function areFootprintsDisjoint(a, b) {
+  if (a.declaredPaths.length === 0 || b.declaredPaths.length === 0) {
+    return true;
+  }
+  for (const pathA of a.declaredPaths) {
+    for (const pathB of b.declaredPaths) {
+      if (pathA === pathB) {
+        return false;
+      }
+      if (pathA.startsWith(`${pathB}/`) || pathB.startsWith(`${pathA}/`)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function partitionByDisjointness(stages) {
+  if (stages.length === 0) return [];
+  if (stages.length === 1) return [stages];
+  const groups = [];
+  for (const stageCtx of stages) {
+    let placed = false;
+    for (const group of groups) {
+      const isDisjoint = group.every(
+        (member) => areFootprintsDisjoint(stageCtx.footprint, member.footprint)
+      );
+      if (isDisjoint) {
+        group.push(stageCtx);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      groups.push([stageCtx]);
+    }
+  }
+  return groups;
+}
+
+export {
+  extractStageFootprint,
+  areFootprintsDisjoint,
+  partitionByDisjointness
+};
+//# sourceMappingURL=chunk-ATBM6AW5.js.map

package/dist/chunk-ATKEKM3E.js

@@ -0,0 +1,206 @@
+import {
+  resolveGeminiUserDir
+} from "./chunk-S6I4KISU.js";
+import {
+  createEngineMetadata
+} from "./chunk-4EBSXZ73.js";
+import {
+  BaseProviderAuth,
+  loadProviderCredentialsConfig,
+  resolveCredential
+} from "./chunk-33IGPPUI.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/core/providers/gemini/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getApiKeyPath: () => getApiKeyPath,
+  getGeminiAuthPaths: () => getGeminiAuthPaths,
+  getGeminiCliSelectedAuthType: () => getGeminiCliSelectedAuthType,
+  getResolvedGeminiApiKey: () => getResolvedGeminiApiKey,
+  isAuthenticated: () => isAuthenticated,
+  isAuthenticatedTriState: () => isAuthenticatedTriState,
+  isGeminiCliOAuthSelected: () => isGeminiCliOAuthSelected,
+  resolveGeminiConfigDir: () => resolveGeminiConfigDir
+});
+import { existsSync } from "fs";
+import { homedir } from "os";
+import * as path from "path";
+
+// src/core/providers/gemini/metadata.ts
+var metadata = createEngineMetadata(
+  {
+    id: "gemini",
+    name: "Gemini",
+    description: "Authenticate with Google Gemini AI",
+    cliCommand: "gemini",
+    cliBinary: "gemini",
+    installCommand: "npm install -g @google/gemini-cli",
+    authHint: "export GOOGLE_API_KEY=...  # or GEMINI_API_KEY",
+    setupCommand: "build provider setup --providers gemini",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "gemini-cli",
+    experimental: true
+  },
+  ["experimental"]
+);
+
+// src/core/providers/gemini/auth.ts
+var GeminiAuth = class extends BaseProviderAuth {
+  metadata = metadata;
+  defaultConfigSubdir = "gemini";
+  configDirEnvVar = "GEMINI_CONFIG_DIR";
+  /**
+   * Environment variables for Gemini credentials
+   */
+  getCredentialEnvVars() {
+    return ["GEMINI_API_KEY", "GOOGLE_API_KEY"];
+  }
+  /**
+   * Resolves the Gemini config directory
+   */
+  resolveConfigDir(options) {
+    if (options?.geminiConfigDir !== void 0) {
+      return super.resolveConfigDir({
+        ...options,
+        configDir: options.geminiConfigDir
+      });
+    }
+    const { profile: _profile, ...restOptions } = options ?? {};
+    return super.resolveConfigDir(restOptions);
+  }
+  /**
+   * Convert GeminiAuthOptions to base options with CLI credentials
+   */
+  toBaseOptions(options) {
+    if (!options) return {};
+    return {
+      ...options,
+      cliCredentials: options.apiKey ? {
+        apiKey: options.apiKey
+      } : options.cliCredentials
+    };
+  }
+  getAuthFilePath(configDir) {
+    return path.join(configDir, ".api_key");
+  }
+  /**
+   * Best-effort check for whether Gemini is authenticated.
+   *
+   * Uses multi-source credential resolution with priority:
+   * 1. CLI args (--api-key)
+   * 2. Config file (.api_key or OAuth)
+   * 3. Environment variables (GEMINI_API_KEY, GOOGLE_API_KEY)
+   *
+   * This is used only for UX (e.g. "login" vs "logout" prompts). It does NOT
+   * gate normal execution – the runners always attempt to invoke the Gemini
+   * CLI and let it report authentication errors directly.
+   */
+  async isAuthenticated(options) {
+    const baseOptions = this.toBaseOptions(options);
+    const baseResult = await super.isAuthenticated(baseOptions);
+    if (baseResult) {
+      return true;
+    }
+    const explicitConfigDir = options?.configDir !== void 0 || options?.geminiConfigDir !== void 0;
+    const oauthPath = path.join(homedir(), ".gemini", "oauth_creds.json");
+    if (!explicitConfigDir && existsSync(oauthPath)) {
+      return true;
+    }
+    const config = loadProviderCredentialsConfig();
+    const configFileApiKey = config?.gemini?.apiKey ?? null;
+    const resolvedApiKey = resolveCredential({
+      cliOverride: options?.apiKey,
+      configFileValue: configFileApiKey,
+      envValue: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || void 0
+    });
+    if (resolvedApiKey) {
+      return true;
+    }
+    const configDir = this.resolveConfigDir(options);
+    const apiKeyPath = this.getAuthFilePath(configDir);
+    try {
+      const { stat } = await import("fs/promises");
+      await stat(apiKeyPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var geminiAuth = new GeminiAuth();
+function resolveGeminiConfigDir(options) {
+  return geminiAuth.resolveConfigDir(options);
+}
+function getApiKeyPath(configDir) {
+  return path.join(configDir, ".api_key");
+}
+function getGeminiAuthPaths(configDir) {
+  return [
+    getApiKeyPath(configDir),
+    path.join(configDir, ".gemini.json"),
+    path.join(configDir, ".gemini.json.backup")
+  ];
+}
+async function isAuthenticated(options) {
+  return geminiAuth.isAuthenticated(options);
+}
+async function isAuthenticatedTriState(_options) {
+  return "unknown";
+}
+function getResolvedGeminiApiKey(options) {
+  const cliOverride = options?.apiKey ?? options?.env?.GEMINI_API_KEY ?? options?.env?.GOOGLE_API_KEY ?? null;
+  const config = loadProviderCredentialsConfig();
+  const configFileValue = config?.gemini?.apiKey ?? null;
+  return resolveCredential({
+    cliOverride,
+    configFileValue,
+    envValue: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || void 0
+  });
+}
+function resolveGeminiNativeSettingsDir(options, env = process.env) {
+  if (options?.geminiConfigDir !== void 0) {
+    return options.geminiConfigDir;
+  }
+  return resolveGeminiUserDir(env);
+}
+async function getGeminiCliSelectedAuthType(options, env) {
+  const configDir = resolveGeminiNativeSettingsDir(options, env);
+  const settingsPath = path.join(configDir, "settings.json");
+  try {
+    const { readFile } = await import("fs/promises");
+    const raw = await readFile(settingsPath, "utf8");
+    const parsed = JSON.parse(String(raw));
+    const selectedType = parsed.security?.auth?.selectedType;
+    if (typeof selectedType === "string" && selectedType.trim().length > 0) {
+      return selectedType.trim();
+    }
+    const legacyMethod = parsed.auth?.method;
+    if (typeof legacyMethod === "string" && legacyMethod.trim().length > 0) {
+      return legacyMethod.trim();
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function isGeminiCliOAuthSelected(options, env) {
+  const selectedType = await getGeminiCliSelectedAuthType(options, env);
+  return selectedType?.toLowerCase().startsWith("oauth") === true;
+}
+
+export {
+  metadata,
+  resolveGeminiConfigDir,
+  getApiKeyPath,
+  getGeminiAuthPaths,
+  isAuthenticated,
+  isAuthenticatedTriState,
+  getResolvedGeminiApiKey,
+  getGeminiCliSelectedAuthType,
+  isGeminiCliOAuthSelected,
+  auth_exports
+};
+//# sourceMappingURL=chunk-ATKEKM3E.js.map