codex-copilot-dx 0.9.20 → 0.9.21

package/README.md

@@ -62,6 +62,9 @@ The dashboard does not poll in the background; refresh when needed.
   break continuations. Generated images and Codex transcripts are not deleted.
 - Optional image setup/maintenance never blocks the primary service. Disabled
   users get no CCDX image skill or MCP installation.
+- CCDX adds experimental local history compression only when installed App
+  runtimes support it and report it off. Existing choices are preserved; an
+  already-enabled default, unavailable runtime or failed check is skipped.
 - Image API redirects must stay on the same HTTPS origin. Returned images must
   use public HTTPS URLs; well-known NAT64 mappings follow IPv4 address rules.
 - Keep the adapter on loopback. LAN mode is only for trusted networks; do not

package/bin/cli.mjs

@@ -24,6 +24,7 @@ import { createProfileModelRuntime } from "../src/profile-model-runtime.mjs";
 import { createCodexModelCatalog } from "../src/codex-model-catalog.mjs";
 import { readImageProviderConfig } from "../src/image-provider-config.mjs";
 import { setResponseHistoryMaxBytes } from "../src/response-history.mjs";
+import { ensureCodexThreadCompression } from "../src/codex-thread-compression.mjs";
 
 const LOCAL_VERSION = localPackageVersion();
 const CLI_NAME = cliCommandName();
@@ -259,7 +260,7 @@ async function reuseRunningAdapterIfAvailable() {
   if (!running.ok) return false;
 
   console.log(status("ok", `Using existing adapter at ${running.baseUrl}`));
-  await configureCodexClient();
+  const { compressionSetup } = await configureCodexClient();
 
   await openCodex();
   console.log(`
@@ -269,6 +270,7 @@ async function reuseRunningAdapterIfAvailable() {
 
   Tip: Run ${CLI_NAME} help to view more features and commands.
 `);
+  await compressionSetup;
   return true;
 }
 
@@ -283,6 +285,7 @@ async function configureCodexClient() {
       console.warn(status("warn", `Image guidance could not be updated: ${error.message}`));
     }
   }
+  return { compressionSetup: runInBackground(ensureCodexThreadCompression) };
 }
 
 if (CLI.command === "doctor") {
@@ -359,7 +362,7 @@ try {
   });
 
   // Point Codex App at the adapter.
-  await configureCodexClient();
+  const { compressionSetup } = await configureCodexClient();
 
   // Launch Codex when available.
   await openCodex();
@@ -404,6 +407,7 @@ try {
   };
   process.once("SIGINT", () => { void shutdown("SIGINT"); });
   process.once("SIGTERM", () => { void shutdown("SIGTERM"); });
+  await compressionSetup;
 } catch (e) {
   console.error(status("err", e.message));
   await closeHttpServer(activeServer, { timeoutMs: RUNTIME.shutdownTimeoutMs }).catch(() => {});

package/docs/README.md

@@ -16,6 +16,7 @@ test counts, timings, live-provider observations, and limitations remain
 historical facts rather than current guarantees.
 
 - [0.9.19: GitHub startup checks and stable-release updates](RELEASE_0.9.19.md)
+- [0.9.21: compatibility-gated local history compression](RELEASE_0.9.21.md)
 - [0.9.20: timing evidence, real-client checks and bounded analytics reuse](RELEASE_0.9.20.md)
 - [0.9.13: model-bound Auto-review reasoning selection](RELEASE_0.9.13.md)
 - [0.9.12: GPT-6.1 Sol / low Auto-review default](RELEASE_0.9.12.md)

package/docs/REFERENCE.md

@@ -65,6 +65,10 @@ The `OPENAI_API_KEY=dummy` value used in the Codex shell environment is only a c
 
 On startup, CCDX also adds `context_management = true` under `[features]` when the key is missing, creating the section if needed. Existing values, including `false`, are preserved. Existing inline or dotted `features` declarations and nested context-management settings are left intact to avoid conflicting TOML definitions. This opts unconfigured users into Codex context management; support and behavior depend on the installed Codex version. A configuration that already matches is not rewritten.
 
+Startup and adapter reuse also attempt an optional `local_thread_store_compression = true` default under `[features]`. CCDX probes installed macOS App runtimes with `features list`, using an empty temporary Codex directory, no inherited credentials/provider overrides, a 1.5-second timeout per runtime and a 128 KiB output limit. All discovered App readers must advertise a supported, disabled feature; missing/removed/unknown/default-on features or failed probes skip setup. Existing user settings (including `false`, inline/dotted forms and legacy profile overrides) are preserved without probing. Alternative feature-table declarations that cannot be safely extended are left intact. The shared config is reread after probing, and only this key can change. Temporary probe directories are removed; no user transcript is read or compressed by CCDX itself, and no upstream or npm lookup is added. Ready and core requests do not wait for this optional task; its failures never abort the main service. On a first launch, the App may read the config before this background task finishes; the setting is available on its next config load/restart.
+
+This remains an experimental Codex storage feature. Current Codex compresses cold local transcript files, including shared histories, with Zstandard; every external reader of that Codex directory must also support the format. It does not reduce model context, request-body limits or CCDX's in-memory history cache, and CCDX does not promise faster inference. Existing third-party transcript readers are not detected. `ccdx doctor config` remains a config-only preview of essential startup settings; it does not spawn runtimes or predict this optional compatibility-gated default.
+
 If a compatible adapter is already running, a later launch reuses it and checks the local Codex configuration. Reuse requires the same package version, protocol version, and required capabilities. After updating the package, stop the old adapter before starting the new version. Installing or updating the package alone does not restart the adapter or update Codex configuration.
 
 ### Codex configuration writes
@@ -78,6 +82,7 @@ Normal startup and reuse of an existing adapter check `~/.codex/config.toml` onc
 | `model_auto_compact_token_limit` | Add `900000` only when missing | `900000` |
 | `[shell_environment_policy.set]` OpenAI URL/key | Update `OPENAI_BASE_URL` and set `OPENAI_API_KEY="dummy"` when this section is recognized; leave an absent section absent | Create the section and set both keys; set `shell_environment_policy.inherit="core"` |
 | `[features]` `context_management` | Add `true` when missing; preserve explicit values and alternative declarations as described above | `true` |
+| `[features]` `local_thread_store_compression` | Optional compatibility-gated default; preserve existing values, skip already-on/unsupported/unavailable runtimes | `true` only after a successful probe |
 | `[mcp_servers.ccdx_image]` | Added in a marked CCDX-owned block only after `ccdx enable-image`; removed by `ccdx disable-image` | Absent by default |
 
 The two token limits are fixed defaults, not detected model capabilities. Existing custom values are retained. Writes target the listed keys with format-preserving edits and atomic replacement; this is not a general TOML formatter. Quoted keys, quoted table headers, and explicit dotted shell-environment declarations are recognized; inline shell-environment tables are left intact. Startup and image configuration commands validate UTF-8/TOML and verify that unrelated settings retain their values before writing. An unsafe edit leaves the original file unchanged. Use `ccdx doctor config` to inspect parsed values and preview what this writer would do with the current file. No actual change means no file rewrite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.9.20",
+  "version": "0.9.21",
   "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/codex-thread-compression.mjs

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { CODEX_APP_BINARY_PATHS } from "./codex-model-catalog.mjs";
+import { parseCodexToml, codexTomlStatements, validateManagedConfigEdit } from "./config-toml.mjs";
+import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { status } from "./status.mjs";
+
+const FEATURE = "local_thread_store_compression";
+const FEATURE_PATH = ["features", FEATURE];
+
+function configured(config) {
+  if (Object.hasOwn(config, FEATURE) || Object.hasOwn(config.features || {}, FEATURE)) return true;
+  return Object.values(config.profiles || {}).some(profile => Object.hasOwn(profile?.features || {}, FEATURE));
+}
+
+export function computeThreadCompressionDefault(content) {
+  const config = parseCodexToml(content);
+  if (configured(config)) return { content, changed: false };
+  const statements = codexTomlStatements(content);
+  // Only append to an explicit features table or create an absent one. Preserve
+  // inline/dotted/nested declarations rather than risking a conflicting table.
+  const table = statements.find(item => item.kind === "table"
+    && item.keys.length === 1 && item.keys[0] === "features");
+  if (!table && Object.hasOwn(config, "features")) return { content, changed: false };
+  const lines = content.split("\n");
+  if (table) {
+    const end = statements.find(item => item.kind === "table" && item.start > table.start)?.line ?? lines.length;
+    lines.splice(end, 0, `${FEATURE} = true`);
+  } else {
+    while (lines.length && !lines.at(-1).trim()) lines.pop();
+    if (lines.length) lines.push("");
+    lines.push("[features]", `${FEATURE} = true`, "");
+  }
+  const joined = lines.join("\n");
+  const updated = joined + (content.endsWith("\n") && !joined.endsWith("\n") ? "\n" : "");
+  validateManagedConfigEdit(config, updated, [FEATURE_PATH]);
+  return { content: updated, changed: true };
+}
+
+export async function codexNeedsThreadCompressionDefault({
+  binaryPaths = CODEX_APP_BINARY_PATHS,
+  execFileFn = promisify(execFile),
+} = {}) {
+  const binaries = new Set();
+  for (const binary of binaryPaths) {
+    try {
+      if (path.isAbsolute(binary) && fs.statSync(binary).isFile()) binaries.add(fs.realpathSync(binary));
+    } catch {}
+  }
+  if (!binaries.size) return false;
+  const home = await fs.promises.mkdtemp(path.join(os.tmpdir(), "ccdx-compression-probe-"));
+  try {
+    const defaults = await Promise.all([...binaries].map(async binary => {
+      try {
+        const { stdout } = await execFileFn(binary, ["features", "list"], {
+          cwd: home,
+          env: { CODEX_HOME: home, PATH: [path.dirname(process.execPath), "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(path.delimiter) },
+          encoding: "utf8", timeout: 1500, maxBuffer: 128 * 1024, windowsHide: true,
+        });
+        const rows = String(stdout).split("\n").filter(line => line.trim().split(/\s+/)[0] === FEATURE);
+        return rows.length === 1
+          && /^local_thread_store_compression\s+(?:under development|experimental|beta|stable)\s+false\s*$/i.test(rows[0].trim());
+      } catch { return false; }
+    }));
+    return defaults.every(Boolean);
+  } finally { await fs.promises.rm(home, { recursive: true, force: true }); }
+}
+
+export async function ensureCodexThreadCompression({
+  filePath = path.join(os.homedir(), ".codex", "config.toml"),
+  probe = codexNeedsThreadCompressionDefault,
+} = {}) {
+  try {
+    const read = () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(fs.readFileSync(filePath));
+    if (configured(parseCodexToml(read()))) return;
+    if (!await probe()) return;
+    // The client/user may edit the shared file while the asynchronous probe runs.
+    // Recompute against its current bytes; explicit opt-outs always win.
+    const updated = computeThreadCompressionDefault(read());
+    if (updated.changed) {
+      atomicWriteFileIfChangedSync(filePath, updated.content);
+      console.log(status("ok", "Enabled Codex local history compression (experimental)"));
+    }
+  } catch {
+    console.warn(status("warn", "Optional Codex history compression setup was skipped; core proxy remains available"));
+  }
+}