codex-copilot-dx 0.9.10 → 0.9.11

package/README.md

@@ -394,6 +394,10 @@ The summary covers the current log and its single rotated backup, not an unbound
 
 Usage writes are asynchronous and batched under the existing cross-process rotation lock. Pending and in-flight records share a 4096-record / 4 MiB ceiling. If either ceiling is reached, new excess records are dropped with a warning and a status counter; inference does not wait or retry. Normal records and per-record rotation boundaries are unchanged. The bounded shutdown flush remains 1.5 seconds; disk failures and shutdown deadlines can prevent persistence, so usage is diagnostic rather than a billing ledger.
 
+Repeated plain usage summaries in the same process reuse one bounded cache entry when both retained log files are unchanged. File identity, size, modification/change timestamps and a two-second recent-write guard control reuse; concurrent settled-file queries share one scan. The serialized summary budget is 256 KiB and at most 128 model groups; larger results remain complete but uncached. Warnings, unstable reads, metadata errors and scans with changed files are not retained. Each caller receives an independent result. Analytics record callbacks and custom-warning reads keep the original streaming path. There is no persistent index, background polling, cross-process cache or change to usage writes; opening analytics still scans the retained records.
+
+Diagnostic redaction removes Basic authorization payloads and URL userinfo, and consumes escaped quotes inside sensitive JSON fields. Ordinary Basic-related prose, safe host/path information and error codes are retained. These protections apply to existing failure/status/debug diagnostics, not forwarded requests or upstream response bodies. They do not make arbitrary upstream prose guaranteed safe to share.
+
 ## Debug logging
 
 Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or provide a custom path. Add `CCDX_LOG_LEVEL=debug` for upstream attempts, retry causes, status codes, and timings. The adapter does not deliberately dump request/response bodies or authorization headers. File diagnostics redact common credential forms and labelled content echoes, but this cannot identify every secret in arbitrary external prose; review logs before sharing them. File writes are asynchronous and batched with a 4096-record / 2 MiB pending-and-in-flight ceiling. Overflow drops excess file records with one warning and a status counter; terminal output continues. CLI exit paths flush for at most 1.5 seconds. `ccdx doctor config` bypasses file logging entirely.

package/package.json

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

package/src/diagnostic-text.mjs

@@ -2,9 +2,16 @@
 // but remove common credential forms and explicitly labelled content echoes.
 export function redactDiagnosticText(value) {
   return String(value ?? "")
-    .replace(/\bBearer\s+[^\s,;"'<>]+/gi, "Bearer [redacted]")
+    .replace(/(\b(?:proxy[-_]?)?authorization["']?\s*[:=]\s*)(?:Basic|Bearer)\s+[^\s,;"'<>\\]+/gi, "$1[redacted]")
+    .replace(/\b(Bearer|Basic)\s+([^\s,;"'<>\\]+)/gi, (match, scheme, value) => {
+      // Standalone ordinary prose such as "basic authentication" is not a credential.
+      if (scheme.toLowerCase() === "basic"
+        && (!/^[a-z0-9+/_-]+={0,2}$/i.test(value) || !Buffer.from(value, "base64").includes(0x3a))) return match;
+      return `${scheme} [redacted]`;
+    })
+    .replace(/\b([a-z][a-z0-9+.-]{0,63}:\/\/)[^\s/?#"'<>]*@/gi, "$1[redacted]@")
     .replace(/\b(?:github_pat_|gh[pousr]_|sk-|copilot_)[A-Za-z0-9._-]+/gi, "[redacted]")
-    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie)["']?\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;]+)/gi, "$1[redacted]")
+    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie)["']?\s*[:=]\s*)(?:"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|[^\s,;]+)/gi, "$1[redacted]")
     .replace(/((?:prompt|input|completion|tool_arguments|arguments|content)["']?\s*[:=]\s*)[^\n]+/gi, "$1[redacted]")
     .replace(/(encrypted(?: function output)? content\s+)[A-Za-z0-9+/_=-]{24,}/gi, "$1[redacted]")
     .replace(/\b[A-Za-z0-9+/_=-]{96,}\b/g, "[redacted]");

package/src/usage.mjs

@@ -288,7 +288,7 @@ export function summarizeUsage(records) {
   return summary;
 }
 
-export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error, onRecord } = {}) {
+async function summarizeUsageLogFiles(filePath, { warn = console.error, onRecord } = {}) {
   const summary = { requests: 0, totals: {}, byModel: {} };
   for (const candidate of [rotatedFilePath(filePath), filePath]) {
     for await (const record of iterateUsageRecords(candidate, { warn })) {
@@ -305,6 +305,51 @@ export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = con
   return summary;
 }
 
+const SUMMARY_CACHE_MAX_BYTES = 256 * 1024;
+const SUMMARY_CACHE_SETTLED_MS = 2000;
+let cachedSummary = null;
+
+async function usageSummaryVersion(filePath) {
+  try {
+    const files = await Promise.all([rotatedFilePath(filePath), filePath].map(async (file) => {
+      try {
+        const stat = await fs.promises.stat(file, { bigint: true });
+        if (!stat.isFile()) return null;
+        const recent = Math.max(Number(stat.mtimeMs), Number(stat.ctimeMs));
+        if (Date.now() - recent < SUMMARY_CACHE_SETTLED_MS) return null;
+        return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+      } catch (error) {
+        if (error?.code === "ENOENT") return "missing";
+        throw error;
+      }
+    }));
+    return files.some((version) => version === null) ? null : `${path.resolve(filePath)}\0${files.join("|")}`;
+  } catch { return null; } // Uncacheable metadata never replaces the normal read/error path.
+}
+
+export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error, onRecord } = {}) {
+  if (onRecord || warn !== console.error) return summarizeUsageLogFiles(filePath, { warn, onRecord });
+  const version = await usageSummaryVersion(filePath);
+  if (version === null) {
+    cachedSummary = null;
+    return summarizeUsageLogFiles(filePath, { warn });
+  }
+  if (cachedSummary?.version === version) return structuredClone(await cachedSummary.promise);
+  const entry = { version, promise: null };
+  cachedSummary = entry;
+  entry.promise = (async () => {
+    let warned = false;
+    const summary = await summarizeUsageLogFiles(filePath, { warn(message) { warned = true; warn(message); } });
+    const after = await usageSummaryVersion(filePath);
+    const retain = !warned && after === version && Object.keys(summary.byModel).length <= 128
+      && Buffer.byteLength(JSON.stringify(summary)) <= SUMMARY_CACHE_MAX_BYTES;
+    if (!retain && cachedSummary === entry) cachedSummary = null;
+    return summary;
+  })();
+  try { return structuredClone(await entry.promise); }
+  catch (error) { if (cachedSummary === entry) cachedSummary = null; throw error; }
+}
+
 function fmt(n) {
   return Number.isFinite(n) ? n.toLocaleString("en-US") : "0";
 }