From 3e79eb9af69f149411d71c65f978bf1e1d231b2e Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 13 May 2026 23:11:38 +0100 Subject: [PATCH] Remove Codex plugin marketplace config --- notes/fresh-workspace-handoff.md | 7 + state/ledgers.msgpack | Bin 106624 -> 106998 bytes state/map.yaml | 7 +- vendor/codex/codex-rs/app-server/README.md | 8 +- .../codex/codex-rs/config/src/config_toml.rs | 10 - vendor/codex/codex-rs/config/src/lib.rs | 6 - .../codex-rs/config/src/marketplace_edit.rs | 276 ------------------ .../codex-rs/config/src/thread_config.rs | 8 +- vendor/codex/codex-rs/config/src/types.rs | 41 --- vendor/codex/codex-rs/core/config.schema.json | 76 ----- 10 files changed, 17 insertions(+), 422 deletions(-) delete mode 100644 vendor/codex/codex-rs/config/src/marketplace_edit.rs diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index b3af036d..17ff945e 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -879,6 +879,13 @@ only. Do not resurrect plugin product routing or `app://` compatibility to make old tests feel less lonely; the blessed route is `mcp://` at the MCP edge and typed CultCache/CultNet documents inside Epiphany. +Plugin and marketplace config is gone as a parsed Codex contract. `ConfigToml` +no longer accepts `[plugins]` or `[marketplaces]`, `PluginConfig`, +`MarketplaceConfig`, and marketplace edit helpers were deleted, the generated +config schema no longer advertises those tables, and app-server README no +longer lists dead plugin or external-agent import routes. Old plugin config +files should fail loudly rather than receive fake compatibility incense. + That husk has now been cut from `codex-core`. The root core crate no longer exports `plugins`, no longer depends on `codex-core-plugins` or `codex-plugin`, and the core plugin manager / marketplace add-remove-sync modules and tests diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index c228c0bbec1d3baf75e3d94923368c20e3935f1e..17af655a969e40d0409a6c08b3209294d7d2e2af 100644 GIT binary patch delta 373 zcmYk2F-rqM5QSNh)Yeu5VwW?y6H{ClG=)e&LMlUw&F$pwaBp|n*$e3s@DEs-PVf&1 zfq>05;(xMs&m(Z){HHhm-nh=#G$D-yTnT7d07dQ~Lut?waEl;NqC?RIZcIRES3Y?% z8s3dZ?Nfx8T~0`TpNnHBTsyRi%Ydh-99UgCqz8}kp~sF%h6Qh-Ou3LbWuD|RO$d%J YB+}LP5cQ)$(7y@7>uLSVFb)S#e=FdIumAu6 delta 49 zcmex%n62R;+XQ8%1#TNvr!g{0Ht%8FzK4-<-8`{|Ek*`LX1WHZx`xIfMut|V##Y7_ FQ2@X254ivU diff --git a/state/map.yaml b/state/map.yaml index 873ad1c2..eb2bd02d 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -280,7 +280,7 @@ rejected_paths: reason: making Epiphany cleaner inside Codex still preserves the wrong organ; Codex must be starved down to OpenAI subscription auth/model transport, while Epiphany data and subsystem communication move to typed CultCache/CultNet. current_status: - summary: The Codex starvation pass has five typing receipts, forty-three processor/foundation cuts, a real physical extraction in `epiphany-codex-bridge`, a root `epiphany-state-model` crate for durable Epiphany state, a source-grounded Codex auth spine inventory, the native `epiphany-openai-adapter` document boundary, a buildable Codex auth/model wrapper in `epiphany-openai-codex-spine`, the first native runtime caller in `epiphany-openai-runtime`, native heartbeat launch planning/job opening in `epiphany-core`, native state-update contract/validation/application in `epiphany-core`, native exact retrieval path matching in `epiphany-core`, and the route-facing mutation/view/coordinator projection services in `epiphany-codex-bridge`. `codex-protocol` no longer defines the durable `Epiphany*` state structs; it re-exports the native model for legacy rollout/API compatibility while `epiphany-core` imports the native model directly. `epiphany-core` now has no direct vendored Codex dependency: pressure derivation accepts native `EpiphanyTokenUsageSnapshot`, Codex rollout replay moved to `codex-core::epiphany_rollout`, and exact retrieval search uses Epiphany-owned workspace walking/path scoring instead of `codex-file-search`. The bridge owns Codex-facing Epiphany adapters for scene, jobs, context/planning/graph query, retrieval/indexing projection, result projection, runtime-spine result adaptation, launch/prompt doctrine, mutation document mechanics, mutation service update/promote/role-accept/reorient-accept/role-launch/reorient-launch/job-launch/job-interrupt application, live-state projection, pressure/pre-compaction rendering, freshness/reorientation projection, CRRC/coordinator/role-board projection, watcher invalidation adaptation, full `thread/epiphany/view` response construction, freshness/context/graph-query response construction, role/reorient result response construction, distill/propose patch-response construction, coordinator status/view construction, and acceptance/evidence signal helpers. Vendored app-server no longer retains root Epiphany modules; `codex_message_processor.rs` still contains route dispatch, JSON-RPC response shaping, watcher registration/snapshotting calls, and notification emission, but its root no longer imports the evacuated Epiphany policy/protocol registry or owns the watcher invalidation manager. Codex product surfaces for apps, skills, plugins, marketplace, and external agent config import are now inert in the app-server compatibility path: list routes return empty lists, mutation/detail/import routes report disabled, `externalAgentConfig/detect` returns no import candidates, helper/import modules and stale implementation-shape tests were deleted, runtime feature enablement no longer supports `apps` or `plugins`, config writes no longer emit plugin-toggle analytics, plugin/skill cache invalidation on config writes is gone, plugin startup warmups and app-list refreshes were removed, and app-server no longer directly depends on `codex-plugin`, `codex-chatgpt`, or `codex-core-plugins`. `Config::to_mcp_config` now keeps user-declared MCP servers but no longer accepts `PluginsManager`, folds plugin MCP servers into the runtime, enables Codex apps, enables skill MCP dependency install, or advertises plugin capability summaries; `TurnContext::apps_enabled()` now returns false so model turns cannot awaken Codex Apps through ChatGPT auth or feature flags; session startup and per-turn context no longer load skills, turns receive an empty `SkillLoadOutcome`, internal `Op::ListSkills` returns empty compatibility entries without loading config layers, plugin roots, skill files, or conversion helpers, the Codex skill watcher has been collapsed to a no-op marker with no file watcher, skill-root registration, cache-clear task, or `SkillsUpdateAvailable` session listener, model turns no longer run skill mention collection, skill env-var prompts, skill MCP dependency installation, skill instruction injection, or implicit skill invocation analytics from shell tools, and the turn prompt/router path no longer loads plugin/app capability summaries, injects available-skill/available-plugin/plugin instruction fragments, parses plugin/app mentions, records app/plugin invocation telemetry, or filters MCP tools through Codex app connectors. The TUI app connector product path is also deleted: no `/apps` slash command, app-link view, connector AppEvent variants, app connector cache/popup/refresh loop, app mention insertion, `app://` mention codec support, stale app-popup tests, or TUI browser-opening shim remains. The `app/list` route and `app/list/updated` notification are gone from app-server protocol, generated schemas, app-server dispatch, test helpers, and docs; `AppInfo`/app-list metadata schema structs are deleted; the orphaned `codex-connectors` crate and `core::connectors` shim are deleted from the workspace; Codex app analytics no longer tracks `codex_app_mentioned` / `codex_app_used` facts, events, reducer arms, client APIs, or dedupe cache state; `[apps.*]`, `Feature::Apps`, `include_apps_instructions`, app config/read schemas, app managed requirements, app prompt tests, and app file-MCP tests are gone; and `Feature::Plugins`, `Feature::RemotePlugin`, `plugin://` structured mentions, plugin instruction tags, and stale plugin popup snapshots are gone too. Live MCP tool approval is now named `McpToolApproval`, not `AppToolApproval`, and remains under MCP server config; live structured tool mentions are MCP/skill-shaped only. `codex_message_processor.rs` is about 9,637 lines; root `message_processor.rs` is about 1,292 lines after the external-agent/config-product cuts; `epiphany_read_routes.rs` is about 579 lines after the full view and read-response extractions; `epiphany_mutation_routes.rs` is about 694 lines after route-load/notification helper cuts and product-surface starvation; `epiphany_state_helpers.rs` is down to a 19-line rollout-state loader; and `codex_thread.rs` is about 1,425 lines after state-update law moved native. `epiphany-openai-adapter` defines CultCache `DatabaseEntry` request/event/receipt/auth-status documents with no Codex app-server or generic JSON dependency. `epiphany-openai-codex-spine` owns all direct Codex auth/model-transport imports for the native OpenAI path: it exposes `default_codex_home` and `auth_manager`, projects `AuthManager` / `CodexAuth` into typed `EpiphanyOpenAiAdapterStatus`, maps typed `EpiphanyOpenAiModelRequest` into Codex API `ResponsesApiRequest`, resolves auth/provider through keeper Codex crates, opens HTTP Responses streams through `codex-api`, maps deltas / completion into typed stream events and receipts, and no longer directly depends on `codex-app-server-protocol` just to name auth mode. `epiphany-openai-runtime` no longer depends directly on `codex-login`; it writes OpenAI status/request/stream-event/receipt records plus runtime sessions/jobs/results/events into `epiphany-core::runtime_spine_cache`, can emit the assistant text artifact for legacy result consumers, is now the default executor for startup-only repo birth specialists, and now has `run-worker` to load a durable `EpiphanyRuntimeWorkerLaunchRequest`, call the typed OpenAI runtime through the spine, persist typed `EpiphanyRuntimeRoleWorkerResult` / `EpiphanyRuntimeReorientWorkerResult` documents, and complete the original heartbeat/specialist runtime job without Codex worker execution; `codex exec` survives only as explicit fallback in repo-birth startup. `epiphany-mvp-coordinator` now invokes `epiphany-openai-runtime run-worker` for launched runtime job ids and no longer creates a second coordinator-owned shadow runtime job/result as a compensator. `epiphany-core::plan_runtime_spine_heartbeat_launch` validates launch contracts/conflicts and projects durable job bindings/runtime links; `epiphany-core::open_runtime_spine_heartbeat_job` owns the initialize-runtime/ensure-session/create-job sequence and now persists `EpiphanyRuntimeWorkerLaunchRequest` CultCache records keyed by runtime job id, with indexed kind/contract fields plus MessagePack-encoded typed launch documents instead of discarding work intent after queue receipt creation; `roleResult` and `reorientResult` now prefer typed worker result documents and fall back only to generic job summaries for older receipts; `epiphany-core::EpiphanyStateUpdate`, `epiphany_state_update_validation_errors`, and `apply_epiphany_state_update` own state-update document shape and mutation law while `codex-core` calls them for compatibility. Vendored `CodexThread::epiphany_launch_job` is now mostly revision check, persistence validation, launch request handoff, and rollout/session writeback for the compatibility route. Vendored `codex-core` no longer has `epiphany_distillation`, `epiphany_promotion`, `epiphany_proposal`, or `epiphany_retrieval` husk modules; it re-exports native surfaces from `epiphany-core` directly, and now owns only the real Codex rollout adapter because it is a host seam. `epiphany-runtime-spine` advertises OpenAI adapter status/model-request/stream-event/receipt CultNet schemas and mutation contracts, so the native caller now has a real storage route instead of only JSON-RPC. MCP itself is correctly JSON at its protocol edge; the target is typed Epiphany intent/result/receipt wrappers around MCP, not replacing MCP JSON. The current OpenAI spine still pulls `codex-api` and a large transport dependency stack, so its next cut is dependency starvation after richer live callers move. + summary: The Codex starvation pass has five typing receipts, forty-four processor/foundation cuts, a real physical extraction in `epiphany-codex-bridge`, a root `epiphany-state-model` crate for durable Epiphany state, a source-grounded Codex auth spine inventory, the native `epiphany-openai-adapter` document boundary, a buildable Codex auth/model wrapper in `epiphany-openai-codex-spine`, the first native runtime caller in `epiphany-openai-runtime`, native heartbeat launch planning/job opening in `epiphany-core`, native state-update contract/validation/application in `epiphany-core`, native exact retrieval path matching in `epiphany-core`, and the route-facing mutation/view/coordinator projection services in `epiphany-codex-bridge`. `codex-protocol` no longer defines the durable `Epiphany*` state structs; it re-exports the native model for legacy rollout/API compatibility while `epiphany-core` imports the native model directly. `epiphany-core` now has no direct vendored Codex dependency: pressure derivation accepts native `EpiphanyTokenUsageSnapshot`, Codex rollout replay moved to `codex-core::epiphany_rollout`, and exact retrieval search uses Epiphany-owned workspace walking/path scoring instead of `codex-file-search`. The bridge owns Codex-facing Epiphany adapters for scene, jobs, context/planning/graph query, retrieval/indexing projection, result projection, runtime-spine result adaptation, launch/prompt doctrine, mutation document mechanics, mutation service update/promote/role-accept/reorient-accept/role-launch/reorient-launch/job-launch/job-interrupt application, live-state projection, pressure/pre-compaction rendering, freshness/reorientation projection, CRRC/coordinator/role-board projection, watcher invalidation adaptation, full `thread/epiphany/view` response construction, freshness/context/graph-query response construction, role/reorient result response construction, distill/propose patch-response construction, coordinator status/view construction, and acceptance/evidence signal helpers. Vendored app-server no longer retains root Epiphany modules; `codex_message_processor.rs` still contains route dispatch, JSON-RPC response shaping, watcher registration/snapshotting calls, and notification emission, but its root no longer imports the evacuated Epiphany policy/protocol registry or owns the watcher invalidation manager. Codex product surfaces for apps, skills, plugins, marketplace, and external agent config import are now inert in the app-server compatibility path: list routes return empty lists, mutation/detail/import routes report disabled, `externalAgentConfig/detect` returns no import candidates, helper/import modules and stale implementation-shape tests were deleted, runtime feature enablement no longer supports `apps` or `plugins`, config writes no longer emit plugin-toggle analytics, plugin/skill cache invalidation on config writes is gone, plugin startup warmups and app-list refreshes were removed, and app-server no longer directly depends on `codex-plugin`, `codex-chatgpt`, or `codex-core-plugins`. `Config::to_mcp_config` now keeps user-declared MCP servers but no longer accepts `PluginsManager`, folds plugin MCP servers into the runtime, enables Codex apps, enables skill MCP dependency install, or advertises plugin capability summaries; `TurnContext::apps_enabled()` now returns false so model turns cannot awaken Codex Apps through ChatGPT auth or feature flags; session startup and per-turn context no longer load skills, turns receive an empty `SkillLoadOutcome`, internal `Op::ListSkills` returns empty compatibility entries without loading config layers, plugin roots, skill files, or conversion helpers, the Codex skill watcher has been collapsed to a no-op marker with no file watcher, skill-root registration, cache-clear task, or `SkillsUpdateAvailable` session listener, model turns no longer run skill mention collection, skill env-var prompts, skill MCP dependency installation, skill instruction injection, or implicit skill invocation analytics from shell tools, and the turn prompt/router path no longer loads plugin/app capability summaries, injects available-skill/available-plugin/plugin instruction fragments, parses plugin/app mentions, records app/plugin invocation telemetry, or filters MCP tools through Codex app connectors. The TUI app connector product path is also deleted: no `/apps` slash command, app-link view, connector AppEvent variants, app connector cache/popup/refresh loop, app mention insertion, `app://` mention codec support, stale app-popup tests, or TUI browser-opening shim remains. The `app/list` route and `app/list/updated` notification are gone from app-server protocol, generated schemas, app-server dispatch, test helpers, and docs; `AppInfo`/app-list metadata schema structs are deleted; the orphaned `codex-connectors` crate and `core::connectors` shim are deleted from the workspace; Codex app analytics no longer tracks `codex_app_mentioned` / `codex_app_used` facts, events, reducer arms, client APIs, or dedupe cache state; `[apps.*]`, `Feature::Apps`, `include_apps_instructions`, app config/read schemas, app managed requirements, app prompt tests, and app file-MCP tests are gone; `Feature::Plugins`, `Feature::RemotePlugin`, `plugin://` structured mentions, plugin instruction tags, and stale plugin popup snapshots are gone too; and `[plugins]` / `[marketplaces]`, `PluginConfig`, `MarketplaceConfig`, marketplace edit helpers, stale plugin/external-agent README route claims, and generated schema entries are now removed from config. Live MCP tool approval is named `McpToolApproval`, not `AppToolApproval`, and remains under MCP server config; live structured tool mentions are MCP/skill-shaped only. `codex_message_processor.rs` is about 9,637 lines; root `message_processor.rs` is about 1,292 lines after the external-agent/config-product cuts; `epiphany_read_routes.rs` is about 579 lines after the full view and read-response extractions; `epiphany_mutation_routes.rs` is about 694 lines after route-load/notification helper cuts and product-surface starvation; `epiphany_state_helpers.rs` is down to a 19-line rollout-state loader; and `codex_thread.rs` is about 1,425 lines after state-update law moved native. `epiphany-openai-adapter` defines CultCache `DatabaseEntry` request/event/receipt/auth-status documents with no Codex app-server or generic JSON dependency. `epiphany-openai-codex-spine` owns all direct Codex auth/model-transport imports for the native OpenAI path: it exposes `default_codex_home` and `auth_manager`, projects `AuthManager` / `CodexAuth` into typed `EpiphanyOpenAiAdapterStatus`, maps typed `EpiphanyOpenAiModelRequest` into Codex API `ResponsesApiRequest`, resolves auth/provider through keeper Codex crates, opens HTTP Responses streams through `codex-api`, maps deltas / completion into typed stream events and receipts, and no longer directly depends on `codex-app-server-protocol` just to name auth mode. `epiphany-openai-runtime` no longer depends directly on `codex-login`; it writes OpenAI status/request/stream-event/receipt records plus runtime sessions/jobs/results/events into `epiphany-core::runtime_spine_cache`, can emit the assistant text artifact for legacy result consumers, is now the default executor for startup-only repo birth specialists, and now has `run-worker` to load a durable `EpiphanyRuntimeWorkerLaunchRequest`, call the typed OpenAI runtime through the spine, persist typed `EpiphanyRuntimeRoleWorkerResult` / `EpiphanyRuntimeReorientWorkerResult` documents, and complete the original heartbeat/specialist runtime job without Codex worker execution; `codex exec` survives only as explicit fallback in repo-birth startup. `epiphany-mvp-coordinator` now invokes `epiphany-openai-runtime run-worker` for launched runtime job ids and no longer creates a second coordinator-owned shadow runtime job/result as a compensator. `epiphany-core::plan_runtime_spine_heartbeat_launch` validates launch contracts/conflicts and projects durable job bindings/runtime links; `epiphany-core::open_runtime_spine_heartbeat_job` owns the initialize-runtime/ensure-session/create-job sequence and now persists `EpiphanyRuntimeWorkerLaunchRequest` CultCache records keyed by runtime job id, with indexed kind/contract fields plus MessagePack-encoded typed launch documents instead of discarding work intent after queue receipt creation; `roleResult` and `reorientResult` now prefer typed worker result documents and fall back only to generic job summaries for older receipts; `epiphany-core::EpiphanyStateUpdate`, `epiphany_state_update_validation_errors`, and `apply_epiphany_state_update` own state-update document shape and mutation law while `codex-core` calls them for compatibility. Vendored `CodexThread::epiphany_launch_job` is now mostly revision check, persistence validation, launch request handoff, and rollout/session writeback for the compatibility route. Vendored `codex-core` no longer has `epiphany_distillation`, `epiphany_promotion`, `epiphany_proposal`, or `epiphany_retrieval` husk modules; it re-exports native surfaces from `epiphany-core` directly, and now owns only the real Codex rollout adapter because it is a host seam. `epiphany-runtime-spine` advertises OpenAI adapter status/model-request/stream-event/receipt CultNet schemas and mutation contracts, so the native caller now has a real storage route instead of only JSON-RPC. MCP itself is correctly JSON at its protocol edge; the target is typed Epiphany intent/result/receipt wrappers around MCP, not replacing MCP JSON. The current OpenAI spine still pulls `codex-api` and a large transport dependency stack, so its next cut is dependency starvation after richer live callers move. latest_cut: > Codex Apps no longer have privileged MCP/runtime treatment in the keeper path. MCP exposure is now uniform: small tool sets are direct, large or @@ -370,6 +370,9 @@ current_status: `Feature::RemotePlugin`, `plugin://` structured mention support, plugin instruction tags, stale plugin popup snapshots, or app/plugin mention path classification in `codex-core-skills` remain. Live structured mentions are - MCP/skill-shaped only. MCP remains JSON-RPC at the edge; user-declared MCP + MCP/skill-shaped only. Config no longer accepts `[plugins]` or + `[marketplaces]`, and the old marketplace edit helper module plus + stale plugin/external-agent app-server README route claims were deleted. + MCP remains JSON-RPC at the edge; user-declared MCP servers are the only runtime MCP authority. next_action: Continue starving coordinator/runtime execution and operator surfaces off app-server JSON-RPC and out of `codex_message_processor.rs`; keep the vestigial Codex organ narrowed to subscription auth/model transport. diff --git a/vendor/codex/codex-rs/app-server/README.md b/vendor/codex/codex-rs/app-server/README.md index 0d34c6e5..81a8b4d6 100644 --- a/vendor/codex/codex-rs/app-server/README.md +++ b/vendor/codex/codex-rs/app-server/README.md @@ -197,18 +197,14 @@ Experimental Epiphany retrieval: - `fs/changed` — notification emitted when watched paths change, including the `watchId` and `changedPaths`. - `model/list` — list available models (set `includeHidden: true` to include entries with `hidden: true`), with reasoning effort options, `additionalSpeedTiers`, optional legacy `upgrade` model ids, optional `upgradeInfo` metadata (`model`, `upgradeCopy`, `modelLink`, `migrationMarkdown`), and optional `availabilityNux` metadata. - `experimentalFeature/list` — list feature flags with stage metadata (`beta`, `underDevelopment`, `stable`, etc.), enabled/default-enabled state, and cursor pagination. For non-beta flags, `displayName`/`description`/`announcement` are `null`. -- `experimentalFeature/enablement/set` — patch the in-memory process-wide runtime feature enablement for the currently supported feature keys (`apps`, `plugins`). For each feature, precedence is: cloud requirements > --enable > config.toml > experimentalFeature/enablement/set (new) > code default. +- `experimentalFeature/enablement/set` — patch the in-memory process-wide runtime feature enablement for supported feature keys. For each feature, precedence is: cloud requirements > --enable > config.toml > experimentalFeature/enablement/set (new) > code default. - `collaborationMode/list` — list available collaboration mode presets (experimental, no pagination). This response omits built-in developer instructions; clients should either pass `settings.developer_instructions: null` when setting a mode to use Codex's built-in instructions, or provide their own instructions explicitly. - `skills/list` — list skills for one or more `cwd` values (optional `forceReload`). -- `plugin/list` — list discovered plugin marketplaces and plugin state, including effective marketplace install/auth policy metadata, fail-open `marketplaceLoadErrors` entries for marketplace files that could not be parsed or loaded, and best-effort `featuredPluginIds` for the official curated marketplace. `interface.category` uses the marketplace category when present; otherwise it falls back to the plugin manifest category (**under development; do not call from production clients yet**). -- `plugin/read` — read one plugin by `marketplacePath` plus `pluginName`, returning marketplace info, a list-style `summary`, manifest descriptions/interface metadata, and bundled skills/apps/MCP server names. Returned plugin skills include their current `enabled` state after local config filtering. Plugin app summaries also include `needsAuth` when the server can determine connector accessibility (**under development; do not call from production clients yet**). - `skills/changed` — notification emitted when watched local skill files change. - `device/key/create` — create or load a controller-local device signing key for an account/client binding. This local-key API is available only over local transports such as stdio and in-process; remote transports reject it. Hardware-backed providers are the target protection class; an OS-protected non-extractable fallback is allowed only with `protectionPolicy: "allow_os_protected_nonextractable"` and returns the reported `protectionClass`. - `device/key/public` — return a device key's SPKI DER public key as base64 plus its `algorithm` and `protectionClass`. - `device/key/sign` — sign one of the accepted structured payload variants with a controller-local device key. The only accepted payload today is `remoteControlClientConnection`, which binds a server-issued `/client` websocket challenge to the enrolled controller device without signing the bearer token itself; this is intentionally not an arbitrary-byte signing API. - `skills/config/write` — write user-level skill config by name or absolute path. -- `plugin/install` — install a plugin from a discovered marketplace entry, rejecting marketplace entries marked unavailable for install, install MCPs if any, and return the effective plugin auth policy plus any apps that still need auth (**under development; do not call from production clients yet**). -- `plugin/uninstall` — uninstall a plugin by id by removing its cached files and clearing its user-level config entry (**under development; do not call from production clients yet**). - `mcpServer/oauth/login` — start an OAuth login for a configured MCP server; returns an `authorization_url` and later emits `mcpServer/oauthLogin/completed` once the browser flow finishes. - `tool/requestUserInput` — prompt the user with 1–3 short questions for a tool call and return their answers (experimental). - `config/mcpServer/reload` — reload MCP server config from disk and queue a refresh for loaded threads (applied on each thread's next active turn); returns `{}`. Use this after editing `config.toml` without restarting the server. @@ -218,8 +214,6 @@ Experimental Epiphany retrieval: - `windowsSandbox/setupStart` — start Windows sandbox setup for the selected mode (`elevated` or `unelevated`); accepts an optional absolute `cwd` to target setup for a specific workspace, returns `{ started: true }` immediately, and later emits `windowsSandbox/setupCompleted`. - `feedback/upload` — submit a feedback report (classification + optional reason/logs, conversation_id, and optional `extraLogFiles` attachments array); returns the tracking thread id. - `config/read` — fetch the effective config on disk after resolving config layering. -- `externalAgentConfig/detect` — detect migratable external-agent artifacts with `includeHome` and optional `cwds`; each detected item includes `cwd` (`null` for home), and plugin migration items may additionally include structured `details` grouping plugin ids under each detected marketplace name. -- `externalAgentConfig/import` — apply selected external-agent migration items by passing explicit `migrationItems` with `cwd` (`null` for home) and any plugin `details` returned by detect. When a request includes plugin imports, the server emits `externalAgentConfig/import/completed` after the full import finishes (immediately after the response when everything completed synchronously, or after background remote imports finish). - `config/value/write` — write a single config key/value to the user's config.toml on disk. - `config/batchWrite` — apply multiple config edits atomically to the user's config.toml on disk, with optional `reloadUserConfig: true` to hot-reload loaded threads. - `configRequirements/read` — fetch loaded requirements constraints from `requirements.toml` and/or MDM (or `null` if none are configured), including allow-lists (`allowedApprovalPolicies`, `allowedSandboxModes`, `allowedWebSearchModes`), pinned feature values (`featureRequirements`), `enforceResidency`, and `network` constraints such as canonical domain/socket permissions plus `managedAllowedDomainsOnly`. diff --git a/vendor/codex/codex-rs/config/src/config_toml.rs b/vendor/codex/codex-rs/config/src/config_toml.rs index 8a3b6d18..3eed4ccc 100644 --- a/vendor/codex/codex-rs/config/src/config_toml.rs +++ b/vendor/codex/codex-rs/config/src/config_toml.rs @@ -11,13 +11,11 @@ use crate::types::ApprovalsReviewer; use crate::types::AuthCredentialsStoreMode; use crate::types::FeedbackConfigToml; use crate::types::History; -use crate::types::MarketplaceConfig; use crate::types::McpServerConfig; use crate::types::MemoriesToml; use crate::types::Notice; use crate::types::OAuthCredentialsStoreMode; use crate::types::OtelConfigToml; -use crate::types::PluginConfig; use crate::types::SandboxWorkspaceWrite; use crate::types::ShellEnvironmentPolicyToml; use crate::types::SkillsConfig; @@ -326,14 +324,6 @@ pub struct ConfigToml { /// User-level skill config entries keyed by SKILL.md path. pub skills: Option, - /// User-level plugin config entries keyed by plugin name. - #[serde(default)] - pub plugins: HashMap, - - /// User-level marketplace entries keyed by marketplace name. - #[serde(default)] - pub marketplaces: HashMap, - /// Centralized feature flags (new). Prefer this over individual toggles. #[serde(default)] // Injects known feature keys into the schema and forbids unknown keys. diff --git a/vendor/codex/codex-rs/config/src/lib.rs b/vendor/codex/codex-rs/config/src/lib.rs index 0ac6ad32..72d3393e 100644 --- a/vendor/codex/codex-rs/config/src/lib.rs +++ b/vendor/codex/codex-rs/config/src/lib.rs @@ -6,7 +6,6 @@ mod diagnostics; mod fingerprint; mod host_name; mod key_aliases; -mod marketplace_edit; mod mcp_edit; mod mcp_types; mod merge; @@ -64,11 +63,6 @@ pub use diagnostics::format_config_error_with_source; pub use diagnostics::io_error_from_config_error; pub use fingerprint::version_for_toml; pub use host_name::host_name; -pub use marketplace_edit::MarketplaceConfigUpdate; -pub use marketplace_edit::RemoveMarketplaceConfigOutcome; -pub use marketplace_edit::record_user_marketplace; -pub use marketplace_edit::remove_user_marketplace; -pub use marketplace_edit::remove_user_marketplace_config; pub use mcp_edit::ConfigEditsBuilder; pub use mcp_edit::load_global_mcp_servers; pub use mcp_types::McpServerConfig; diff --git a/vendor/codex/codex-rs/config/src/marketplace_edit.rs b/vendor/codex/codex-rs/config/src/marketplace_edit.rs deleted file mode 100644 index 2aad2486..00000000 --- a/vendor/codex/codex-rs/config/src/marketplace_edit.rs +++ /dev/null @@ -1,276 +0,0 @@ -use std::fs; -use std::io::ErrorKind; -use std::path::Path; - -use toml_edit::DocumentMut; -use toml_edit::Item as TomlItem; -use toml_edit::Table as TomlTable; -use toml_edit::Value as TomlValue; -use toml_edit::value; - -use crate::CONFIG_TOML_FILE; - -pub struct MarketplaceConfigUpdate<'a> { - pub last_updated: &'a str, - pub last_revision: Option<&'a str>, - pub source_type: &'a str, - pub source: &'a str, - pub ref_name: Option<&'a str>, - pub sparse_paths: &'a [String], -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum RemoveMarketplaceConfigOutcome { - Removed, - NotFound, - NameCaseMismatch { configured_name: String }, -} - -pub fn record_user_marketplace( - codex_home: &Path, - marketplace_name: &str, - update: &MarketplaceConfigUpdate<'_>, -) -> std::io::Result<()> { - let config_path = codex_home.join(CONFIG_TOML_FILE); - let mut doc = read_or_create_document(&config_path)?; - upsert_marketplace(&mut doc, marketplace_name, update); - fs::create_dir_all(codex_home)?; - fs::write(config_path, doc.to_string()) -} - -pub fn remove_user_marketplace(codex_home: &Path, marketplace_name: &str) -> std::io::Result { - let outcome = remove_user_marketplace_config(codex_home, marketplace_name)?; - Ok(outcome == RemoveMarketplaceConfigOutcome::Removed) -} - -pub fn remove_user_marketplace_config( - codex_home: &Path, - marketplace_name: &str, -) -> std::io::Result { - let config_path = codex_home.join(CONFIG_TOML_FILE); - let mut doc = match fs::read_to_string(&config_path) { - Ok(raw) => raw - .parse::() - .map_err(|err| std::io::Error::new(ErrorKind::InvalidData, err))?, - Err(err) if err.kind() == ErrorKind::NotFound => { - return Ok(RemoveMarketplaceConfigOutcome::NotFound); - } - Err(err) => return Err(err), - }; - - let outcome = remove_marketplace(&mut doc, marketplace_name); - if outcome != RemoveMarketplaceConfigOutcome::Removed { - return Ok(outcome); - } - - fs::create_dir_all(codex_home)?; - fs::write(config_path, doc.to_string())?; - Ok(RemoveMarketplaceConfigOutcome::Removed) -} - -fn read_or_create_document(config_path: &Path) -> std::io::Result { - match fs::read_to_string(config_path) { - Ok(raw) => raw - .parse::() - .map_err(|err| std::io::Error::new(ErrorKind::InvalidData, err)), - Err(err) if err.kind() == ErrorKind::NotFound => Ok(DocumentMut::new()), - Err(err) => Err(err), - } -} - -fn upsert_marketplace( - doc: &mut DocumentMut, - marketplace_name: &str, - update: &MarketplaceConfigUpdate<'_>, -) { - let root = doc.as_table_mut(); - if !root.contains_key("marketplaces") { - root.insert("marketplaces", TomlItem::Table(new_implicit_table())); - } - - let Some(marketplaces_item) = root.get_mut("marketplaces") else { - return; - }; - if !marketplaces_item.is_table() { - *marketplaces_item = TomlItem::Table(new_implicit_table()); - } - - let Some(marketplaces) = marketplaces_item.as_table_mut() else { - return; - }; - let mut entry = TomlTable::new(); - entry.set_implicit(false); - entry["last_updated"] = value(update.last_updated.to_string()); - if let Some(last_revision) = update.last_revision { - entry["last_revision"] = value(last_revision.to_string()); - } - entry["source_type"] = value(update.source_type.to_string()); - entry["source"] = value(update.source.to_string()); - if let Some(ref_name) = update.ref_name { - entry["ref"] = value(ref_name.to_string()); - } - if !update.sparse_paths.is_empty() { - entry["sparse_paths"] = TomlItem::Value(TomlValue::Array( - update.sparse_paths.iter().map(String::as_str).collect(), - )); - } - marketplaces.insert(marketplace_name, TomlItem::Table(entry)); -} - -fn remove_marketplace( - doc: &mut DocumentMut, - marketplace_name: &str, -) -> RemoveMarketplaceConfigOutcome { - let root = doc.as_table_mut(); - let Some(marketplaces_item) = root.get_mut("marketplaces") else { - return RemoveMarketplaceConfigOutcome::NotFound; - }; - - let mut remove_marketplaces = false; - let outcome = match marketplaces_item { - TomlItem::Table(marketplaces) => { - let outcome = if marketplaces.remove(marketplace_name).is_some() { - RemoveMarketplaceConfigOutcome::Removed - } else if let Some(configured_name) = - case_mismatched_key(marketplaces.iter().map(|(key, _)| key), marketplace_name) - { - RemoveMarketplaceConfigOutcome::NameCaseMismatch { configured_name } - } else { - RemoveMarketplaceConfigOutcome::NotFound - }; - remove_marketplaces = marketplaces.is_empty(); - outcome - } - TomlItem::Value(value) => { - let Some(marketplaces) = value.as_inline_table_mut() else { - return RemoveMarketplaceConfigOutcome::NotFound; - }; - let outcome = if marketplaces.remove(marketplace_name).is_some() { - RemoveMarketplaceConfigOutcome::Removed - } else if let Some(configured_name) = - case_mismatched_key(marketplaces.iter().map(|(key, _)| key), marketplace_name) - { - RemoveMarketplaceConfigOutcome::NameCaseMismatch { configured_name } - } else { - RemoveMarketplaceConfigOutcome::NotFound - }; - remove_marketplaces = marketplaces.is_empty(); - outcome - } - _ => RemoveMarketplaceConfigOutcome::NotFound, - }; - - if outcome == RemoveMarketplaceConfigOutcome::Removed && remove_marketplaces { - root.remove("marketplaces"); - } - outcome -} - -fn case_mismatched_key<'a>( - mut keys: impl Iterator, - requested_name: &str, -) -> Option { - keys.find(|key| *key != requested_name && key.eq_ignore_ascii_case(requested_name)) - .map(str::to_string) -} - -fn new_implicit_table() -> TomlTable { - let mut table = TomlTable::new(); - table.set_implicit(true); - table -} - -#[cfg(test)] -mod tests { - use super::*; - use pretty_assertions::assert_eq; - use tempfile::TempDir; - - #[test] - fn remove_user_marketplace_removes_requested_entry() { - let codex_home = TempDir::new().unwrap(); - let update = MarketplaceConfigUpdate { - last_updated: "2026-04-13T00:00:00Z", - last_revision: None, - source_type: "git", - source: "https://github.com/owner/repo.git", - ref_name: Some("main"), - sparse_paths: &[], - }; - record_user_marketplace(codex_home.path(), "debug", &update).unwrap(); - record_user_marketplace(codex_home.path(), "other", &update).unwrap(); - - let removed = remove_user_marketplace(codex_home.path(), "debug").unwrap(); - - assert!(removed); - let config: toml::Value = - toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap()) - .unwrap(); - let marketplaces = config - .get("marketplaces") - .and_then(toml::Value::as_table) - .unwrap(); - assert_eq!(marketplaces.len(), 1); - assert!(marketplaces.contains_key("other")); - } - - #[test] - fn remove_user_marketplace_returns_false_when_missing() { - let codex_home = TempDir::new().unwrap(); - - let removed = remove_user_marketplace(codex_home.path(), "debug").unwrap(); - - assert!(!removed); - } - - #[test] - fn remove_user_marketplace_config_reports_case_mismatch() { - let codex_home = TempDir::new().unwrap(); - let update = MarketplaceConfigUpdate { - last_updated: "2026-04-13T00:00:00Z", - last_revision: None, - source_type: "git", - source: "https://github.com/owner/repo.git", - ref_name: Some("main"), - sparse_paths: &[], - }; - record_user_marketplace(codex_home.path(), "debug", &update).unwrap(); - - let outcome = remove_user_marketplace_config(codex_home.path(), "Debug").unwrap(); - - assert_eq!( - outcome, - RemoveMarketplaceConfigOutcome::NameCaseMismatch { - configured_name: "debug".to_string() - } - ); - } - - #[test] - fn remove_user_marketplace_config_removes_inline_table_entry() { - let codex_home = TempDir::new().unwrap(); - fs::write( - codex_home.path().join(CONFIG_TOML_FILE), - r#" -marketplaces = { - debug = { source_type = "git", source = "https://github.com/owner/repo.git" }, - other = { source_type = "local", source = "/tmp/marketplace" }, -} -"#, - ) - .unwrap(); - - let outcome = remove_user_marketplace_config(codex_home.path(), "debug").unwrap(); - - assert_eq!(outcome, RemoveMarketplaceConfigOutcome::Removed); - let config: toml::Value = - toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap()) - .unwrap(); - let marketplaces = config - .get("marketplaces") - .and_then(toml::Value::as_table) - .unwrap(); - assert_eq!(marketplaces.len(), 1); - assert!(marketplaces.contains_key("other")); - } -} diff --git a/vendor/codex/codex-rs/config/src/thread_config.rs b/vendor/codex/codex-rs/config/src/thread_config.rs index e1e59870..a2b63cf0 100644 --- a/vendor/codex/codex-rs/config/src/thread_config.rs +++ b/vendor/codex/codex-rs/config/src/thread_config.rs @@ -219,7 +219,7 @@ mod tests { ThreadConfigSource::Session(SessionThreadConfig { model_provider: Some("local".to_string()), model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), - features: BTreeMap::from([("plugins".to_string(), false)]), + features: BTreeMap::from([("multi_agent_v2".to_string(), false)]), }), ThreadConfigSource::User(UserThreadConfig::default()), ]); @@ -238,7 +238,7 @@ mod tests { ThreadConfigSource::Session(SessionThreadConfig { model_provider: Some("local".to_string()), model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), - features: BTreeMap::from([("plugins".to_string(), false)]), + features: BTreeMap::from([("multi_agent_v2".to_string(), false)]), }), ThreadConfigSource::User(UserThreadConfig::default()), ] @@ -252,7 +252,7 @@ mod tests { ThreadConfigSource::Session(SessionThreadConfig { model_provider: Some("local".to_string()), model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), - features: BTreeMap::from([("plugins".to_string(), false)]), + features: BTreeMap::from([("multi_agent_v2".to_string(), false)]), }), ]); let layers = loader @@ -283,7 +283,7 @@ mod tests { supports_websockets = true [features] - plugins = false + multi_agent_v2 = false } .into() )] diff --git a/vendor/codex/codex-rs/config/src/types.rs b/vendor/codex/codex-rs/config/src/types.rs index 8679e3e8..2d95e0ce 100644 --- a/vendor/codex/codex-rs/config/src/types.rs +++ b/vendor/codex/codex-rs/config/src/types.rs @@ -37,10 +37,6 @@ const MAX_MEMORIES_MAX_RAW_MEMORIES_FOR_CONSOLIDATION: usize = 4096; const MIN_MEMORIES_MAX_ROLLOUTS_PER_STARTUP: usize = 1; const MAX_MEMORIES_MAX_ROLLOUTS_PER_STARTUP: usize = 128; -const fn default_enabled() -> bool { - true -} - /// Determine where Codex should store CLI auth credentials. #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] #[serde(rename_all = "lowercase")] @@ -525,43 +521,6 @@ pub use crate::skills_config::BundledSkillsConfig; pub use crate::skills_config::SkillConfig; pub use crate::skills_config::SkillsConfig; -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema)] -#[schemars(deny_unknown_fields)] -pub struct PluginConfig { - #[serde(default = "default_enabled")] - pub enabled: bool, -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default, JsonSchema)] -#[schemars(deny_unknown_fields)] -pub struct MarketplaceConfig { - /// Last time Codex successfully added or refreshed this marketplace. - #[serde(default)] - pub last_updated: Option, - /// Git revision Codex last successfully activated for this marketplace. - #[serde(default)] - pub last_revision: Option, - /// Source kind used to install this marketplace. - #[serde(default)] - pub source_type: Option, - /// Source location used when the marketplace was added. - #[serde(default)] - pub source: Option, - /// Git ref to check out when `source_type` is `git`. - #[serde(default, rename = "ref")] - pub ref_name: Option, - /// Sparse checkout paths used when `source_type` is `git`. - #[serde(default)] - pub sparse_paths: Option>, -} - -#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema)] -#[serde(rename_all = "snake_case")] -pub enum MarketplaceSourceType { - Git, - Local, -} - #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct SandboxWorkspaceWrite { diff --git a/vendor/codex/codex-rs/core/config.schema.json b/vendor/codex/codex-rs/core/config.schema.json index 976af9d0..cb6440ec 100644 --- a/vendor/codex/codex-rs/core/config.schema.json +++ b/vendor/codex/codex-rs/core/config.schema.json @@ -710,56 +710,6 @@ } ] }, - "MarketplaceConfig": { - "additionalProperties": false, - "properties": { - "last_revision": { - "default": null, - "description": "Git revision Codex last successfully activated for this marketplace.", - "type": "string" - }, - "last_updated": { - "default": null, - "description": "Last time Codex successfully added or refreshed this marketplace.", - "type": "string" - }, - "ref": { - "default": null, - "description": "Git ref to check out when `source_type` is `git`.", - "type": "string" - }, - "source": { - "default": null, - "description": "Source location used when the marketplace was added.", - "type": "string" - }, - "source_type": { - "allOf": [ - { - "$ref": "#/definitions/MarketplaceSourceType" - } - ], - "default": null, - "description": "Source kind used to install this marketplace." - }, - "sparse_paths": { - "default": null, - "description": "Sparse checkout paths used when `source_type` is `git`.", - "items": { - "type": "string" - }, - "type": "array" - } - }, - "type": "object" - }, - "MarketplaceSourceType": { - "enum": [ - "git", - "local" - ], - "type": "string" - }, "McpServerEnvVar": { "anyOf": [ { @@ -1419,16 +1369,6 @@ ], "type": "string" }, - "PluginConfig": { - "additionalProperties": false, - "properties": { - "enabled": { - "default": true, - "type": "boolean" - } - }, - "type": "object" - }, "ProjectConfig": { "additionalProperties": false, "properties": { @@ -2476,14 +2416,6 @@ ], "description": "Directory where Codex writes log files, for example `codex-tui.log`. Defaults to `$CODEX_HOME/log`." }, - "marketplaces": { - "additionalProperties": { - "$ref": "#/definitions/MarketplaceConfig" - }, - "default": {}, - "description": "User-level marketplace entries keyed by marketplace name.", - "type": "object" - }, "mcp_oauth_callback_port": { "description": "Optional fixed port for the local HTTP callback server used during MCP OAuth login. When unset, Codex will bind to an ephemeral port chosen by the OS.", "format": "uint16", @@ -2631,14 +2563,6 @@ "plan_mode_reasoning_effort": { "$ref": "#/definitions/ReasoningEffort" }, - "plugins": { - "additionalProperties": { - "$ref": "#/definitions/PluginConfig" - }, - "default": {}, - "description": "User-level plugin config entries keyed by plugin name.", - "type": "object" - }, "profile": { "description": "Profile to use from the `profiles` map.", "type": "string"