pi-openai-codex-compat 0.0.16 → 0.0.17

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Unreleased
 
+## 0.0.17 - 2026-09-25
+
+### Fixed
+
+- Separate menu sections with blank rows, using compact spacing on short terminals.
+- Align setting names on the left and values in a stable column on the right.
+  Render the search placeholder in muted gray instead of ordinary input text.
+  Keep Save and Discard hints visible in narrow terminals.
+- Align settings with the Anthropic menu: Enter changes values, Ctrl+S saves and
+  applies drafts, and Escape discards unapplied drafts without changing active tools.
+- Save only changed overrides, preserve inheritance and external edits, and
+  report conflicting saves without overwriting them.
+- Block command-tool switches while persistent command sessions remain instead
+  of terminating them while browsing settings.
+
+### Added
+
+- Apply to session without changing configuration files. Reopening settings shows
+  active session values, including after reload, restart, or resume.
+  Ctrl+S can save session-only changes later.
+- Custom percentage editing, configuration-source and model-applicability labels,
+  inherited-value resets, and consistent keyboard, focus, and mouse support.
+
 ## 0.0.16 - 2026-09-23
 
 ### Added

package/README.md

@@ -14,7 +14,7 @@ OpenAI Codex compatibility for [Pi](https://github.com/earendil-works/pi-mono),
 - **Dedicated Codex tool UI**: renders command tools, `apply_patch`, `image_gen.imagegen`, and `web.run` on a shared configurable surface with compact summaries and `Ctrl+O` expansion.
 - **Hosted web-search fallback**: injects native `web_search` only when `web.run` is inactive, with cached, indexed, or live modes.
 - **Native request controls**: configures Responses API text verbosity, reasoning summaries, and standard/pro reasoning mode on supported models.
-- **Session-local settings pane**: `/codex-settings` changes every compatibility setting for the current session; `Enter` persists and closes, `Escape` discards unsaved changes and closes, and `Ctrl+S` persists without closing.
+- **Draft settings pane**: `/codex-settings` stages edits before applying them. Apply to session stores them with the session without changing configuration files. Ctrl+S saves and applies them. Escape discards only unapplied drafts.
 - **Session-aware footer**: shows the current Pi session ID on the first line and appends non-default Codex request modes to the model side of Pi's normal second line.
 
 Pi provides the Codex OAuth flow and model catalog. At session start, this package overrides the built-in `openai-codex` runtime under the same provider id so ordinary responses and remote compaction share one transport, parser, native-history store, and sticky WebSocket session.
@@ -173,7 +173,56 @@ A trusted project can override it at:
 <project>/.pi/openai-codex-compat.json
 ```
 
-Each session inherits the effective file-backed settings. Open `/codex-settings` to make immediate session-local changes. Press `Enter` to persist and close, `Escape` to discard unsaved changes and close, or `Ctrl+S` to persist without closing. The global file is the normal save target, while an existing trusted project override remains the target for that project. After `Ctrl+S`, later unsaved changes can still be discarded back to the values from that save.
+Each session inherits the effective file-backed settings. `/codex-settings`
+uses the same interaction contract as `/anthropic-settings`:
+
+- **Enter** changes the selected value or opens its editor. It never implicitly saves.
+- **Space** activates a result or inserts a space when search has focus.
+- **Tab / Shift+Tab** move between search, results, and action controls.
+- **F1** opens scrollable details, full errors, and the exact save target.
+- Edits remain drafts until explicitly applied or saved.
+- **Apply to session** applies drafts without writing configuration files and stays open.
+- **Ctrl+S** saves and applies changes without closing.
+- **Save and close** saves and applies changes, then closes on success.
+- **Escape** cancels a field editor or discards unapplied drafts and closes the main menu.
+  It does not undo settings already applied to the session.
+
+Search matches labels, configuration keys, and descriptions. The percentage
+editor supports presets and custom fractional values. **Use inherited value**
+removes an override. This differs from **Pi default**, which explicitly disables
+an inherited percentage trigger. Rows show configuration sources, environment
+locks, and model applicability. Pi's remapped selection and cancel keys are respected.
+
+The global file is the normal save target. An existing trusted project override
+is the target for that project. The target stays fixed while the menu is open.
+Saving changes only edited overrides, preserves unknown keys and inherited values,
+and preserves non-conflicting external edits. Conflicting edits are rejected for review.
+Opening or closing without changes does not create a configuration file.
+Reopening shows active session values, not freshly read file values. `*` marks
+an unapplied draft. `~` marks an active session override or a value that differs
+from the saved configuration. Details shows the saved value when it differs.
+Ctrl+S also persists changes previously applied only to the session.
+Session settings are stored as extension state entries in the Pi session,
+outside model context. They survive menu closure, tree navigation, extension
+reload, process restart, and switching away and back. Resuming the same session
+restores its settings before provider operations. A new session, fork, or clone
+has a separate identity and starts from configuration files.
+Pi's `--no-session` mode cannot be resumed after exit. Pi also defers creating a
+new session file until its first assistant message.
+Environment-controlled fields remain locked and take precedence over restored
+session preferences. Their values are not copied into session settings.
+
+Applying and saving wait for Pi to become idle. Collect pending output with `write_stdin` or
+stop running command sessions through `/ps` before applying or saving a command-tool switch.
+Browsing settings and discarding drafts
+never terminate those sessions. Escape cancels a pending operation without discarding
+the draft. Failures leave the menu open. If a save reaches disk but cannot
+be applied to the session, the menu reports that distinction and Ctrl+S retries
+application. Cooperating writers use a `.settings-lock` file. An interrupted
+writer can leave a lock that requires review; locks are not automatically
+deleted. External editors do not participate in that lock.
+Session overrides retain their original conflict checks across menu reopenings.
+Conflicting external edits remain protected after reload or restart.
 
 The effective settings are printed once when a TUI session starts. The footer shows the current Pi session ID alongside the working directory and optional session name. It shows `fast` and `pro` only when enabled, and shows text verbosity or reasoning summary only when they differ from their defaults.
 
@@ -225,7 +274,9 @@ Responses Lite supports exactly `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`,
 standard reasoning mode even when `pro` is configured. Both controls remain
 opt-in. GPT-6 Sol and Luna require Pi 0.87.1's model catalog.
 
-Invalid JSON setting values are ignored and invalid JSON does not prevent Pi from starting. The settings pane never writes on ordinary changes, refuses to overwrite invalid JSON when `Enter` or `Ctrl+S` attempts to save, and retains unknown keys when saving. Project configuration is read only when the project is trusted.
+Invalid JSON setting values are ignored and invalid JSON does not prevent Pi from
+starting. The settings pane reports malformed JSON instead of overwriting it.
+Project configuration is read only when the project is trusted.
 
 Every setting can also be overridden for one Pi process with an environment variable:
 
@@ -533,7 +584,9 @@ The tool generates new images with `gpt-image-2` or edits up to five local/recen
 ~/.pi/agent/generated_images/<session-id>/<call-id>.png
 ```
 
-The active Pi agent directory replaces `~/.pi/agent` when configured differently. Turning `imageGeneration` off removes the tool immediately for the current session; `Enter` or `Ctrl+S` in `/codex-settings` persists the value.
+The active Pi agent directory replaces `~/.pi/agent` when configured differently.
+Saving `imageGeneration: false` through `/codex-settings` removes the tool from
+the current session.
 
 The tool registers the server-reserved schema directly with a model-facing absolute-path annotation that names the supported image formats. OpenAI rejects additional schema keywords for image-count bounds and selector exclusivity, so the executor enforces those constraints before filesystem or network access. Local paths are lexically normalized before reading. A one-line system-prompt snippet and four high-signal guidelines cover normal model use. Local images are inspected with Pi's `read` tool, and generated image content is displayed and saved automatically without Codex Code Mode wrappers.
 

package/extensions/openai-codex-compat/command-tools.ts

@@ -59,6 +59,7 @@ export { formatBackgroundProcesses } from "./background-process-browser.ts";
 export type CommandToolsApi = Pick<ExtensionAPI, "on" | "registerCommand" | "registerTool">;
 
 export type CommandToolsController = {
+  hasPersistentSessions: () => boolean;
   terminateUnifiedExecSessions: () => void;
 };
 
@@ -352,6 +353,7 @@ export default function registerCommandTools(
   pi.on("session_shutdown", () => manager.terminateAll());
 
   return {
+    hasPersistentSessions: () => manager.activeSessionCount() > 0,
     terminateUnifiedExecSessions() {
       manager.terminateAll().catch((error: unknown) => {
         console.error("Could not terminate unified exec sessions.", error);

package/extensions/openai-codex-compat/config.ts

@@ -1,12 +1,10 @@
 import { isBoolean, isNumber, nodeErrorCode } from "./value-contracts.ts";
-import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { join } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import type { Static } from "typebox";
 import { Value } from "typebox/value";
-import { isObject, type JsonRecord } from "./codex-protocol.ts";
+import { isObject } from "./codex-protocol.ts";
 
 export const WEB_SEARCH_MODE_SCHEMA = {
   enum: ["disabled", "cached", "indexed", "live"],
@@ -465,55 +463,3 @@ export function withoutEnvironmentOverrides(
   }
   return result;
 }
-
-async function readWritableConfig(filePath: string): Promise<JsonRecord> {
-  try {
-    const value: unknown = JSON.parse(await readFile(filePath, "utf8"));
-    if (!isObject(value)) throw new Error("the root value must be a JSON object");
-    return value;
-  } catch (error) {
-    if (nodeErrorCode(error) === "ENOENT") return {};
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot update ${filePath}: ${detail}`, { cause: error });
-  }
-}
-
-/**
- * Merge known setting changes into the dedicated extension file. Unknown keys
- * are retained, and an invalid existing file is never overwritten.
- */
-export async function saveConfig(
-  cwd: string,
-  projectTrusted: boolean,
-  patch: ConfigLayer,
-): Promise<string> {
-  const filePath = writableConfigPath(cwd, projectTrusted);
-  const current = await readWritableConfig(filePath);
-  const next = { ...current, ...patch };
-  const directory = dirname(filePath);
-  const temporaryPath = join(
-    directory,
-    `.${basename(filePath)}.${process.pid}.${randomUUID()}.tmp`,
-  );
-
-  await mkdir(directory, { recursive: true });
-  const existingMode = await stat(filePath)
-    .then((metadata) => metadata.mode & 0o777)
-    .catch((error: unknown) => {
-      if (nodeErrorCode(error) === "ENOENT") return 0o600;
-      throw error;
-    });
-
-  try {
-    await writeFile(temporaryPath, `${JSON.stringify(next, null, 2)}\n`, {
-      encoding: "utf8",
-      flag: "wx",
-      mode: existingMode,
-    });
-    await rename(temporaryPath, filePath);
-  } finally {
-    await rm(temporaryPath, { force: true });
-  }
-
-  return filePath;
-}

package/extensions/openai-codex-compat/index.ts

@@ -12,7 +12,7 @@ import registerOutputLimitContinuation, {
 } from "./output-limit-continuation.ts";
 import registerRemoteCompaction, { remoteCompactionApi } from "./remote-compaction.ts";
 import registerCodexRequestOptions from "./request-options.ts";
-import registerCodexSettings from "./settings-pane.ts";
+import registerCodexSettings, { loadSessionConfig } from "./settings-pane.ts";
 import registerCodexThreadLineage, { codexThreadLineageApi } from "./codex-thread-lineage.ts";
 import registerCodexTools, { syncCodexTools } from "./tools.ts";
 
@@ -26,8 +26,11 @@ export {
 export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
   requirePiTranscriptRuntime(piAi, piCodingAgent);
   let activeConfig: CodexCompatConfig | undefined;
+  let sessionContext: Parameters<typeof loadSessionConfig>[0] | undefined;
   const resolveConfig = (ctx: ConfigContext): CodexCompatConfig => {
-    activeConfig ??= loadConfig(ctx.cwd, ctx.isProjectTrusted());
+    activeConfig ??= sessionContext
+      ? loadSessionConfig(sessionContext)
+      : loadConfig(ctx.cwd, ctx.isProjectTrusted());
     return activeConfig;
   };
   const resolveToolBackground = () => activeConfig?.toolBackground ?? DEFAULT_CONFIG.toolBackground;
@@ -37,7 +40,9 @@ export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
     activeConfig?.applyPatchDiagnostics ?? DEFAULT_CONFIG.applyPatchDiagnostics;
 
   pi.on("session_start", (event, ctx) => {
-    activeConfig = loadConfig(ctx.cwd, ctx.isProjectTrusted());
+    sessionContext = ctx;
+    activeConfig = undefined;
+    activeConfig = resolveConfig(ctx);
     installCodexFooter(ctx, resolveConfig);
     if (event.reason !== "reload" && ctx.mode === "tui") {
       ctx.ui.notify("pi-openai-codex-compat loaded · /codex-settings", "info");
@@ -60,6 +65,7 @@ export default function registerOpenAICodexCompat(pi: ExtensionAPI): void {
   registerCodexModelPolicy(modelPolicy, resolveConfig, commandTools);
   registerCodexSettings(pi, {
     getConfig: resolveConfig,
+    hasPersistentSessions: commandTools.hasPersistentSessions,
     onChange(config, ctx) {
       activeConfig = config;
       codexProvider.updateSessionConfig(ctx.sessionId, config);