@poetic-ai/poetic 1.42.0

package/dist/chunk-ACKIPAOJ.js

@@ -0,0 +1,302 @@
+import {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+
+// src/core/project/failure-output-parsers.ts
+function parseTscOutput(output) {
+  const errorLines = [];
+  let summaryCounted = false;
+  let errorCount = null;
+  const summaryMatch = /Found\s+(\d+)\s+errors?\b/i.exec(output);
+  if (summaryMatch) {
+    const n = parseInt(summaryMatch[1] ?? "0", 10);
+    errorCount = n;
+    summaryCounted = true;
+  }
+  for (const line of output.split(/\r?\n/)) {
+    if (/\berror TS\d+:/.test(line)) {
+      errorLines.push(line.trim());
+    }
+  }
+  if (!summaryCounted && errorLines.length === 0) return null;
+  const count = summaryCounted ? errorCount ?? errorLines.length : errorLines.length;
+  return {
+    toolFamily: "tsc",
+    errorCount: count,
+    messages: errorLines.slice(0, 20),
+    parsed: true
+  };
+}
+function parseEslintOutput(output) {
+  const summaryMatch = /(\d+)\s+problems?\s+\((\d+)\s+errors?/i.exec(output);
+  if (!summaryMatch) return null;
+  const errorCount = parseInt(summaryMatch[2] ?? "0", 10);
+  const messages = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (/\berror\b/i.test(line) && /\d+:\d+/.test(line)) {
+      messages.push(line.trim());
+    }
+  }
+  return {
+    toolFamily: "eslint",
+    errorCount,
+    messages: messages.slice(0, 20),
+    parsed: true
+  };
+}
+function parseBiomeOutput(output) {
+  const raw = output.trim();
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const jsonCandidate = raw.slice(start, end + 1);
+    try {
+      const json = JSON.parse(jsonCandidate);
+      if (Array.isArray(json?.diagnostics)) {
+        const diagCount = json.diagnostics.length;
+        const summaryErrors = json.summary?.errorCount ?? null;
+        const errorCount = typeof summaryErrors === "number" ? summaryErrors : diagCount;
+        if (diagCount > 0 || typeof summaryErrors === "number") {
+          return {
+            toolFamily: "biome",
+            errorCount,
+            messages: [],
+            parsed: true
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  const plainMatch = /Found\s+(\d+)\s+errors?\b/i.exec(output);
+  if (plainMatch) {
+    return {
+      toolFamily: "biome",
+      errorCount: parseInt(plainMatch[1] ?? "0", 10),
+      messages: [],
+      parsed: true
+    };
+  }
+  return null;
+}
+function parseNodeTestSummary(output) {
+  const messages = [];
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (/^FAIL\s+/.test(trimmed) || /^×\s+/.test(trimmed) || /^not ok\b/.test(trimmed)) {
+      messages.push(trimmed);
+    }
+  }
+  const cappedMessages = messages.slice(0, 20);
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const hasPipe = /\d+\s+(?:failed|passed|skipped)\s*\|/i.test(trimmed);
+    const greenOnly = /^(?:Tests\s+)?\d+\s+passed\b/i.test(trimmed) && !/\bfailed\b/i.test(trimmed);
+    if (!hasPipe && !greenOnly) continue;
+    if (!/^(?:Tests\s+)?\d+\s+(?:failed|passed|skipped)\b/i.test(trimmed)) continue;
+    const failed = intFromToken(trimmed, /(\d+)\s+failed/i) ?? 0;
+    const passed = intFromToken(trimmed, /(\d+)\s+passed/i);
+    const skipped = intFromToken(trimmed, /(\d+)\s+skipped/i) ?? 0;
+    if (passed === null) {
+      if (failed > 0) {
+        return {
+          toolFamily: "node-test",
+          errorCount: failed,
+          messages: cappedMessages,
+          parsed: true
+        };
+      }
+      continue;
+    }
+    return {
+      toolFamily: "node-test",
+      errorCount: failed,
+      messages: cappedMessages,
+      parsed: true,
+      suiteFootprint: { executed: passed + failed, skipped }
+    };
+  }
+  const jestLine = /(?:^|\n)\s*Tests:\s+([^\n]+)/i.exec(output);
+  if (jestLine?.[1]) {
+    const body = jestLine[1];
+    const failed = intFromToken(body, /(\d+)\s+failed/i);
+    const passed = intFromToken(body, /(\d+)\s+passed/i);
+    const skipped = intFromToken(body, /(\d+)\s+skipped/i) ?? 0;
+    if (passed !== null) {
+      const failCount = failed ?? 0;
+      return {
+        toolFamily: "node-test",
+        errorCount: failCount,
+        messages: cappedMessages,
+        parsed: true,
+        // executed = non-skipped (pass + fail); do not use Jest "total" (includes skips).
+        suiteFootprint: { executed: passed + failCount, skipped }
+      };
+    }
+    if (failed !== null) {
+      return {
+        toolFamily: "node-test",
+        errorCount: failed,
+        messages: cappedMessages,
+        parsed: true
+      };
+    }
+  }
+  const tapFail = intFromToken(output, /(?:^|\n)\s*#\s+fail\s+(\d+)/i);
+  const tapPass = intFromToken(output, /(?:^|\n)\s*#\s+pass\s+(\d+)/i);
+  const tapSkip = intFromToken(output, /(?:^|\n)\s*#\s+skip\s+(\d+)/i) ?? 0;
+  const tapTests = intFromToken(output, /(?:^|\n)\s*#\s+tests\s+(\d+)/i);
+  if (tapFail !== null || tapPass !== null) {
+    const failCount = tapFail ?? 0;
+    const passCount = tapPass ?? (tapTests !== null ? Math.max(0, tapTests - failCount - tapSkip) : null);
+    if (passCount !== null) {
+      return {
+        toolFamily: "node-test",
+        errorCount: failCount,
+        messages: cappedMessages,
+        parsed: true,
+        // executed = non-skipped runs (pass + fail); skip tracked separately.
+        suiteFootprint: { executed: passCount + failCount, skipped: tapSkip }
+      };
+    }
+  }
+  return null;
+}
+function intFromToken(text, pattern) {
+  const match = pattern.exec(text);
+  if (!match?.[1]) return null;
+  return parseInt(match[1], 10);
+}
+function parsePytestOutput(output) {
+  const bannerSummary = /=+\s+([^=]*?\b\d+\s+(?:failed|passed|skipped|errors?)\b[^=]*?)=+/i.exec(
+    output
+  );
+  const looseFailed = !bannerSummary ? /\b(\d+)\s+failed\b.*\bin\s+[\d.]+s/i.exec(output) : null;
+  if (!bannerSummary && !looseFailed) return null;
+  const summaryLine = bannerSummary?.[1] ?? looseFailed?.[0] ?? "";
+  const failedMatch = /\b(\d+)\s+failed\b/i.exec(summaryLine);
+  const passedMatch = /\b(\d+)\s+passed\b/i.exec(summaryLine);
+  const skippedMatch = /\b(\d+)\s+skipped\b/i.exec(summaryLine);
+  const errorsMatch = /\b(\d+)\s+errors?\b/i.exec(summaryLine);
+  const setupErrors = errorsMatch ? parseInt(errorsMatch[1] ?? "0", 10) : 0;
+  const failed = failedMatch ? parseInt(failedMatch[1] ?? "0", 10) : 0;
+  const errorCount = failed + setupErrors;
+  if (!failedMatch && !passedMatch && !skippedMatch && !errorsMatch) return null;
+  const messages = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (/^FAILED\s+/.test(line.trim())) {
+      messages.push(line.trim());
+    }
+  }
+  let suiteFootprint;
+  if (passedMatch) {
+    const passed = parseInt(passedMatch[1] ?? "0", 10);
+    const skipped = skippedMatch ? parseInt(skippedMatch[1] ?? "0", 10) : 0;
+    suiteFootprint = { executed: passed + errorCount, skipped };
+  }
+  return {
+    toolFamily: "pytest",
+    errorCount,
+    messages: messages.slice(0, 20),
+    parsed: true,
+    ...suiteFootprint ? { suiteFootprint } : {}
+  };
+}
+function parseGoTestOutput(output) {
+  const failLines = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (/^---\s+FAIL:/.test(line.trim())) {
+      failLines.push(line.trim());
+    }
+  }
+  const packageFailCount = (output.match(/^FAIL\b/gm) ?? []).length;
+  if (failLines.length === 0 && packageFailCount === 0) return null;
+  return {
+    toolFamily: "go-test",
+    errorCount: failLines.length > 0 ? failLines.length : packageFailCount,
+    messages: failLines.slice(0, 20),
+    parsed: true
+  };
+}
+function parseCargoOutput(output) {
+  const testResultMatch = /test result:\s+FAILED\.\s+\d+\s+passed;\s+(\d+)\s+failed/i.exec(output);
+  if (testResultMatch) {
+    const errorCount = parseInt(testResultMatch[1] ?? "0", 10);
+    const messages = [];
+    for (const line of output.split(/\r?\n/)) {
+      if (/^test\s+\S+\s+\.\.\.\s+FAILED\b/.test(line.trim())) {
+        messages.push(line.trim());
+      }
+    }
+    return { toolFamily: "cargo", errorCount, messages: messages.slice(0, 20), parsed: true };
+  }
+  const errorLines = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (/^error\[E\d+\]/.test(line.trim())) {
+      errorLines.push(line.trim());
+    }
+  }
+  if (errorLines.length > 0) {
+    return {
+      toolFamily: "cargo",
+      errorCount: errorLines.length,
+      messages: errorLines.slice(0, 20),
+      parsed: true
+    };
+  }
+  const abortMatch = /error:\s+aborting due to (\d+) previous errors?/i.exec(output);
+  if (abortMatch) {
+    return {
+      toolFamily: "cargo",
+      errorCount: parseInt(abortMatch[1] ?? "1", 10),
+      messages: [],
+      parsed: true
+    };
+  }
+  return null;
+}
+var PARSED_FALSE_UNKNOWN = {
+  toolFamily: "unknown",
+  errorCount: null,
+  messages: [],
+  parsed: false
+};
+var PARSER_REGISTRY = /* @__PURE__ */ new Map([
+  // Node — dispatch on kind.
+  ["node/typecheck", [parseTscOutput]],
+  ["node/build", [parseTscOutput]],
+  ["node/lint", [parseBiomeOutput, parseEslintOutput]],
+  // node/test: suite summary first; tsc kept for tsc-in-test-script edge cases.
+  ["node/test", [parseNodeTestSummary, parseTscOutput]],
+  // Python — pytest covers all test kinds.
+  ["python/test", [parsePytestOutput]],
+  // Go — go test.
+  ["go/test", [parseGoTestOutput]],
+  // Rust — cargo.
+  ["rust/test", [parseCargoOutput]],
+  ["rust/build", [parseCargoOutput]],
+  ["rust/typecheck", [parseCargoOutput]]
+]);
+function parsersForKey(language, kind) {
+  const specific = PARSER_REGISTRY.get(`${language}/${kind}`);
+  if (specific) return specific;
+  return PARSER_REGISTRY.get(`${language}/*`);
+}
+function parseFailureOutput(command, output, kind) {
+  const descriptor = describeVerificationCommand(command);
+  const { language } = descriptor;
+  const parsers = parsersForKey(language, kind);
+  if (!parsers || parsers.length === 0) {
+    return PARSED_FALSE_UNKNOWN;
+  }
+  for (const parser of parsers) {
+    const result = parser(output);
+    if (result !== null) return result;
+  }
+  return PARSED_FALSE_UNKNOWN;
+}
+
+export {
+  parseFailureOutput
+};
+//# sourceMappingURL=chunk-ACKIPAOJ.js.map

package/dist/chunk-APPNGGN7.js

@@ -0,0 +1,365 @@
+import {
+  hasPositiveBedrockCredentialSignals
+} from "./chunk-5HDP7XZG.js";
+import {
+  metadata
+} from "./chunk-PJWJ3SAV.js";
+import {
+  CODEX_API_KEY_ENV_VARS,
+  detectCodexAuthMode
+} from "./chunk-4NXPXE62.js";
+import {
+  BaseProviderAuth,
+  assertSkipAuthAllowed
+} from "./chunk-4VJITV4P.js";
+import {
+  lookupFreshAuthFailure
+} from "./chunk-R6W23LKN.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-SURZ2WFE.js";
+import {
+  getStandardCodexHome,
+  normalizeCodexHomePath,
+  resolveCodexAwsCredentialEnvRelease,
+  resolveCodexBackend
+} from "./chunk-5WRLK5KW.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  mergeExecutionContextEnvOverrides
+} from "./chunk-UI2F6DJ5.js";
+import {
+  getDefaultPaths
+} from "./chunk-UUH2RVKS.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_CODEX_AUTH_MODE,
+  POETIC_MOCK_PROVIDERS,
+  POETIC_SKIP_AUTH,
+  readEnv,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/core/providers/codex/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  clearAuth: () => clearAuth,
+  ensureAuth: () => ensureAuth,
+  getAuthFilePath: () => getAuthFilePath,
+  isAuthenticated: () => isAuthenticated,
+  isAuthenticatedTriState: () => isAuthenticatedTriState,
+  nextAuthMenuAction: () => nextAuthMenuAction
+});
+import { rm, stat } from "fs/promises";
+import * as path from "path";
+var CODEX_AUTH_JSON_MIN_BYTES = 10;
+var CodexAuth = class extends BaseProviderAuth {
+  metadata = metadata;
+  defaultConfigSubdir = "codex";
+  configDirEnvVar = "CODEX_HOME";
+  /**
+   * Resolve configured Codex CLI invocation (supports compound commands like `npx @openai/codex@ver`).
+   */
+  resolveCodexCliInvocation() {
+    const resolved = resolveProviderCliCommand("codex");
+    return {
+      command: resolved.command,
+      prefixArgs: resolved.prefixArgs,
+      displayCommand: [resolved.command, ...resolved.prefixArgs].join(" ")
+    };
+  }
+  resolveAuthMode(env) {
+    const probeEnv = {
+      ...process.env,
+      ...env ?? {}
+    };
+    const explicit = env?.[POETIC_CODEX_AUTH_MODE.name]?.trim().toLowerCase() ?? readEnv(POETIC_CODEX_AUTH_MODE).value?.trim().toLowerCase();
+    if (explicit === "api_key" || explicit === "chatgpt_login") {
+      return explicit;
+    }
+    return detectCodexAuthMode(probeEnv);
+  }
+  /**
+   * Environment variables for Codex credentials.
+   * Key aliases are honored only when POETIC_CODEX_AUTH_MODE=api_key so shell keys
+   * used for other tools never mark Codex authenticated under chatgpt_login.
+   */
+  getCredentialEnvVars() {
+    const authMode = this.resolveAuthMode();
+    if (authMode === "api_key") {
+      return [...CODEX_API_KEY_ENV_VARS];
+    }
+    return [];
+  }
+  getCredentialEnvVarsForEnv(env) {
+    const authMode = this.resolveAuthMode(env);
+    if (authMode === "api_key") {
+      return [...CODEX_API_KEY_ENV_VARS];
+    }
+    return [];
+  }
+  /**
+   * Convert CodexAuthOptions to base options with CLI credentials
+   */
+  toBaseOptions(options) {
+    if (!options) return {};
+    return {
+      ...options,
+      cliCredentials: options.apiKey || options.token ? {
+        apiKey: options.apiKey,
+        token: options.token
+      } : options.cliCredentials
+    };
+  }
+  /**
+   * Gets the standard Codex CLI auth location (~/.codex/)
+   */
+  getStandardCodexDir() {
+    return getStandardCodexHome();
+  }
+  getAuthFilePath(configDir) {
+    return path.join(configDir, "auth.json");
+  }
+  getAuthPaths(configDir) {
+    return [this.getAuthFilePath(configDir)];
+  }
+  /**
+   * True when auth.json exists and exceeds {@link CODEX_AUTH_JSON_MIN_BYTES}.
+   * Same threshold for XDG, explicit CODEX_HOME, and ~/.codex — no split-brain.
+   */
+  async hasAuthFile(authPath) {
+    try {
+      const fileStat = await stat(authPath);
+      if (typeof fileStat.size !== "number" || fileStat.size <= CODEX_AUTH_JSON_MIN_BYTES) {
+        return false;
+      }
+      await this.verifyFilePermissions(authPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasApiKeyCredential(options) {
+    const baseOptions = this.toBaseOptions(options);
+    if (baseOptions.cliCredentials?.apiKey || baseOptions.cliCredentials?.token) {
+      return true;
+    }
+    for (const envVar of this.getCredentialEnvVarsForEnv(baseOptions.env)) {
+      const envValue = baseOptions.env?.[envVar] ?? process.env[envVar];
+      if (envValue && envValue.trim().length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Homes that login readiness can consult for this probe.
+   * Explicit configDir / CODEX_HOME: only that home.
+   * Unset: XDG providers/codex then ~/.codex (same fallbacks as hasLoginAuth).
+   */
+  resolveLoginAuthHomes(options) {
+    const baseOptions = this.toBaseOptions(options);
+    if (baseOptions.configDir !== void 0) {
+      return [normalizeCodexHomePath(baseOptions.configDir)];
+    }
+    const envHome = baseOptions.env?.CODEX_HOME ?? getRuntimeEnv("CODEX_HOME");
+    if (envHome) {
+      return [normalizeCodexHomePath(envHome)];
+    }
+    const { userConfigDir } = getDefaultPaths();
+    const xdgHome = path.join(userConfigDir, "providers", this.defaultConfigSubdir);
+    const standardHome = this.getStandardCodexDir();
+    return [.../* @__PURE__ */ new Set([path.resolve(xdgHome), path.resolve(standardHome)])];
+  }
+  async hasLoginAuth(options) {
+    for (const home of this.resolveLoginAuthHomes(options)) {
+      if (await this.hasAuthFile(this.getAuthFilePath(home))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  isEnoentError(error) {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+    const code = error.code;
+    if (code === "ENOENT") {
+      return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /\bENOENT\b/i.test(message);
+  }
+  /**
+   * Clear login auth files for the canonical selected home(s).
+   *
+   * - Explicit configDir / CODEX_HOME (options.env or process): clear only that home.
+   * - Unset CODEX_HOME: clear every readiness fallback (XDG + ~/.codex) so logout
+   *   cannot leave readiness "yes" via the standard-location fallback.
+   *
+   * ENOENT on remove is treated as already clear. Any other removal error throws
+   * immediately (never swallowed). After successful removes, if login readiness
+   * would still be yes, throw.
+   */
+  async clearAuth(options) {
+    const baseOptions = this.toBaseOptions(options);
+    const homes = this.resolveLoginAuthHomes(baseOptions);
+    for (const home of homes) {
+      const authPath = this.getAuthFilePath(home);
+      try {
+        await rm(authPath, { force: true, recursive: true });
+      } catch (error) {
+        if (this.isEnoentError(error)) {
+          continue;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `[Codex] clearAuth failed removing ${authPath}: ${message}. Homes in scope: ${homes.join(", ")}.`
+        );
+      }
+    }
+    if (await this.hasLoginAuth(baseOptions)) {
+      throw new Error(
+        `[Codex] clearAuth failed: login auth still present under ${homes.join(", ")}. Auth file(s) still present after removal attempt.`
+      );
+    }
+  }
+  /**
+   * Override isAuthenticated to enforce mode-aware readiness.
+   *
+   * api_key mode:
+   *   1. CLI args (--api-key, --token)
+   *   2. Environment variables (OPENAI_API_KEY, CODEX_API_KEY, CODEX_TOKEN)
+   *   Auth files alone never satisfy api_key mode.
+   *
+   * chatgpt_login mode:
+   *   Auth file only (XDG path or ~/.codex/). Key aliases never mark ready.
+   */
+  async isAuthenticated(options) {
+    const baseOptions = this.toBaseOptions(options);
+    const authMode = this.resolveAuthMode(baseOptions.env);
+    if (authMode === "api_key") {
+      return this.hasApiKeyCredential(baseOptions);
+    }
+    return this.hasLoginAuth(baseOptions);
+  }
+  resolveProbeEnv(options) {
+    return {
+      ...process.env,
+      ...options?.env ?? {}
+    };
+  }
+  /**
+   * Passive readiness: login/api_key stay yes/no. Attested Bedrock with a
+   * positive AWS signal is yes. Attested Bedrock without a passive proof
+   * (IMDS/SSO/credential_process) is unknown so the real CLI can attempt.
+   * Config-observed Bedrock without POETIC_CODEX_BACKEND is unknown, not yes.
+   */
+  async readAuthState(options) {
+    const env = this.resolveProbeEnv(options);
+    if (resolveCodexAwsCredentialEnvRelease(env)) {
+      if (await hasPositiveBedrockCredentialSignals(env)) {
+        return "yes";
+      }
+      if (await lookupFreshAuthFailure("codex", { env })) {
+        return "no";
+      }
+      return "unknown";
+    }
+    if (resolveCodexBackend(env) === "bedrock") {
+      return "unknown";
+    }
+    if (await this.isAuthenticated(options)) {
+      return "yes";
+    }
+    return "no";
+  }
+  buildNotAuthenticatedError(authMode, env = process.env) {
+    const { displayCommand } = this.resolveCodexCliInvocation();
+    if (resolveCodexBackend(env) === "bedrock" && !resolveCodexAwsCredentialEnvRelease(env)) {
+      return new Error(
+        "[Codex] Bedrock is configured but AWS credentials will not reach the child. Set POETIC_CODEX_BACKEND=bedrock so the AWS chain is passed through, or authenticate with ChatGPT login / POETIC_CODEX_AUTH_MODE=api_key."
+      );
+    }
+    if (authMode === "api_key") {
+      return new Error(
+        `[Codex] Not authenticated (api_key mode). Set OPENAI_API_KEY (or CODEX_API_KEY / CODEX_TOKEN) so the key reaches the Codex child, or pass --api-key. To use ChatGPT login instead, unset POETIC_CODEX_AUTH_MODE or set POETIC_CODEX_AUTH_MODE=chatgpt_login and run: ${displayCommand} login (or ${this.metadata.setupCommand}).`
+      );
+    }
+    return new Error(
+      `[Codex] Not authenticated (chatgpt_login mode). Run: ${this.metadata.setupCommand} (or ${displayCommand} login). Legacy key aliases (OPENAI_API_KEY / CODEX_API_KEY / CODEX_TOKEN) do not mark ready under chatgpt_login. To use API keys, set POETIC_CODEX_AUTH_MODE=api_key and provide OPENAI_API_KEY. For Amazon Bedrock, set POETIC_CODEX_BACKEND=bedrock and provide an AWS credential chain.`
+    );
+  }
+  /**
+   * Ensures Codex is authenticated with fail-fast validation.
+   *
+   * Passive path: never starts interactive login. Throws an actionable error when
+   * the selected mode cannot run.
+   */
+  async ensureAuth(options) {
+    if (readRawEnv(POETIC_SKIP_AUTH) === "1") {
+      assertSkipAuthAllowed();
+      return true;
+    }
+    if (readEnv(POETIC_MOCK_PROVIDERS).value === "1") {
+      return true;
+    }
+    const baseOptions = this.toBaseOptions(options);
+    const authMode = this.resolveAuthMode(baseOptions.env);
+    const isAuth = await this.isAuthenticated(baseOptions);
+    if (isAuth) {
+      if (authMode !== "api_key" && !getRuntimeEnv("CODEX_HOME")) {
+        const standardDir = this.getStandardCodexDir();
+        if (await this.hasAuthFile(this.getAuthFilePath(standardDir))) {
+          mergeExecutionContextEnvOverrides({ CODEX_HOME: standardDir });
+          if (isDebugMode()) {
+            console.log(`[Codex Auth] Set CODEX_HOME=${standardDir}`);
+          }
+        }
+      }
+      return true;
+    }
+    const env = this.resolveProbeEnv(baseOptions);
+    if (resolveCodexAwsCredentialEnvRelease(env)) {
+      return true;
+    }
+    throw this.buildNotAuthenticatedError(authMode, env);
+  }
+};
+var codexAuth = new CodexAuth();
+function getAuthFilePath(codexHome) {
+  return path.join(codexHome, "auth.json");
+}
+async function isAuthenticated(options) {
+  return codexAuth.isAuthenticated(options);
+}
+async function isAuthenticatedTriState(options) {
+  return codexAuth.readAuthState(options);
+}
+async function ensureAuth(options) {
+  return codexAuth.ensureAuth(options);
+}
+async function clearAuth(options) {
+  return codexAuth.clearAuth(options);
+}
+async function nextAuthMenuAction(options) {
+  return codexAuth.nextAuthMenuAction(options);
+}
+
+export {
+  getAuthFilePath,
+  isAuthenticated,
+  isAuthenticatedTriState,
+  ensureAuth,
+  clearAuth,
+  nextAuthMenuAction,
+  auth_exports
+};
+//# sourceMappingURL=chunk-APPNGGN7.js.map