@bryanhu/codexly 0.11.2 → 0.13.0

package/dist/{chunk-YMFGL4ZR.js → chunk-TVRHN6RY.js}

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { WorkbenchPetProviderError, PendingRequestResolutionError } from './chunk-RNTA4MFS.js';
-import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_TEXT_BYTES } from './chunk-2NJ4CTQP.js';
+import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_TEXT_BYTES } from './chunk-G4BIMVEW.js';
 import { __commonJS, __require, __toESM } from './chunk-K6J42667.js';
 import { execFile, spawn } from 'child_process';
 import { constants, mkdtempSync, rmSync, createReadStream, mkdirSync, unlinkSync, renameSync, writeFileSync, openSync, readSync, closeSync, statSync } from 'fs';
@@ -4466,7 +4466,8 @@ var require_pino = __commonJS({
   }
 });
 var execFileAsync = promisify(execFile);
-var SUPPORTED_CODEX_VERSION = "0.151.0";
+var SUPPORTED_CODEX_VERSION = "0.153.4";
+var SUPPORTED_CODEX_VERSION_RANGE = ">=0.153.4,<0.154.0";
 var BUNDLED_CODEX_TARGETS = {
   "darwin-arm64": {
     executableName: "codex",
@@ -4580,7 +4581,9 @@ async function locateCodexBinary(options = {}) {
   if (pathBinary) {
     return { path: resolve(pathBinary), source: "path" };
   }
-  throw new Error("Codex binary was not found; install @openai/codex or configure --codex-bin");
+  throw new Error(
+    `Codex binary was not found; install @openai/codex@${SUPPORTED_CODEX_VERSION} or configure --codex-bin`
+  );
 }
 async function executeCodexVersion(binaryPath) {
   const { stdout } = await execFileAsync(binaryPath, ["--version"], {
@@ -4604,8 +4607,12 @@ async function checkCodexVersion(binaryPath, options = {}) {
   if (!version) {
     throw new Error(`Invalid Codex version output: ${raw || "<empty>"}`);
   }
-  if (version !== SUPPORTED_CODEX_VERSION) {
-    throw new Error(`Unsupported Codex version ${version}; expected ${SUPPORTED_CODEX_VERSION}`);
+  const [major, minor, patch] = version.split("-", 1)[0]?.split(".").map(Number) ?? [];
+  const isPrerelease = version.includes("-");
+  if (major !== 0 || minor !== 153 || patch === void 0 || patch < 4 || isPrerelease) {
+    throw new Error(
+      `Unsupported Codex version ${version}; expected ${SUPPORTED_CODEX_VERSION_RANGE}`
+    );
   }
   return { raw, version };
 }
@@ -4617,6 +4624,7 @@ var CodexProtocolMappingError = class extends Error {
 };
 var MAX_COMMAND_OUTPUT_BYTES = 1048576;
 var MAX_COMMAND_OUTPUT_LINES = 1e4;
+var CODEX_THREAD_CONFIG = Object.freeze({ "tools.update_plan.enabled": true });
 var CODEX_MAPPED_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
   "error",
   "guardianWarning",
@@ -4674,6 +4682,8 @@ var CODEX_IGNORED_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
   "item/fileChange/outputDelta",
   "mcpServer/oauthLogin/completed",
   "mcpServer/event/stream/notification",
+  "modelProvider/authRecoveryCompleted",
+  "modelProvider/authRecoveryStarted",
   "process/exited",
   "process/outputDelta",
   "rawResponse/completed",
@@ -5094,7 +5104,7 @@ function mapMcpServerElicitationRequest(serverRequest, project) {
     type: "mcp_elicitation"
   };
   const mode = expectString(params["mode"], "MCP elicitation mode");
-  const request = mode === "form" ? { ...identity, fields: mapFormFields(params["requestedSchema"]), mode } : mode === "url" ? { ...identity, mode, url: mapSafeUrl(params["url"]) } : mode === "openai/form" ? { ...identity, mode: "unsupported" } : (() => {
+  const request = mode === "form" ? { ...identity, fields: mapFormFields(params["requestedSchema"]), mode } : mode === "url" ? { ...identity, mode, url: mapSafeUrl(params["url"]) } : mode === "openai/form" || mode === "openaiForm" ? { ...identity, mode: "unsupported" } : (() => {
     throw new CodexProtocolMappingError("MCP elicitation mode is unsupported");
   })();
   return { providerRequestId: serverRequest.id, request };
@@ -6291,6 +6301,37 @@ function mapApprovalReviewAction(value) {
   }
   throw new CodexProtocolMappingError("Codex automatic approval review action type is invalid");
 }
+function mapAsyncUserInputQuestions(value) {
+  if (value === null) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new CodexProtocolMappingError("Codex agent message questions must be an array or null");
+  }
+  return value.map((questionValue) => {
+    const question = expectRecord(questionValue, "Codex asynchronous user input question");
+    const title = expectString(question["title"], "Codex asynchronous user input question title");
+    const options = question["options"];
+    if (options !== null && !Array.isArray(options)) {
+      throw new CodexProtocolMappingError(
+        "Codex asynchronous user input question options must be an array or null"
+      );
+    }
+    if (Array.isArray(options)) {
+      for (const option of options) {
+        if (typeof option !== "string") {
+          throw new CodexProtocolMappingError(
+            "Codex asynchronous user input question options must contain only strings"
+          );
+        }
+      }
+    }
+    return {
+      title,
+      options: options === null ? null : options.map((option) => expectString(option, "Codex asynchronous user input option"))
+    };
+  });
+}
 function mapApprovalReviewItem(params) {
   const review = expectRecord(params["review"], "Codex automatic approval review");
   const riskLevel = optionalString(review["riskLevel"]);
@@ -6334,6 +6375,7 @@ function mapAgentItem(value, subagentNicknames = /* @__PURE__ */ new Map(), mapI
     }
     case "agentMessage": {
       const text = expectString(item["text"], "Codex agent message text");
+      const questions = mapAsyncUserInputQuestions(item["questions"]);
       if (item["delivery"] !== null && item["delivery"] !== "async") {
         throw new CodexProtocolMappingError("Codex agent message delivery must be async or null");
       }
@@ -6341,6 +6383,7 @@ function mapAgentItem(value, subagentNicknames = /* @__PURE__ */ new Map(), mapI
       return {
         id,
         ...phase === void 0 ? {} : { phase },
+        ...questions === void 0 ? {} : { questions },
         role: "assistant",
         text,
         type: "message"
@@ -6482,6 +6525,60 @@ function normalizedTitle(thread) {
   const preview = optionalString(thread["preview"])?.trim().split(/\r?\n/u)[0]?.trim();
   return preview?.length ? preview : "\u65B0\u804A\u5929";
 }
+var CODEX_PINNED_THREAD_SECTION_ID = "01984de2-8f74-7c91-a3b2-5c5e937cf318";
+function isPinnedThreadSection(value) {
+  if (value === null) return false;
+  const section = expectRecord(value, "Codex thread section");
+  const sectionId = expectString(section["id"], "Codex thread section id");
+  expectString(section["name"], "Codex thread section name");
+  const appearance = section["appearance"];
+  if (appearance !== null && (!isRecord(appearance) || appearance["icon"] !== null && typeof appearance["icon"] !== "string" || appearance["color"] !== null && typeof appearance["color"] !== "string")) {
+    throw new CodexProtocolMappingError("Codex thread section appearance is invalid");
+  }
+  return sectionId === CODEX_PINNED_THREAD_SECTION_ID;
+}
+function isProjectThread(thread, project) {
+  const nativeProjectId = thread["projectId"];
+  if (nativeProjectId !== null && typeof nativeProjectId !== "string") {
+    throw new CodexProtocolMappingError("Codex thread projectId must be a string or null");
+  }
+  if (project.kind === "project") {
+    return nativeProjectId === project.id;
+  }
+  if (nativeProjectId !== null) {
+    return false;
+  }
+  return true;
+}
+function assertProjectThread(thread, project) {
+  if (!isProjectThread(thread, project)) {
+    return Promise.reject(
+      new CodexProtocolMappingError("Codex thread does not belong to the active project")
+    );
+  }
+  return Promise.resolve();
+}
+async function mapAgentTask(thread, project) {
+  await assertProjectThread(thread, project);
+  if (thread["model"] !== null && typeof thread["model"] !== "string") {
+    throw new CodexProtocolMappingError("Codex thread model must be a string or null");
+  }
+  if (thread["reasoningEffort"] !== null && typeof thread["reasoningEffort"] !== "string") {
+    throw new CodexProtocolMappingError("Codex thread reasoningEffort must be a string or null");
+  }
+  return {
+    id: expectString(thread["id"], "Codex thread id"),
+    pinned: isPinnedThreadSection(thread["section"]),
+    projectId: project.id,
+    // 线程配置来自原生元数据，与应用内保存的下次提交设置分别保留。
+    threadConfiguration: {
+      model: thread["model"],
+      reasoningEffort: thread["reasoningEffort"]
+    },
+    title: normalizedTitle(thread),
+    updatedAt: toDateTime(thread["updatedAt"], "Codex thread updatedAt")
+  };
+}
 function mapAgentModel(value) {
   const model = expectRecord(value, "Codex model");
   const multiAgentVersion = model["multiAgentVersion"];
@@ -8991,20 +9088,6 @@ async function releaseCodexProjectThreads(client, logger, projectId, taskIds) {
 }
 
 // packages/provider-codex/src/agent-provider-base.ts
-var CODEX_PINNED_THREAD_SECTION_ID = "01984de2-8f74-7c91-a3b2-5c5e937cf318";
-function isPinnedThreadSection(value) {
-  if (value === null) {
-    return false;
-  }
-  const section = expectRecord(value, "Codex thread section");
-  const sectionId = expectString(section["id"], "Codex thread section id");
-  expectString(section["name"], "Codex thread section name");
-  const appearance = section["appearance"];
-  if (appearance !== null && (!isRecord(appearance) || appearance["icon"] !== null && typeof appearance["icon"] !== "string" || appearance["color"] !== null && typeof appearance["color"] !== "string")) {
-    throw new CodexProtocolMappingError("Codex thread section appearance is invalid");
-  }
-  return sectionId === CODEX_PINNED_THREAD_SECTION_ID;
-}
 async function canonicalPathIdentity(path) {
   try {
     return normalizedPathIdentity(await realpath(path));
@@ -9019,27 +9102,6 @@ async function isSameCanonicalPath(left, right) {
   ]);
   return leftIdentity === rightIdentity;
 }
-function isProjectThread(thread, project) {
-  const nativeProjectId = thread["projectId"];
-  if (nativeProjectId !== null && typeof nativeProjectId !== "string") {
-    throw new CodexProtocolMappingError("Codex thread projectId must be a string or null");
-  }
-  if (project.kind === "project") {
-    return nativeProjectId === project.id;
-  }
-  if (nativeProjectId !== null) {
-    return false;
-  }
-  return true;
-}
-function assertProjectThread(thread, project) {
-  if (!isProjectThread(thread, project)) {
-    return Promise.reject(
-      new CodexProtocolMappingError("Codex thread does not belong to the active project")
-    );
-  }
-  return Promise.resolve();
-}
 function isThreadNotLoadedError(error) {
   return error instanceof RpcResponseError && error.code === -32600 && error.message.startsWith("thread not loaded:");
 }
@@ -9065,16 +9127,6 @@ function createUnmaterializedTaskSnapshot(task) {
     turnsNextCursor: null
   };
 }
-async function mapAgentTask(thread, project) {
-  await assertProjectThread(thread, project);
-  return {
-    id: expectString(thread["id"], "Codex thread id"),
-    pinned: isPinnedThreadSection(thread["section"]),
-    projectId: project.id,
-    title: normalizedTitle(thread),
-    updatedAt: toDateTime(thread["updatedAt"], "Codex thread updatedAt")
-  };
-}
 var CodexAgentProviderBase = class {
   client;
   eventListenersIncludingEphemeral = /* @__PURE__ */ new Set();
@@ -9201,6 +9253,7 @@ var CodexAgentProviderBase = class {
     this.assertKnownProjectTask(taskId);
     const response = expectRecord(
       await this.client.request("thread/fork", {
+        config: CODEX_THREAD_CONFIG,
         // 仅返回元数据并覆盖完整运行时根；历史统一分页读取，避免单个 JSONL 帧过大。
         excludeTurns: true,
         ...lastTurnId === void 0 ? {} : { lastTurnId },
@@ -9394,10 +9447,10 @@ var CodexAgentProviderQueue = class extends CodexAgentProviderBase {
       return { name: skill.name, path: skill.path, type: "skill" };
     });
     const images = input.images.map((image) => {
-      if (!image.url.startsWith(`data:${image.mediaType};base64,`)) {
-        throw new CodexProtocolMappingError("Provider image URL does not match its media type");
+      if (image.path.length === 0) {
+        throw new CodexProtocolMappingError("Provider image path must not be empty");
       }
-      return { type: "image", url: image.url };
+      return { detail: image.detail, path: image.path, type: "localImage" };
     });
     const files = input.files.map(createCodexFileTextInput);
     const textAttachments = input.textAttachments.map((attachment) => ({
@@ -9567,6 +9620,7 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
   async startTask(options = {}) {
     const response = expectRecord(
       await this.client.request("thread/start", {
+        config: CODEX_THREAD_CONFIG,
         historyMode: "paginated",
         ...this.project.kind === "temporary" ? {} : {
           cwd: this.project.rootPath,
@@ -9766,6 +9820,22 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
       "turn/interrupt response"
     );
   }
+  async updateTurnApprovalsReviewer(taskId, turnId, reviewer) {
+    this.assertKnownProjectTask(taskId);
+    const response = expectRecord(
+      await this.client.request("turn/settings/update", {
+        threadId: taskId,
+        turnId,
+        approvalsReviewer: reviewer
+      }),
+      "turn/settings/update response"
+    );
+    const status = response["status"];
+    if (status !== "applied" && status !== "targetUnavailable") {
+      throw new CodexProtocolMappingError("Codex turn settings update status is invalid");
+    }
+    return status;
+  }
   async listBackgroundTerminals(taskId) {
     this.assertKnownProjectTask(taskId);
     const terminals = [];
@@ -9826,6 +9896,9 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
     }
   }
   async listTasks(input = {}) {
+    if (input.completed === true) {
+      return this.listCompletedTasks(input);
+    }
     const response = expectRecord(
       await this.client.request("thread/list", {
         ...input.archived === true ? { archived: true } : {},
@@ -9862,6 +9935,49 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
     const data = [...pendingTasks, ...nativeTasks];
     return { data, nextCursor: nextCursor ?? null };
   }
+  async listCompletedTasks(input) {
+    const limit = Math.min(100, Math.max(1, input.limit ?? 10));
+    const requestedCursors = /* @__PURE__ */ new Set();
+    const data = [];
+    let cursor = input.cursor;
+    while (data.length < limit) {
+      const response = expectRecord(
+        await this.client.request("thread/list", {
+          ...cursor === void 0 ? {} : { cursor },
+          limit: limit - data.length,
+          ...this.project.kind === "temporary" ? { projectId: null } : { projectId: this.project.id },
+          sortDirection: "desc",
+          sortKey: "updated_at"
+        }),
+        "thread/list response"
+      );
+      if (!Array.isArray(response["data"])) {
+        throw new CodexProtocolMappingError("thread/list data must be an array");
+      }
+      for (const value of response["data"]) {
+        const thread = expectRecord(value, "Codex thread");
+        const status = expectString(
+          expectRecord(thread["status"], "Codex thread status")["type"],
+          "Codex thread status type"
+        );
+        if (status !== "idle" && status !== "notLoaded") continue;
+        data.push(await mapAgentTask(thread, this.project));
+        if (data.length === limit) break;
+      }
+      const nextCursor = response["nextCursor"];
+      if (nextCursor === null || nextCursor === void 0) {
+        return { data, nextCursor: null };
+      }
+      const next = expectString(nextCursor, "thread/list nextCursor");
+      if (requestedCursors.has(next)) {
+        throw new CodexProtocolMappingError("thread/list returned a repeated cursor");
+      }
+      requestedCursors.add(next);
+      cursor = next;
+      if (data.length === limit) return { data, nextCursor: next };
+    }
+    return { data, nextCursor: null };
+  }
 };
 
 // packages/provider-codex/src/task-history-pagination.ts
@@ -10584,6 +10700,7 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
     const resumePromise = (async () => {
       const response = expectRecord(
         await this.client.request("thread/resume", {
+          config: CODEX_THREAD_CONFIG,
           // 恢复只负责加载运行时，Snapshot 历史继续通过分页接口获取。
           excludeTurns: true,
           // 恢复 Project Task 时覆盖旧运行时配置，使全部根立即生效。
@@ -10611,7 +10728,10 @@ var CodexAgentProviderEvents = class extends CodexAgentProviderTasks {
   async resumeReviewWorker(workerTaskId) {
     try {
       const response = expectRecord(
-        await this.client.request("thread/resume", { threadId: workerTaskId }),
+        await this.client.request("thread/resume", {
+          config: CODEX_THREAD_CONFIG,
+          threadId: workerTaskId
+        }),
         "review worker thread/resume response"
       );
       const thread = expectRecord(response["thread"], "review worker thread/resume thread");
@@ -10812,12 +10932,99 @@ var CodexNativeStateSnapshot = class {
   }
 };
 
+// packages/provider-codex/src/provider-connection-config.ts
+var DEFAULT_CUSTOM_PROVIDER_ID = "OpenAI";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString3(value, maxLength) {
+  return typeof value === "string" ? value.slice(0, maxLength) : null;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function readConfiguredProviderId(config) {
+  return nonEmptyString(config["model_provider"]);
+}
+function readModelProviderConfig(config, providerId) {
+  const providers = isRecord6(config["model_providers"]) ? config["model_providers"] : null;
+  const provider = providers?.[providerId];
+  return isRecord6(provider) ? provider : null;
+}
+function readActiveProvider(config) {
+  const providerId = readConfiguredProviderId(config) ?? "openai";
+  const openaiBaseUrl = optionalString3(config["openai_base_url"], 2048);
+  if (providerId === "openai") {
+    return openaiBaseUrl === null || openaiBaseUrl.length === 0 ? { customBaseUrl: null, mode: "official" } : { customBaseUrl: openaiBaseUrl, mode: "custom" };
+  }
+  const provider = readModelProviderConfig(config, providerId);
+  const baseUrl = optionalString3(provider?.["base_url"], 2048);
+  return {
+    customBaseUrl: baseUrl === null || baseUrl.length === 0 ? null : baseUrl,
+    mode: "custom"
+  };
+}
+function createCustomProviderConfigUpdate(config, baseUrl, hasApiKey) {
+  const configuredProviderId = readConfiguredProviderId(config);
+  const existingProviderId = readActiveProvider(config).mode === "custom" ? configuredProviderId : null;
+  const providerId = existingProviderId ?? DEFAULT_CUSTOM_PROVIDER_ID;
+  if (providerId === "openai") {
+    return {
+      edits: [{ keyPath: "openai_base_url", mergeStrategy: "upsert", value: baseUrl }],
+      providerId,
+      requiresOpenaiAuth: true,
+      rollbackEdits: [
+        {
+          keyPath: "openai_base_url",
+          mergeStrategy: "replace",
+          value: config["openai_base_url"] ?? null
+        }
+      ]
+    };
+  }
+  const previousProvider = readModelProviderConfig(config, providerId);
+  const previousRequiresOpenaiAuth = previousProvider?.["requires_openai_auth"];
+  const requiresOpenaiAuth = hasApiKey ? true : typeof previousRequiresOpenaiAuth === "boolean" ? previousRequiresOpenaiAuth : false;
+  const configuredName = nonEmptyString(previousProvider?.["name"]);
+  const edits = [
+    {
+      keyPath: `model_providers.${providerId}`,
+      mergeStrategy: "upsert",
+      value: {
+        base_url: baseUrl,
+        name: configuredName ?? providerId,
+        requires_openai_auth: requiresOpenaiAuth,
+        wire_api: "responses"
+      }
+    }
+  ];
+  const rollbackEdits = [
+    {
+      keyPath: `model_providers.${providerId}`,
+      mergeStrategy: "replace",
+      value: previousProvider
+    }
+  ];
+  if (existingProviderId === null) {
+    edits.push({
+      keyPath: "model_provider",
+      mergeStrategy: "upsert",
+      value: DEFAULT_CUSTOM_PROVIDER_ID
+    });
+    rollbackEdits.push({
+      keyPath: "model_provider",
+      mergeStrategy: "replace",
+      value: config["model_provider"] ?? null
+    });
+  }
+  return { edits, providerId, requiresOpenaiAuth, rollbackEdits };
+}
+
 // packages/provider-codex/src/provider-connection.ts
-var CUSTOM_PROVIDER_ID = "codexly_custom";
 var DEFAULT_MODEL_REQUEST_TIMEOUT_MS = 1e4;
 var DEFAULT_MODEL_RESPONSE_MAX_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MODEL_COUNT_LIMIT = 1e3;
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function requiredString(value, field) {
@@ -10826,7 +11033,7 @@ function requiredString(value, field) {
   }
   return value;
 }
-function optionalString3(value, maxLength) {
+function optionalString4(value, maxLength) {
   return typeof value === "string" ? value.slice(0, maxLength) : null;
 }
 function normalizeBaseUrl(value) {
@@ -10866,39 +11073,25 @@ async function readBoundedBody(response, maximumBytes) {
   return Buffer$1.concat(chunks, total);
 }
 function mapAccount(value) {
-  if (!isRecord6(value)) return null;
+  if (!isRecord7(value)) return null;
   if (value["type"] === "apiKey") return { type: "apiKey" };
   if (value["type"] === "chatgpt") {
     return {
-      email: optionalString3(value["email"], 320),
-      planType: optionalString3(value["planType"], 64),
+      email: optionalString4(value["email"], 320),
+      planType: optionalString4(value["planType"], 64),
       type: "chatgpt"
     };
   }
   return null;
 }
 function readConfig(response) {
-  if (!isRecord6(response) || !isRecord6(response["config"])) {
+  if (!isRecord7(response) || !isRecord7(response["config"])) {
     throw new CodexProviderConnectionError("Codex returned an invalid config response");
   }
   return response["config"];
 }
-function readActiveProvider(config) {
-  const providerId = typeof config["model_provider"] === "string" ? config["model_provider"] : "openai";
-  const openaiBaseUrl = optionalString3(config["openai_base_url"], 2048);
-  if (providerId === "openai") {
-    return openaiBaseUrl === null || openaiBaseUrl.length === 0 ? { customBaseUrl: null, mode: "official" } : { customBaseUrl: openaiBaseUrl, mode: "custom" };
-  }
-  const providers = isRecord6(config["model_providers"]) ? config["model_providers"] : null;
-  const provider = providers && isRecord6(providers[providerId]) ? providers[providerId] : null;
-  const baseUrl = optionalString3(provider?.["base_url"], 2048);
-  return {
-    customBaseUrl: baseUrl === null || baseUrl.length === 0 ? null : baseUrl,
-    mode: "custom"
-  };
-}
 function readAccountResponse(response) {
-  if (!isRecord6(response) || typeof response["requiresOpenaiAuth"] !== "boolean") {
+  if (!isRecord7(response) || typeof response["requiresOpenaiAuth"] !== "boolean") {
     throw new CodexProviderConnectionError("Codex returned an invalid account response");
   }
   return {
@@ -10917,12 +11110,8 @@ function createConnectionStatus(config, accountState, pendingLogin) {
     state: pendingLogin?.state ?? (connected ? "connected" : "disconnected")
   };
 }
-function readCustomProviderConfig(config) {
-  const providers = isRecord6(config["model_providers"]) ? config["model_providers"] : null;
-  return providers?.[CUSTOM_PROVIDER_ID] ?? null;
-}
 function readProviderCapabilities(response) {
-  if (!isRecord6(response) || typeof response["namespaceTools"] !== "boolean" || typeof response["imageGeneration"] !== "boolean" || typeof response["webSearch"] !== "boolean") {
+  if (!isRecord7(response) || typeof response["namespaceTools"] !== "boolean" || typeof response["imageGeneration"] !== "boolean" || typeof response["webSearch"] !== "boolean") {
     throw new CodexProviderConnectionError("Codex returned invalid model provider capabilities");
   }
 }
@@ -10949,13 +11138,13 @@ var CodexProviderConnectionService = class {
     if (method === "account/updated") {
       this.#nativeState.clear();
     }
-    if (method === "account/updated" && isRecord6(params) && params["authMode"] === "chatgpt") {
+    if (method === "account/updated" && isRecord7(params) && params["authMode"] === "chatgpt") {
       this.#pendingLogin = null;
       return;
     }
     if (method !== "account/login/completed") return;
     this.#nativeState.clear();
-    if (!isRecord6(params)) return;
+    if (!isRecord7(params)) return;
     const loginId = params["loginId"];
     if (typeof loginId !== "string" || this.#pendingLogin?.loginId !== loginId) return;
     if (params["success"] === true) {
@@ -10963,7 +11152,7 @@ var CodexProviderConnectionService = class {
       return;
     }
     this.#pendingLogin = {
-      error: optionalString3(params["error"], 1e3) ?? "Login failed",
+      error: optionalString4(params["error"], 1e3) ?? "Login failed",
       loginId,
       state: "failed"
     };
@@ -10988,7 +11177,7 @@ var CodexProviderConnectionService = class {
       type: "chatgpt",
       useHostedLoginSuccessPage: true
     });
-    if (!isRecord6(response) || response["type"] !== "chatgpt") {
+    if (!isRecord7(response) || response["type"] !== "chatgpt") {
       throw new CodexProviderConnectionError("Codex returned an invalid login response");
     }
     const loginId = requiredString(response["loginId"], "login id");
@@ -11012,21 +11201,26 @@ var CodexProviderConnectionService = class {
   async readConfig() {
     return this.#nativeState.readConfig();
   }
-  async configureCustom(input) {
+  async configureCustom(input, persistedModels) {
     const baseUrl = normalizeBaseUrl(input.baseUrl);
     const apiKey = input.apiKey;
     if (apiKey?.trim().length === 0) {
       throw new CodexProviderConnectionError("Custom API key cannot be blank");
     }
     const manualModels = normalizeManualModels(input.models ?? [], this.#modelCountLimit);
-    let discoveredModels;
-    try {
-      discoveredModels = await this.#discoverModels(baseUrl, apiKey);
-    } catch (error) {
-      if (manualModels.length === 0) throw error;
-      discoveredModels = [];
+    let models;
+    if (input.models === void 0 && persistedModels !== void 0) {
+      models = persistedModels;
+    } else {
+      let discoveredModels;
+      try {
+        discoveredModels = await this.#discoverModels(baseUrl, apiKey);
+      } catch (error) {
+        if (manualModels.length === 0) throw error;
+        discoveredModels = [];
+      }
+      models = mapCustomModels([...discoveredModels, ...manualModels], this.#modelCountLimit);
     }
-    const models = mapCustomModels([...discoveredModels, ...manualModels], this.#modelCountLimit);
     this.#nativeState.clear();
     const [configResponse, accountResponse] = await Promise.all([
       this.#client.request("config/read", { includeLayers: false }),
@@ -11034,20 +11228,13 @@ var CodexProviderConnectionService = class {
     ]);
     const previousConfig = readConfig(configResponse);
     const previousAccountState = readAccountResponse(accountResponse);
+    const configUpdate = createCustomProviderConfigUpdate(
+      previousConfig,
+      baseUrl,
+      apiKey !== void 0
+    );
     await this.#client.request("config/batchWrite", {
-      edits: [
-        {
-          keyPath: `model_providers.${CUSTOM_PROVIDER_ID}`,
-          mergeStrategy: "upsert",
-          value: {
-            base_url: baseUrl,
-            name: "Codexly Custom API",
-            requires_openai_auth: apiKey !== void 0,
-            wire_api: "responses"
-          }
-        },
-        { keyPath: "model_provider", mergeStrategy: "upsert", value: CUSTOM_PROVIDER_ID }
-      ]
+      edits: configUpdate.edits
     });
     this.#nativeState.clear();
     try {
@@ -11057,7 +11244,7 @@ var CodexProviderConnectionService = class {
           apiKey,
           type: "apiKey"
         });
-        if (!isRecord6(loginResponse) || loginResponse["type"] !== "apiKey") {
+        if (!isRecord7(loginResponse) || loginResponse["type"] !== "apiKey") {
           throw new CodexProviderConnectionError(
             "Codex returned an invalid API key login response"
           );
@@ -11066,18 +11253,7 @@ var CodexProviderConnectionService = class {
     } catch (error) {
       try {
         await this.#client.request("config/batchWrite", {
-          edits: [
-            {
-              keyPath: `model_providers.${CUSTOM_PROVIDER_ID}`,
-              mergeStrategy: "replace",
-              value: readCustomProviderConfig(previousConfig)
-            },
-            {
-              keyPath: "model_provider",
-              mergeStrategy: "replace",
-              value: previousConfig["model_provider"] ?? null
-            }
-          ]
+          edits: configUpdate.rollbackEdits
         });
         this.#nativeState.clear();
       } catch {
@@ -11089,13 +11265,16 @@ var CodexProviderConnectionService = class {
     }
     this.#pendingLogin = null;
     this.#nativeState.clear();
-    const activeConfig = {
-      model_provider: CUSTOM_PROVIDER_ID,
+    const activeConfig = configUpdate.providerId === "openai" ? { model_provider: "openai", openai_base_url: baseUrl } : {
+      model_provider: configUpdate.providerId,
       model_providers: {
-        [CUSTOM_PROVIDER_ID]: { base_url: baseUrl }
+        [configUpdate.providerId]: { base_url: baseUrl }
       }
     };
-    const activeAccountState = apiKey === void 0 ? { account: previousAccountState.account, requiresOpenaiAuth: false } : { account: { type: "apiKey" }, requiresOpenaiAuth: true };
+    const activeAccountState = apiKey === void 0 ? {
+      account: previousAccountState.account,
+      requiresOpenaiAuth: configUpdate.requiresOpenaiAuth
+    } : { account: { type: "apiKey" }, requiresOpenaiAuth: true };
     return {
       models,
       status: createConnectionStatus(activeConfig, activeAccountState, null)
@@ -11224,6 +11403,10 @@ var CodexRuntimeProjectProvider = class {
     this.#runtime.assertTaskOwner(this.#project, taskId);
     return this.#delegate.interruptTurn(taskId, turnId);
   }
+  updateTurnApprovalsReviewer(taskId, turnId, reviewer) {
+    this.#runtime.assertTaskOwner(this.#project, taskId);
+    return this.#delegate.updateTurnApprovalsReviewer(taskId, turnId, reviewer);
+  }
   async listBackgroundTerminals(taskId) {
     await this.#ensureTaskOwner(taskId);
     return this.#delegate.listBackgroundTerminals(taskId);
@@ -11621,7 +11804,7 @@ var CodexFuzzyFileSearchService = class {
 var DEFAULT_CHANGE_DEBOUNCE_MS = 100;
 var MAX_GIT_REPOSITORIES_PER_ROOT = 32;
 var MAX_CODEX_GIT_METADATA_WATCHES = 128;
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function pathExists(path) {
@@ -11750,7 +11933,7 @@ var CodexGitMetadataWatchService = class {
     await state.operation;
   }
   receiveNotification(method, params) {
-    if (method !== "fs/changed" || !isRecord7(params) || typeof params["watchId"] !== "string" || !Array.isArray(params["changedPaths"]) || !params["changedPaths"].every((path) => typeof path === "string")) {
+    if (method !== "fs/changed" || !isRecord8(params) || typeof params["watchId"] !== "string" || !Array.isArray(params["changedPaths"]) || !params["changedPaths"].every((path) => typeof path === "string")) {
       return;
     }
     const owner = this.#watchOwners.get(params["watchId"]);
@@ -11817,7 +12000,7 @@ var CodexGitMetadataWatchService = class {
           path: descriptor.path,
           watchId
         });
-        if (!isRecord7(response) || typeof response["path"] !== "string") {
+        if (!isRecord8(response) || typeof response["path"] !== "string") {
           throw new TypeError("fs/watch response path is invalid");
         }
       } catch {
@@ -11861,6 +12044,240 @@ var CodexGitMetadataWatchService = class {
   }
 };
 
+// packages/provider-codex/src/skill-market-provider.ts
+var OFFICIAL_MARKETPLACES = /* @__PURE__ */ new Set([
+  "openai-curated",
+  "openai-api-curated",
+  "openai-curated-remote"
+]);
+function nullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function mapOfficialPluginSummary(value, marketplaceName, marketplacePath) {
+  const plugin = expectRecord(value, "plugin summary");
+  const name = expectString(plugin["name"], "plugin summary name");
+  const view = plugin["interface"] === void 0 ? void 0 : expectRecord(plugin["interface"], "plugin summary interface");
+  const authPolicy = expectString(plugin["authPolicy"], "plugin summary authPolicy");
+  const installPolicy = expectString(plugin["installPolicy"], "plugin summary installPolicy");
+  const availability = plugin["availability"] ?? "AVAILABLE";
+  if (authPolicy !== "ON_INSTALL" && authPolicy !== "ON_USE") {
+    throw new CodexProtocolMappingError("plugin summary authPolicy is invalid");
+  }
+  if (installPolicy !== "NOT_AVAILABLE" && installPolicy !== "AVAILABLE" && installPolicy !== "INSTALLED_BY_DEFAULT") {
+    throw new CodexProtocolMappingError("plugin summary installPolicy is invalid");
+  }
+  if (availability !== "AVAILABLE" && availability !== "DISABLED_BY_ADMIN") {
+    throw new CodexProtocolMappingError("plugin summary availability is invalid");
+  }
+  return {
+    authPolicy,
+    availability,
+    description: typeof view?.["shortDescription"] === "string" ? view["shortDescription"] : "",
+    developerName: nullableString(view?.["developerName"]),
+    disabledReason: nullableString(plugin["disabledReason"]),
+    displayName: typeof view?.["displayName"] === "string" ? view["displayName"] : name,
+    enabled: typeof plugin["enabled"] === "boolean" ? plugin["enabled"] : false,
+    id: expectString(plugin["id"], "plugin summary id"),
+    installPolicy,
+    installed: typeof plugin["installed"] === "boolean" ? plugin["installed"] : false,
+    localVersion: nullableString(plugin["localVersion"]),
+    logoUrl: nullableString(view?.["logoUrl"]),
+    marketplaceName,
+    marketplacePath,
+    name,
+    pluginName: typeof plugin["remotePluginId"] === "string" ? plugin["remotePluginId"] : name,
+    version: nullableString(plugin["version"])
+  };
+}
+function mapOfficialPluginApps(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    const app = expectRecord(item, "plugin app");
+    return {
+      description: typeof app["description"] === "string" ? app["description"] : "",
+      id: expectString(app["id"], "plugin app id"),
+      installUrl: nullableString(app["installUrl"]),
+      name: expectString(app["name"], "plugin app name")
+    };
+  });
+}
+function remotePluginParams(marketplaceName, marketplacePath, pluginName) {
+  return {
+    marketplacePath,
+    pluginName,
+    remoteMarketplaceName: marketplacePath === null ? marketplaceName : null
+  };
+}
+async function listCodexOfficialPlugins(client, projects, forceRefetch) {
+  const response = expectRecord(
+    await client.request("plugin/list", {
+      cwds: projects.flatMap((project) => project.roots.map((root) => root.path)),
+      forceRefetch,
+      marketplaceKinds: null
+    }),
+    "plugin/list response"
+  );
+  if (!Array.isArray(response["marketplaces"])) {
+    throw new CodexProtocolMappingError("plugin/list marketplaces must be an array");
+  }
+  const data = [];
+  for (const value of response["marketplaces"]) {
+    const marketplace = expectRecord(value, "plugin marketplace");
+    const name = expectString(marketplace["name"], "plugin marketplace name");
+    if (!OFFICIAL_MARKETPLACES.has(name)) continue;
+    if (!Array.isArray(marketplace["plugins"])) {
+      throw new CodexProtocolMappingError("plugin marketplace plugins must be an array");
+    }
+    const path = nullableString(marketplace["path"]);
+    for (const plugin of marketplace["plugins"]) {
+      data.push(mapOfficialPluginSummary(plugin, name, path));
+    }
+  }
+  return { data };
+}
+async function getCodexOfficialPlugin(client, marketplaceName, marketplacePath, pluginName) {
+  const response = expectRecord(
+    await client.request(
+      "plugin/read",
+      remotePluginParams(marketplaceName, marketplacePath, pluginName)
+    ),
+    "plugin/read response"
+  );
+  const plugin = expectRecord(response["plugin"], "plugin/read plugin");
+  const summaryValue = expectRecord(plugin["summary"], "plugin/read summary");
+  const summary = mapOfficialPluginSummary(
+    summaryValue,
+    expectString(plugin["marketplaceName"], "plugin/read marketplaceName"),
+    nullableString(plugin["marketplacePath"])
+  );
+  const skills = Array.isArray(plugin["skills"]) ? plugin["skills"].map((value) => {
+    const skill = expectRecord(value, "plugin skill");
+    return {
+      description: typeof skill["shortDescription"] === "string" ? skill["shortDescription"] : typeof skill["description"] === "string" ? skill["description"] : "",
+      name: expectString(skill["name"], "plugin skill name")
+    };
+  }) : [];
+  const mcpServers = Array.isArray(plugin["mcpServers"]) ? plugin["mcpServers"].map((value) => expectString(value, "plugin MCP server")) : [];
+  const hooks = Array.isArray(plugin["hooks"]) ? plugin["hooks"].map(
+    (value) => expectString(expectRecord(value, "plugin hook")["key"], "plugin hook key")
+  ) : [];
+  const view = summaryValue["interface"] === void 0 ? void 0 : expectRecord(summaryValue["interface"], "plugin summary interface");
+  return {
+    ...summary,
+    apps: mapOfficialPluginApps(plugin["apps"]),
+    description: typeof plugin["description"] === "string" ? plugin["description"] : summary.description,
+    hooks,
+    mcpServers,
+    skills,
+    websiteUrl: nullableString(view?.["websiteUrl"])
+  };
+}
+async function installCodexOfficialPlugin(client, marketplaceName, marketplacePath, pluginName, installAttemptId) {
+  const response = expectRecord(
+    await client.request("plugin/install", {
+      installAttemptId,
+      ...remotePluginParams(marketplaceName, marketplacePath, pluginName)
+    }),
+    "plugin/install response"
+  );
+  const authPolicy = expectString(response["authPolicy"], "plugin/install authPolicy");
+  if (authPolicy !== "ON_INSTALL" && authPolicy !== "ON_USE") {
+    throw new CodexProtocolMappingError("plugin/install authPolicy is invalid");
+  }
+  return { appsNeedingAuth: mapOfficialPluginApps(response["appsNeedingAuth"]), authPolicy };
+}
+async function uninstallCodexOfficialPlugin(client, pluginId) {
+  await client.request("plugin/uninstall", { pluginId });
+  return {};
+}
+async function listCodexInstalledSkills(client, projects, forceReload) {
+  const roots = projects.flatMap(
+    (project) => project.roots.map((root) => ({ path: root.path, project }))
+  );
+  const rootsByPath = new Map(roots.map((root) => [root.path, root]));
+  const response = expectRecord(
+    await client.request("skills/list", {
+      cwds: roots.map((root) => root.path),
+      forceReload
+    }),
+    "skills/list response"
+  );
+  if (!Array.isArray(response["data"])) {
+    throw new CodexProtocolMappingError("skills/list data must be an array");
+  }
+  const seenPaths = /* @__PURE__ */ new Set();
+  const data = [];
+  for (const value of response["data"]) {
+    const entry = expectRecord(value, "skills/list entry");
+    const cwd = expectString(entry["cwd"], "skills/list cwd");
+    if (!Array.isArray(entry["skills"])) {
+      throw new CodexProtocolMappingError("skills/list skills must be an array");
+    }
+    for (const rawSkill of entry["skills"]) {
+      const skill = mapCodexSkill(rawSkill);
+      if (seenPaths.has(skill.path)) continue;
+      seenPaths.add(skill.path);
+      const root = skill.scope === "repo" ? rootsByPath.get(cwd) : void 0;
+      data.push({
+        ...skill,
+        ...root === void 0 ? {} : {
+          projectId: root.project.id,
+          projectName: root.project.name,
+          rootPath: root.path
+        },
+        source: "local"
+      });
+    }
+  }
+  return { data, nextCursor: null };
+}
+async function setCodexSkillEnabled(client, path, enabled) {
+  const response = expectRecord(
+    await client.request("skills/config/write", { enabled, name: null, path }),
+    "skills/config/write response"
+  );
+  return {
+    effectiveEnabled: expectBoolean(
+      response["effectiveEnabled"],
+      "skills/config/write effectiveEnabled"
+    )
+  };
+}
+async function listCodexConfiguredMcpServers(client) {
+  const response = expectRecord(
+    await client.request("config/read", { includeLayers: false }),
+    "config/read response"
+  );
+  const config = expectRecord(response["config"], "config/read config");
+  const rawServers = config["mcp_servers"];
+  if (rawServers === void 0) return { data: [] };
+  const servers = expectRecord(rawServers, "config/read mcp_servers");
+  return {
+    data: Object.entries(servers).map(([name, value]) => {
+      const server = expectRecord(value, `config/read mcp_servers.${name}`);
+      const configuredEnabled = server["enabled"];
+      if (configuredEnabled !== void 0 && typeof configuredEnabled !== "boolean") {
+        throw new CodexProtocolMappingError(`config/read mcp_servers.${name}.enabled is invalid`);
+      }
+      return { enabled: configuredEnabled ?? true, name };
+    }).toSorted((left, right) => left.name.localeCompare(right.name))
+  };
+}
+function quoteConfigKeySegment(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+async function setCodexMcpServerEnabled(client, name, enabled) {
+  await client.request("config/value/write", {
+    expectedVersion: null,
+    filePath: null,
+    keyPath: `mcp_servers.${quoteConfigKeySegment(name)}.enabled`,
+    mergeStrategy: "replace",
+    value: enabled
+  });
+  await client.request("config/mcpServer/reload");
+  return { enabled };
+}
+
 // packages/provider-codex/src/runtime-provider.ts
 function optionalNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -11981,8 +12398,8 @@ var CodexRuntimeProvider = class {
   cancelProviderLogin(loginId) {
     return this.#providerConnection.cancelLogin(loginId);
   }
-  configureCustomProvider(input) {
-    return this.#providerConnection.configureCustom(input);
+  configureCustomProvider(input, persistedModels) {
+    return this.#providerConnection.configureCustom(input, persistedModels);
   }
   forProject(project) {
     const primaryRoot = project.roots[0];
@@ -12058,6 +12475,30 @@ var CodexRuntimeProvider = class {
       subscribeRpc: false
     }).listModels();
   }
+  listConfiguredMcpServers() {
+    return listCodexConfiguredMcpServers(this.#client);
+  }
+  listInstalledSkills(projects, forceReload) {
+    return listCodexInstalledSkills(this.#client, projects, forceReload);
+  }
+  listOfficialPlugins(projects, forceRefetch) {
+    return listCodexOfficialPlugins(this.#client, projects, forceRefetch);
+  }
+  getOfficialPlugin(marketplaceName, marketplacePath, pluginName) {
+    return getCodexOfficialPlugin(this.#client, marketplaceName, marketplacePath, pluginName);
+  }
+  installOfficialPlugin(marketplaceName, marketplacePath, pluginName, installAttemptId) {
+    return installCodexOfficialPlugin(
+      this.#client,
+      marketplaceName,
+      marketplacePath,
+      pluginName,
+      installAttemptId
+    );
+  }
+  uninstallOfficialPlugin(pluginId) {
+    return uninstallCodexOfficialPlugin(this.#client, pluginId);
+  }
   logoutProvider() {
     return this.#providerConnection.logout();
   }
@@ -12107,6 +12548,12 @@ var CodexRuntimeProvider = class {
   startOfficialProviderLogin() {
     return this.#providerConnection.startOfficialLogin();
   }
+  setMcpServerEnabled(name, enabled) {
+    return setCodexMcpServerEnabled(this.#client, name, enabled);
+  }
+  setSkillEnabled(path, enabled) {
+    return setCodexSkillEnabled(this.#client, path, enabled);
+  }
   beginTaskRead(project, taskId) {
     return this.#owners.beginTaskRead(project, taskId);
   }
@@ -12136,7 +12583,7 @@ function createCodexRuntimeProvider(options) {
     ...options.fetch === void 0 ? {} : { fetch: options.fetch }
   });
 }
-var APP_SERVER_ARGUMENTS = ["app-server", "--listen", "stdio://"];
+var APP_SERVER_ARGUMENTS = ["app-server", "--enable", "plugins", "--listen", "stdio://"];
 var CodexAppServerExitedError = class extends RpcConnectionClosedError {
   exitCode;
   signal;
@@ -12340,6 +12787,13 @@ function mapUnixSeconds(value, context) {
   }
   return date.toISOString();
 }
+function validateNullableUnixSeconds(value, context) {
+  if (value === null) return;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new CodexProtocolMappingError(`${context} must be a Unix timestamp or null`);
+  }
+  mapUnixSeconds(value, context);
+}
 function mapProjectRoot(value, index) {
   const root = expectRecord(value, `Codex project root ${String(index)}`);
   const path = expectNonEmptyString2(root["path"], `Codex project root ${String(index)} path`);
@@ -12369,6 +12823,7 @@ function mapCodexProject(value) {
   }
   validateMetadata(nativeProject["metadata"]);
   mapUnixSeconds(nativeProject["updatedAt"], "Codex project updatedAt");
+  validateNullableUnixSeconds(nativeProject["recencyAt"], "Codex project recencyAt");
   return {
     position: expectSafeInteger(nativeProject["position"], "Codex project position"),
     project: {
@@ -13540,4 +13995,4 @@ function validateDownloadUrl(value) {
   }
 }
 
-export { CodexAppServerExitedError, CodexAppServerProcess, CodexAppServerShutdownError, CodexAppServerSpawnError, CodexProjectRepository, CodexProtocolMappingError, CodexProviderConnectionError, CodexProviderConnectionService, CodexRuntimeProvider, CodexWorkbenchPetProvider, JsonlRpcClient, RpcConnectionClosedError, RpcProtocolError, RpcResponseError, RpcTimeoutError, SUPPORTED_CODEX_VERSION, checkCodexVersion, createCodexRuntimeProvider, createCodexWorkbenchPetProvider, locateCodexBinary, require_pino, require_safe_stable_stringify, startCodexAppServer };
+export { CodexAppServerExitedError, CodexAppServerProcess, CodexAppServerShutdownError, CodexAppServerSpawnError, CodexProjectRepository, CodexProtocolMappingError, CodexProviderConnectionError, CodexProviderConnectionService, CodexRuntimeProvider, CodexWorkbenchPetProvider, JsonlRpcClient, RpcConnectionClosedError, RpcProtocolError, RpcResponseError, RpcTimeoutError, SUPPORTED_CODEX_VERSION, SUPPORTED_CODEX_VERSION_RANGE, checkCodexVersion, createCodexRuntimeProvider, createCodexWorkbenchPetProvider, locateCodexBinary, require_pino, require_safe_stable_stringify, startCodexAppServer };