@bitkyc08/opencodex 2.68.0 → 2.69.0-preview.20260928

package/src/config/macos-system-proxy.ts

@@ -0,0 +1,114 @@
+import { execFileSync } from "node:child_process";
+import { isIP } from "node:net";
+
+export type MacOSProxyReader = () => string | null;
+export type MacOSSystemProxyResult =
+  | { kind: "proxy"; httpUrl?: string; httpsUrl?: string; exceptions: string[]; droppedLinkLocal: boolean }
+  | { kind: "disabled" | "unreadable" | "unsafe-exceptions" };
+
+function readScutilProxy(): string {
+  return execFileSync("/usr/sbin/scutil", ["--proxy"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 2_000,
+    maxBuffer: 64 * 1024,
+  });
+}
+
+function proxyUrl(host: string | undefined, port: string | undefined): string | undefined {
+  if (!host || !port || !/^\d+$/.test(port) || +port < 1 || +port > 65535) return undefined;
+  const bareHost = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  if (!isIP(bareHost) && !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?\.?$/i.test(host)) return undefined;
+  try {
+    return new URL(`http://${isIP(bareHost) === 6 ? `[${bareHost}]` : host}:${port}`).origin;
+  } catch {
+    return undefined;
+  }
+}
+
+// Bun matches a leading-dot entry at DNS-label boundaries and also bypasses the
+// bare apex. Translating "*.local" to ".local" therefore widens only to "local";
+// other glob shapes are refused. Bun cannot represent the default link-local
+// CIDRs, so they are dropped with a diagnostic instead of blocking discovery.
+// null means one of those exact ranges was dropped; undefined refuses discovery.
+function translateException(value: string): string | null | undefined {
+  if (value === "*") return value;
+  if (value === "169.254/16" || value === "169.254.0.0/16") return null;
+  const ipv6Range = /^(?:\[([0-9a-f:]+)\]|([0-9a-f:]+))\/10$/i.exec(value);
+  const ipv6Base = ipv6Range?.[1] ?? ipv6Range?.[2];
+  if (ipv6Base && isIP(ipv6Base) === 6
+    && new URL(`http://[${ipv6Base}]`).hostname === "[fe80::]") return null;
+  if (value.startsWith("*.")) {
+    const domain = value.slice(2);
+    if (domain.length > 253 || !domain.split(".").every(label => label.length <= 63
+      && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label))) return undefined;
+    return `.${domain.toLowerCase()}`;
+  }
+  if (isIP(value) === 4) {
+    const canonical = new URL(`http://${value}`).hostname;
+    return value === canonical ? value : undefined;
+  }
+  const bare = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
+  return isIP(bare) === 6 ? new URL(`http://[${bare}]`).hostname : undefined;
+}
+
+/** Read only the global dictionary; scoped service dictionaries do not apply globally. */
+export function readMacOSSystemProxy(reader: MacOSProxyReader = readScutilProxy): MacOSSystemProxyResult {
+  try {
+    const output = reader();
+    if (!output || output.length > 64 * 1024 || !/^\s*<dictionary>\s*\{/.test(output)) return { kind: "unreadable" };
+    const values = new Map<string, string>();
+    const exceptions: string[] = [];
+    let depth = 0;
+    let inExceptions = false;
+    for (const row of output.split(/\r?\n/)) {
+      const line = row.trim();
+      if (line.endsWith("{")) {
+        if (inExceptions) return { kind: "unreadable" };
+        if (depth === 1) {
+          inExceptions = /^ExceptionsList\s*:\s*<array>\s*\{$/.test(line);
+          if (line.startsWith("ExceptionsList") && !inExceptions) return { kind: "unreadable" };
+        }
+        depth++;
+      } else if (line === "}") {
+        if (--depth < 0) return { kind: "unreadable" };
+        if (depth === 1) inExceptions = false;
+      } else {
+        const entry = /^([^:]+)\s*:\s*(.*?)\s*$/.exec(line);
+        if (!entry) {
+          if (inExceptions) return { kind: "unreadable" };
+          continue;
+        }
+        if (depth === 1) {
+          if (entry[1]!.trim() === "ExceptionsList") return { kind: "unreadable" };
+          values.set(entry[1]!.trim(), entry[2]!);
+        }
+        if (depth === 2 && inExceptions) {
+          if (!/^\d+$/.test(entry[1]!.trim())) return { kind: "unreadable" };
+          exceptions.push(entry[2]!);
+        }
+      }
+    }
+    if (depth !== 0) return { kind: "unreadable" };
+    if (values.get("ExcludeSimpleHostnames") === "1" || values.get("ProxyAutoConfigEnable") === "1"
+      || values.get("ProxyAutoDiscoveryEnable") === "1") return { kind: "unsafe-exceptions" };
+    for (const key of ["HTTPEnable", "HTTPSEnable", "ExcludeSimpleHostnames", "ProxyAutoConfigEnable", "ProxyAutoDiscoveryEnable"]) {
+      const value = values.get(key);
+      if (value !== undefined && value !== "0" && value !== "1") return { kind: "unreadable" };
+    }
+    const translated = exceptions.map(translateException);
+    if (translated.some(value => value === undefined)) return { kind: "unsafe-exceptions" };
+    const httpEnabled = values.get("HTTPEnable") === "1";
+    const httpsEnabled = values.get("HTTPSEnable") === "1";
+    const httpUrl = httpEnabled ? proxyUrl(values.get("HTTPProxy"), values.get("HTTPPort")) : undefined;
+    const httpsUrl = httpsEnabled ? proxyUrl(values.get("HTTPSProxy"), values.get("HTTPSPort")) : undefined;
+    if ((httpEnabled && !httpUrl) || (httpsEnabled && !httpsUrl)) return { kind: "unreadable" };
+    return httpUrl || httpsUrl
+      ? { kind: "proxy", httpUrl, httpsUrl,
+          exceptions: translated.filter((value): value is string => typeof value === "string"),
+          droppedLinkLocal: translated.includes(null) }
+      : { kind: "disabled" };
+  } catch {
+    return { kind: "unreadable" };
+  }
+}

package/src/config/proxy-env.ts

@@ -5,6 +5,7 @@ import { DEFAULT_SUBAGENT_MODELS, SUBAGENT_MODELS_VERSION } from "./subagent-mod
 import { MULTI_AGENT_SURFACE_ADVISORY_VERSION } from "./multi-agent-surface";
 import { DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES } from "../lib/app-owned-memory";
 import { describeProxyForLog, readWindowsSystemProxy, type WindowsProxyRegistryReader } from "../lib/windows-system-proxy";
+import { readMacOSSystemProxy, type MacOSProxyReader } from "./macos-system-proxy";
 import { OPENAI_PROVIDER_TIER_VERSION, type OcxConfig } from "../types";
 import type { OcxRuntimeRole } from "../types/config";
 
@@ -152,6 +153,23 @@ function mergeNoProxyEntries(configured: readonly string[] = [], loopback: reado
   }
 }
 
+function configuredNoProxyEntries(config: OcxConfig): string[] {
+  const raw = config.noProxy;
+  let entries: string[];
+  if (Array.isArray(raw)) {
+    if (raw.some(entry => typeof entry !== "string")) warnProxyConfigDiscardOnce("noProxyElements");
+    entries = raw.filter((entry): entry is string => typeof entry === "string");
+  } else if (typeof raw === "string") {
+    const resolved = resolveEnvValue(raw);
+    if (raw && resolved === undefined) warnProxyConfigDiscardOnce("noProxy");
+    entries = (resolved ?? "").split(",");
+  } else {
+    if (raw !== undefined) warnProxyConfigDiscardOnce("noProxy");
+    entries = [];
+  }
+  return entries.map(entry => entry.trim()).filter(Boolean);
+}
+
 /**
  * Mirror `config.proxy` into HTTP(S)_PROXY env vars. Bun fetch consumes them natively; transports
  * such as the ChatGPT upstream WebSocket select the same environment explicitly. User-set HTTP(S)_PROXY
@@ -172,7 +190,7 @@ export function applyProxyEnv(config: OcxConfig, announce = false): void {
 /** Test seam for `proxy: "auto"`: the registry reader and platform are injectable. */
 export function applyProxyEnvWith(
   config: OcxConfig,
-  auto: { reader?: WindowsProxyRegistryReader; platform?: NodeJS.Platform } = {},
+  auto: { reader?: WindowsProxyRegistryReader; macOSReader?: MacOSProxyReader; platform?: NodeJS.Platform } = {},
 ): void {
   // `proxy` and `noProxy` are not declared in the top-level schema, which ends in
   // `.passthrough()`, so whatever is on disk arrives here verbatim. A non-string value
@@ -194,6 +212,52 @@ export function applyProxyEnvWith(
     return;
   }
   if (proxy.trim().toLowerCase() === "auto") {
+    if ((auto.platform ?? process.platform) === "darwin") {
+      // An inherited scheme or ALL_PROXY route owns both its proxy and bypass
+      // variables. Combining it with system exceptions would change that route.
+      if (["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"]
+        .some(key => process.env[key]?.trim())) {
+        console.log('[opencodex] proxy "auto": existing proxy environment wins; macOS system proxy not consulted');
+        configureSocks5Fetch();
+        return;
+      }
+      const found = readMacOSSystemProxy(auto.macOSReader);
+      if (found.kind !== "proxy") {
+        const reason = found.kind === "unsafe-exceptions"
+          ? "macOS exceptions cannot be safely translated; discovery refused"
+          : found.kind === "disabled"
+            ? "macOS system proxy is disabled"
+            : "macOS proxy settings could not be read";
+        console.log(`[opencodex] proxy "auto": ${reason}; proxy environment unchanged`);
+        return;
+      }
+      const configured = configuredNoProxyEntries(config);
+      const inheritedLowercase = process.env.no_proxy?.trim();
+      if (inheritedLowercase && configured.some(host => /^localhost\.?$/i.test(host))) {
+        console.log('[opencodex] proxy "auto": configured noProxy "localhost" cannot be represented exactly for Bun while an inherited no_proxy is set; discovery refused');
+        return;
+      }
+      const origins = [
+        found.httpUrl && `HTTP ${describeProxyForLog(found.httpUrl)}`,
+        found.httpsUrl && `HTTPS ${describeProxyForLog(found.httpsUrl)}`,
+      ].filter(Boolean).join(", ");
+      console.log(`[opencodex] proxy "auto": using macOS system proxy ${origins}`);
+      if (found.droppedLinkLocal) {
+        console.log('[opencodex] proxy "auto": link-local IP literals use the proxy; macOS link-local range exceptions are not expressible');
+      }
+      if (found.httpUrl) process.env.HTTP_PROXY = found.httpUrl;
+      if (found.httpsUrl) process.env.HTTPS_PROXY = found.httpsUrl;
+      // Bun gives non-empty lowercase no_proxy priority over NO_PROXY. Before
+      // discovery there was no proxy, so an ordinary configured name and its
+      // subdomains can stay direct in both paths. Bare localhost is refused
+      // above when lowercase is inherited: Bun cannot match it exactly there.
+      mergeNoProxyEntries([...configured, ...found.exceptions], LOOPBACK_ADDRESS_NO_PROXY);
+      if (process.env.no_proxy?.trim()) {
+        process.env.no_proxy = withNoProxyEntries(process.env.no_proxy, [...configured, ...found.exceptions], LOOPBACK_ADDRESS_NO_PROXY);
+      }
+      configureSocks5Fetch();
+      return;
+    }
     // #1525 slice 1: one startup read of the Windows static proxy. Never copy the literal
     // "auto" into HTTP_PROXY; every non-proxy outcome leaves outbound routing as it was.
     if (process.env.HTTP_PROXY?.trim() || process.env.http_proxy?.trim()
@@ -213,7 +277,7 @@ export function applyProxyEnvWith(
         proxy = undefined;
       } else {
         const reason = found.kind === "unsupported"
-          ? "only Windows system proxy discovery is supported; using direct egress on this OS"
+          ? "only Windows and macOS system proxy discovery is supported; using direct egress on this OS"
           : found.kind === "disabled"
             ? "Windows system proxy is disabled; using direct egress"
             : found.kind === "socks-only"
@@ -240,23 +304,6 @@ export function applyProxyEnvWith(
   }
   // Configured entries first, then loopback: loopback is unconditional, so appending it last
   // keeps it present even when the operator lists a loopback host themselves.
-  const raw = config.noProxy;
-  let configuredEntries: string[];
-  if (Array.isArray(raw)) {
-    // One unusable element must not discard the operator's other entries.
-    if (raw.some(entry => typeof entry !== "string")) warnProxyConfigDiscardOnce("noProxyElements");
-    configuredEntries = raw.filter((entry): entry is string => typeof entry === "string");
-  } else if (typeof raw === "string") {
-    const resolved = resolveEnvValue(raw);
-    if (raw && resolved === undefined) warnProxyConfigDiscardOnce("noProxy");
-    configuredEntries = (resolved ?? "").split(",");
-  } else {
-    if (raw !== undefined) warnProxyConfigDiscardOnce("noProxy");
-    configuredEntries = [];
-  }
-  const configured = configuredEntries
-    .map(entry => entry.trim())
-    .filter(Boolean);
-  mergeNoProxyEntries(configured);
+  mergeNoProxyEntries(configuredNoProxyEntries(config));
   configureSocks5Fetch();
 }

package/src/config/schema/config-schema.ts

@@ -16,6 +16,7 @@ import {
   remoteGuiConfigSchema,
   runtimeRoleSchema,
   spendSchema,
+  skillsConfigSchema,
   configuredCodexPoolAccountIds,
   apiKeyEntrySchema,
   asideProfileSyncSchema,
@@ -24,6 +25,8 @@ import {
   codexAccountNamespacesSchema,
   modelPinnedEffortsSchema,
   compactionRoutingSchema,
+  memoryModelSettingSchema,
+  memoryModelsSchema,
   modelPreferHostedToolsConfigError,
   providerModelCostsConfigError,
   providerRelativeSendPathConfigError,
@@ -78,6 +81,7 @@ export const configSchema = z.object({
   // A malformed privacy block must never be read as "unmask": .catch(undefined) drops it and
   // emailMaskingEnabled then falls back to masked, which is also what an absent block means.
   privacy: z.object({ maskEmails: z.boolean().optional() }).strict().optional().catch(undefined),
+  skills: skillsConfigSchema.optional().catch(undefined),
   // Malformed hand edits disable this opt-in exporter. Live writes reject them in diagnostics.ts.
   metricsExport: z.object({ enabled: z.boolean().optional() }).strict().optional().catch(undefined),
   // Kept raw on purpose: `.catch(undefined)` would turn a mistyped `enabled` into "inherit",
@@ -158,6 +162,17 @@ export const configSchema = z.object({
   modelPinnedEfforts: modelPinnedEffortsSchema.optional(),
   compactionRouting: compactionRoutingSchema.optional().catch(undefined),
   compactionRecovery: compactionRecoverySchema.optional().catch(undefined),
+  // A hand-edited malformed phase disables only that phase instead of rejecting
+  // providers/apiKeys, matching the load-time degradation notice; the management write
+  // boundary (validateConfigCandidate) still refuses the bad value through the shared,
+  // catch-free memoryModelsSchema.
+  memoryModels: z
+    .object({
+      extract: memoryModelSettingSchema.optional().catch(undefined),
+      consolidation: memoryModelSettingSchema.optional().catch(undefined),
+    })
+    .optional()
+    .catch(undefined),
   defaultProvider: z.string().min(1).default("openai"),
   defaultModelAliases: z.boolean().optional(),
   // Malformed hand edits disable this opt-in projection without rejecting providers.

package/src/config/schema/leaf-validators.ts

@@ -55,6 +55,21 @@ export const compactionRoutingSchema = z.object({
     .optional(),
 }).strict();
 
+/**
+ * One phase of Codex's memory pipeline. A present phase must name a model: the GUI's "Off"
+ * removes the phase instead of blanking it, so an empty entry would only ever come from a
+ * hand-edited file, where failing the write is the honest answer.
+ */
+export const memoryModelSettingSchema = z.object({
+  model: z.string().trim().min(1),
+  reasoningEffort: z.string().refine(value => pinnedReasoningEffortConfigError(value) === null).optional(),
+}).strict();
+
+export const memoryModelsSchema = z.object({
+  extract: memoryModelSettingSchema.optional(),
+  consolidation: memoryModelSettingSchema.optional(),
+}).strict();
+
 /**
  * Bounds for the opt-in same-target 429 wait-and-retry policy. Single source of truth
  * shared by the config schema, the load-time sanitizer, and the management write
@@ -297,6 +312,7 @@ export const providerConfigSchema = z.object({
   annotateEmptyToolOutputs: z.boolean().optional(),
   foldDeveloperRoleToSystem: z.boolean().optional(),
   fastWire: fastWireSchema.nullable().optional(),
+  responseTierAuthoritative: z.boolean().optional(),
   fastEnabled: z.boolean().optional(),
   supportsServiceTier: z.boolean().optional(),
   modelSupportsServiceTier: z.record(z.string().min(1), z.boolean()).optional(),
@@ -1055,3 +1071,10 @@ export const spendSchema = z.object({
   pool: spendScopeSchema.optional(),
   retentionDays: z.number().int().min(1).max(365).optional(),
 }).strict();
+
+/**
+ * Runtime skills catalog configuration (#5569).
+ */
+export const skillsConfigSchema = z.object({
+  catalog_refresh: z.enum(["per_session", "per_turn"]).optional(),
+}).strict();

package/src/config.ts

@@ -267,6 +267,7 @@ export function loadConfig(): OcxConfig {
       warnConfigRepaired(configPath, result.error);
       const config = normalizeApiKeyIds(retryResult.data as OcxConfig);
       warnInheritedFastWireConflicts(configPath, config);
+      warnDegradedTopLevelOptIns(parsed, config);
       warnDegradedHostname(parsed, config);
       warnDegradedListeners(parsed, config);
       warnDegradedApiKeys(parsed, config);
@@ -296,6 +297,7 @@ export function loadConfig(): OcxConfig {
         warnDroppedConfigSections(configPath, salvaged.dropped, salvaged.issues);
         const config = normalizeApiKeyIds(salvaged.parsed);
         warnInheritedFastWireConflicts(configPath, config);
+        warnDegradedTopLevelOptIns(parsed, config);
         warnDegradedHostname(parsed, config);
         warnDegradedListeners(parsed, config);
         warnDegradedApiKeys(parsed, config);