@remnic/core 9.69.32 → 9.69.34

package/dist/{chunk-TLPZ6MKZ.js → chunk-YEN4TREG.js}

@@ -10,12 +10,18 @@ import {
 import {
   loadModelsJsonProviders
 } from "./chunk-45GF7Y3V.js";
+import {
+  callCodexCliFallback,
+  isCodexCliFallbackRunnerRegistered,
+  normalizeCodexCliTimeoutMs,
+  setCodexCliFallbackRunnerForProcess
+} from "./chunk-65RENJGB.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
 import {
-  callCodexCliFallback
-} from "./chunk-N7RWREIQ.js";
+  launchProcess
+} from "./chunk-ZEFVK7XC.js";
 import {
   expandTildePath
 } from "./chunk-6KH5NLQS.js";
@@ -27,7 +33,525 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/fallback-llm.ts
+import path2 from "path";
+
+// src/providers/codex-subscription.ts
+import { mkdir, mkdtemp, readFile, rm } from "fs/promises";
+import os from "os";
 import path from "path";
+var CODEX_SUBSCRIPTION_PROVIDER_ID = "codex-subscription";
+var CODEX_EXECUTABLE_ENV = "REMNIC_CODEX_EXECUTABLE";
+var DEFAULT_REASONING_EFFORT = "medium";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var LOGIN_STATUS_TIMEOUT_MS = 1e4;
+var LOGIN_STATUS_CACHE_TTL_MS = 10 * 6e4;
+var STDIO_LIMIT = 64e3;
+var OUTPUT_SUMMARY_LIMIT = 500;
+var CODEX_RUNTIME_ENV_ALLOWLIST = Object.freeze({
+  ALL_PROXY: true,
+  APPDATA: true,
+  CODEX_HOME: true,
+  COLORTERM: true,
+  COMSPEC: true,
+  FORCE_COLOR: true,
+  HOME: true,
+  HOMEDRIVE: true,
+  HOMEPATH: true,
+  LANG: true,
+  LOCALAPPDATA: true,
+  LOGNAME: true,
+  NO_COLOR: true,
+  NODE_EXTRA_CA_CERTS: true,
+  NO_PROXY: true,
+  NUMBER_OF_PROCESSORS: true,
+  OS: true,
+  PATH: true,
+  PATHEXT: true,
+  PROGRAMDATA: true,
+  PROCESSOR_ARCHITECTURE: true,
+  HTTP_PROXY: true,
+  HTTPS_PROXY: true,
+  SHELL: true,
+  SSL_CERT_DIR: true,
+  SSL_CERT_FILE: true,
+  SYSTEMDRIVE: true,
+  SYSTEMROOT: true,
+  TEMP: true,
+  TERM: true,
+  TMP: true,
+  TMPDIR: true,
+  USER: true,
+  USERNAME: true,
+  USERPROFILE: true,
+  WINDIR: true,
+  XDG_CACHE_HOME: true,
+  XDG_CONFIG_HOME: true,
+  XDG_DATA_HOME: true,
+  XDG_RUNTIME_DIR: true
+});
+var LOGIN_OK_PATTERN = /logged in using chatgpt/i;
+var LOGIN_API_KEY_PATTERN = /api key/i;
+var AUTH_FAILURE_PATTERN = /\b401\b|\b403\b|unauthorized|forbidden|not logged in|no active|re-?authenticat|token expired|session expired|please log ?in/i;
+var TIMEOUT_PATTERN = /timed out after \d+ms/i;
+var SECRET_ECHO_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{8,}/g,
+  /Bearer\s+[A-Za-z0-9._-]{8,}/g,
+  /eyJ[A-Za-z0-9._-]{10,}/g
+];
+function codexSubscriptionBuiltinProviderConfig() {
+  return {
+    baseUrl: "codex-cli://subscription",
+    api: "codex-cli",
+    models: []
+  };
+}
+var CodexSubscriptionAuthError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "CodexSubscriptionAuthError";
+    this.reason = reason;
+  }
+};
+var CodexSubscriptionConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexSubscriptionConfigError";
+  }
+};
+var CodexSubscriptionTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`codex-subscription request timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+  }
+};
+var loginStatusCache = /* @__PURE__ */ new Map();
+var coreRunnerRegistered = false;
+function createCodexSubscriptionRunner(deps = {}) {
+  const envSource = deps.env ?? process.env;
+  return (request) => runCodexSubscriptionRequest(request, deps, envSource);
+}
+function ensureCodexSubscriptionRunnerRegistered(deps = {}) {
+  if (isCodexCliFallbackRunnerRegistered()) return false;
+  setCodexCliFallbackRunnerForProcess(createCodexSubscriptionRunner(deps));
+  coreRunnerRegistered = true;
+  return true;
+}
+async function runCodexSubscriptionRequest(request, deps, envSource) {
+  const { config } = request;
+  assertNoApiKeyConfig(config);
+  const executable = resolveExecutable(config, envSource);
+  const env = buildIsolatedEnv(envSource);
+  const providerTimeoutMs = config.retryOptions?.timeoutMs !== void 0 ? normalizeCodexCliTimeoutMs(config.retryOptions.timeoutMs) : void 0;
+  const timeoutMs = request.options.timeoutMs ?? providerTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const now = deps.now ?? Date.now;
+  const deadlineStartedAt = now();
+  await assertSubscriptionLogin(executable, env, deps, Math.min(LOGIN_STATUS_TIMEOUT_MS, timeoutMs));
+  if (request.options.signal?.aborted) {
+    throw abortErrorOf(request.options.signal);
+  }
+  const remainingTimeoutMs = timeoutMs - (now() - deadlineStartedAt);
+  if (remainingTimeoutMs <= 0) {
+    throw new CodexSubscriptionTimeoutError(timeoutMs);
+  }
+  let tempDir;
+  try {
+    tempDir = await mkdtemp(path.join(deps.tmpdir?.() ?? os.tmpdir(), "remnic-codex-sub-"));
+    const workspacePath = path.join(tempDir, "workspace");
+    const outputPath = path.join(tempDir, "last-message.txt");
+    await mkdir(workspacePath, { recursive: true });
+    const runCodexExec = deps.runCodexExec ?? runCodexExecSubprocess;
+    const result = await runCodexExec({
+      executable,
+      args: buildExecArgs(request.modelId, config, workspacePath, outputPath),
+      input: buildPrompt(request.messages),
+      env,
+      outputPath,
+      workspacePath,
+      timeoutMs: remainingTimeoutMs,
+      signal: request.options.signal
+    });
+    if (request.options.signal?.aborted) {
+      throw abortErrorOf(request.options.signal);
+    }
+    if (result.status !== 0) {
+      throw execFailureError(result, remainingTimeoutMs, executable, env);
+    }
+    const content = result.outputText.trim();
+    if (content.length === 0) {
+      throw new Error(
+        `codex-subscription: codex exec returned no final message (${summarizeOutput(result.stderr, result.stdout)})`
+      );
+    }
+    return { content, ...usageFrom(result) };
+  } finally {
+    if (tempDir) {
+      await rm(tempDir, { force: true, recursive: true }).catch(() => {
+      });
+    }
+  }
+}
+function assertNoApiKeyConfig(config) {
+  if (config.apiKey !== void 0 && config.apiKey !== "") {
+    throw new CodexSubscriptionConfigError(
+      `${CODEX_SUBSCRIPTION_PROVIDER_ID} does not accept apiKey configuration: it authenticates through the Codex CLI login. Remove the apiKey field and run \`codex login\` with a ChatGPT account instead.`
+    );
+  }
+}
+function resolveExecutable(config, env) {
+  const configured = config.codexCliExecutable ?? config.executable ?? env[CODEX_EXECUTABLE_ENV] ?? "codex";
+  const expanded = expandTildePath(String(configured).trim());
+  if (expanded.trim().length === 0) {
+    throw new CodexSubscriptionConfigError(`${CODEX_EXECUTABLE_ENV} / executable must not be empty`);
+  }
+  if (expanded.includes("/") || expanded.includes("\\")) {
+    return path.resolve(expanded);
+  }
+  return expanded;
+}
+function buildIsolatedEnv(source) {
+  const env = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== void 0 && isAllowedEnvKey(key)) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function isAllowedEnvKey(key) {
+  const normalized = key.toUpperCase();
+  return CODEX_RUNTIME_ENV_ALLOWLIST[normalized] === true || normalized.startsWith("LC_");
+}
+async function assertSubscriptionLogin(executable, env, deps, loginStatusTimeoutMs) {
+  const now = deps.now ?? Date.now;
+  const cacheKey = `${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`;
+  const cached = loginStatusCache.get(cacheKey);
+  if (cached && now() - cached.at < LOGIN_STATUS_CACHE_TTL_MS) {
+    await cached.promise;
+    return;
+  }
+  const promise = (async () => {
+    const runLoginStatus = deps.runLoginStatus ?? runLoginStatusSubprocess;
+    const result = await runLoginStatus(executable, env, loginStatusTimeoutMs);
+    const output = `${result.stdout}
+${result.stderr}`.trim();
+    if (TIMEOUT_PATTERN.test(output)) {
+      throw new CodexSubscriptionTimeoutError(loginStatusTimeoutMs);
+    }
+    if (result.status === 0 && LOGIN_OK_PATTERN.test(output)) {
+      return;
+    }
+    const apiKeyNote = LOGIN_API_KEY_PATTERN.test(output) ? " The CLI currently reports an API-key login; subscription extraction needs a ChatGPT login." : "";
+    throw new CodexSubscriptionAuthError(
+      "unauthenticated",
+      `codex-subscription: no ChatGPT-backed Codex login found. Run \`codex login\` and choose the ChatGPT account option, then retry.${apiKeyNote}`
+    );
+  })();
+  loginStatusCache.set(cacheKey, { at: now(), promise });
+  try {
+    await promise;
+  } catch (err) {
+    loginStatusCache.delete(cacheKey);
+    throw err;
+  }
+}
+function buildExecArgs(modelId, config, workspacePath, outputPath) {
+  const reasoningEffort = readReasoningEffort(config) ?? DEFAULT_REASONING_EFFORT;
+  return [
+    "exec",
+    "--strict-config",
+    "--model",
+    modelId,
+    "--config",
+    `model_reasoning_effort=${JSON.stringify(reasoningEffort)}`,
+    "--config",
+    'approval_policy="never"',
+    "--config",
+    'web_search="disabled"',
+    "--disable",
+    "hooks",
+    "--disable",
+    "shell_tool",
+    "--disable",
+    "unified_exec",
+    "--disable",
+    "apps",
+    "--disable",
+    "plugins",
+    "--disable",
+    "remote_plugin",
+    "--disable",
+    "multi_agent",
+    "--disable",
+    "browser_use",
+    "--disable",
+    "browser_use_external",
+    "--disable",
+    "computer_use",
+    "--disable",
+    "image_generation",
+    "--disable",
+    "in_app_browser",
+    "--disable",
+    "goals",
+    "--disable",
+    "memories",
+    "--disable",
+    "chronicle",
+    "--disable",
+    "tool_suggest",
+    "--disable",
+    "workspace_dependencies",
+    "--disable",
+    "shell_snapshot",
+    "--ephemeral",
+    "--ignore-user-config",
+    "--ignore-rules",
+    "--sandbox",
+    "read-only",
+    "--cd",
+    workspacePath,
+    "--skip-git-repo-check",
+    "--json",
+    "--output-last-message",
+    outputPath,
+    "-"
+  ];
+}
+function readReasoningEffort(config) {
+  for (const value of [config.codexCliReasoningEffort, config.reasoningEffort]) {
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "low" || normalized === "medium" || normalized === "high" || normalized === "xhigh") {
+        return normalized;
+      }
+      throw new CodexSubscriptionConfigError(
+        "codex-subscription reasoningEffort must be one of low, medium, high, xhigh (got unrecognized value)"
+      );
+    }
+  }
+  return void 0;
+}
+function buildPrompt(messages) {
+  const transcript = messages.map((message) => JSON.stringify({ role: message.role, content: message.content })).join("\n");
+  return [
+    "You are acting as an LLM completion endpoint for a memory-extraction pipeline, not as a coding agent.",
+    "Answer the request in the transcript below. Do not inspect files, run commands, browse, or use tools.",
+    "Return only the final answer text. If the request asks for JSON, return raw JSON only.",
+    "",
+    'TRANSCRIPT (JSON Lines: one {"role":"...","content":"..."} object per message; newlines inside content are escaped):',
+    transcript
+  ].join("\n");
+}
+function execFailureError(result, timeoutMs, executable, env) {
+  const combined = `${result.stderr}
+${result.stdout}`;
+  if (AUTH_FAILURE_PATTERN.test(combined)) {
+    loginStatusCache.delete(`${executable}\0${env.CODEX_HOME ?? env.HOME ?? ""}`);
+    return new CodexSubscriptionAuthError(
+      "expired_or_revoked",
+      "codex-subscription: the Codex CLI rejected the request as unauthenticated (session expired or revoked). Run `codex login` again to re-authenticate, then retry."
+    );
+  }
+  if (TIMEOUT_PATTERN.test(combined)) {
+    return new CodexSubscriptionTimeoutError(timeoutMs);
+  }
+  const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
+  return new Error(
+    `codex-subscription: codex exec failed (${exitLabel}): ${summarizeOutput(result.stderr, result.stdout)}`
+  );
+}
+function summarizeOutput(stderr, stdout) {
+  const summary = [stderr.trim(), stdout.trim()].filter((part) => part.length > 0).join("\n");
+  if (summary.length === 0) {
+    return "no process output";
+  }
+  return redactSecretEchoes(summary).slice(-OUTPUT_SUMMARY_LIMIT);
+}
+function redactSecretEchoes(value) {
+  let redacted = value;
+  for (const pattern of SECRET_ECHO_PATTERNS) {
+    redacted = redacted.replace(pattern, "[redacted]");
+  }
+  return redacted;
+}
+function usageFrom(result) {
+  const usage = parseCodexJsonlUsage(`${result.stdout}
+${result.stderr}`);
+  if (!usage) {
+    return {};
+  }
+  return {
+    usage: {
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      totalTokens: usage.inputTokens + usage.outputTokens
+    }
+  };
+}
+function parseCodexJsonlUsage(output) {
+  let usage;
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.type !== "turn.completed" || !event.usage) continue;
+      const inputTokens = readCounter(event.usage.input_tokens);
+      const outputTokens = readCounter(event.usage.output_tokens);
+      if (inputTokens !== void 0 && outputTokens !== void 0) {
+        usage = { inputTokens, outputTokens };
+      }
+    } catch {
+    }
+  }
+  return usage;
+}
+function readCounter(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return value;
+}
+function abortErrorOf(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  if (signal.reason !== void 0) return new Error(String(signal.reason));
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+function appendBounded(existing, next) {
+  const redacted = redactSecretEchoes(existing + next);
+  return redacted.length > STDIO_LIMIT ? redacted.slice(-STDIO_LIMIT) : redacted;
+}
+async function runLoginStatusSubprocess(executable, env, timeoutMs) {
+  return await runSubprocess(executable, ["login", "status"], {
+    env,
+    stdin: void 0,
+    timeoutMs,
+    timeoutLabel: "login status"
+  });
+}
+async function runCodexExecSubprocess(request) {
+  const result = await runSubprocess(request.executable, request.args, {
+    env: request.env,
+    stdin: request.input,
+    timeoutMs: request.timeoutMs,
+    timeoutLabel: "exec",
+    signal: request.signal,
+    cwd: request.workspacePath
+  });
+  let outputText = "";
+  try {
+    outputText = (await readFile(request.outputPath, "utf8")).trim();
+  } catch {
+  }
+  return { ...result, outputText };
+}
+async function runSubprocess(executable, args, options) {
+  return await new Promise((resolve, reject) => {
+    if (options.signal?.aborted) {
+      reject(abortErrorOf(options.signal));
+      return;
+    }
+    const child = launchProcess(executable, args, {
+      ...options.cwd ? { cwd: options.cwd } : {},
+      env: options.env,
+      stdio: [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killTimeout;
+    const clearKillTimeout = () => {
+      if (killTimeout) {
+        clearTimeout(killTimeout);
+        killTimeout = void 0;
+      }
+    };
+    const terminate = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const scheduleForcedKill = () => {
+      clearKillTimeout();
+      killTimeout = setTimeout(() => terminate("SIGKILL"), 1e3);
+      killTimeout.unref();
+    };
+    const onAbort = () => {
+      terminate("SIGTERM");
+      scheduleForcedKill();
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timeout = options.timeoutMs ? setTimeout(() => {
+      timedOut = true;
+      stderr = appendBounded(
+        stderr,
+        `
+codex-subscription: ${options.timeoutLabel} timed out after ${options.timeoutMs}ms.`
+      );
+      terminate("SIGTERM");
+      scheduleForcedKill();
+    }, options.timeoutMs) : void 0;
+    timeout?.unref();
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout = appendBounded(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = appendBounded(stderr, chunk);
+    });
+    child.stdin?.on("error", (error) => {
+      stderr = appendBounded(stderr, `
+codex-subscription: stdin error: ${error.code ?? error.message}`);
+    });
+    const settle = (fn) => {
+      clearTimeout(timeout);
+      clearKillTimeout();
+      options.signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    child.on("error", (error) => {
+      settle(() => {
+        reject(
+          child.pid ? new Error(`codex-subscription: codex CLI failed after start: ${safeMessage(error)}`, { cause: error }) : new CodexSubscriptionAuthError(
+            "unauthenticated",
+            `codex-subscription: codex CLI not found at \`${executable}\` \u2014 install the Codex CLI and run \`codex login\` with a ChatGPT account, then retry.`
+          )
+        );
+      });
+    });
+    child.on("close", (status, signal) => {
+      settle(() => {
+        resolve({
+          status: timedOut ? status ?? 124 : status,
+          signal: timedOut ? signal ?? "SIGTERM" : signal,
+          stdout,
+          stderr
+        });
+      });
+    });
+    if (options.stdin !== void 0) {
+      try {
+        child.stdin?.end(options.stdin);
+      } catch (error) {
+        log.debug(`codex-subscription: failed writing prompt to stdin: ${safeMessage(error)}`);
+      }
+    }
+  });
+}
+function safeMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/fallback-llm.ts
 function gatewayTaskChainOptions(config) {
   if (config.modelSource !== "gateway") return {};
   if (config.taskModelChain) return { modelChain: config.taskModelChain };
@@ -71,7 +595,11 @@ var BUILT_IN_PROVIDER_FALLBACKS = {
     api: "openai-responses",
     models: [],
     [PROVIDER_API_KEY_FIELD]: MANAGED_SECRETREF_MARKER
-  }
+  },
+  // Subscription-OAuth extraction provider (issue #2784): no apiKey — the
+  // codex CLI login authenticates, via the runner the codex-subscription
+  // module registers on this same seam.
+  [CODEX_SUBSCRIPTION_PROVIDER_ID]: codexSubscriptionBuiltinProviderConfig()
 };
 var FallbackLlmClient = class {
   gatewayConfig;
@@ -442,6 +970,7 @@ var FallbackLlmClient = class {
       return await this.callAnthropic(effectiveConfig, model.modelId, messages, options);
     }
     if (model.providerConfig.api === "codex-cli") {
+      ensureCodexSubscriptionRunnerRegistered();
       return await callCodexCliFallback(
         effectiveConfig,
         model.modelId,
@@ -762,7 +1291,7 @@ function readGatewayWorkspaceDir(gatewayConfig) {
   return normalizeRuntimePath(raw.workspaceDir) ?? normalizeRuntimePath(raw.workspacePath) ?? normalizeRuntimePath(raw.workspace);
 }
 function defaultOpenClawWorkspaceDir() {
-  return path.join(resolveHomeDir(), ".openclaw", "workspace");
+  return path2.join(resolveHomeDir(), ".openclaw", "workspace");
 }
 function extractResponsesOutputText(data) {
   if (typeof data.output_text === "string" && data.output_text.trim().length > 0) {
@@ -784,8 +1313,15 @@ function extractResponsesOutputText(data) {
 }
 
 export {
+  CODEX_SUBSCRIPTION_PROVIDER_ID,
+  codexSubscriptionBuiltinProviderConfig,
+  CodexSubscriptionAuthError,
+  CodexSubscriptionConfigError,
+  CodexSubscriptionTimeoutError,
+  createCodexSubscriptionRunner,
+  ensureCodexSubscriptionRunnerRegistered,
   gatewayTaskChainOptions,
   fallbackLlmRuntimeContextFromConfig,
   FallbackLlmClient
 };
-//# sourceMappingURL=chunk-TLPZ6MKZ.js.map
+//# sourceMappingURL=chunk-YEN4TREG.js.map