@yansigit/opencodex 2.36.1-dev.20260829.42 → 2.36.1-dev.20260829.48

package/src/storage/policy-input.ts

@@ -0,0 +1,166 @@
+import type { StorageCleanupPolicy } from "../types";
+
+export const DEFAULT_ARCHIVED_BYTES_OVER = 5 * 1024 ** 3;
+export const DEFAULT_REMOVE_OLDEST_PERCENT = 25;
+
+export type PolicySchedule = StorageCleanupPolicy["schedule"];
+
+/** Canonical defaults — enabled is always false. */
+export function defaultStorageCleanupPolicy(): StorageCleanupPolicy {
+  return {
+    enabled: false,
+    trigger: { archivedBytesOver: DEFAULT_ARCHIVED_BYTES_OVER },
+    target: { removeOldestPercent: DEFAULT_REMOVE_OLDEST_PERCENT },
+    schedule: "manual",
+    mode: "quarantine",
+  };
+}
+
+function isFiniteNonNegInt(n: unknown): n is number {
+  return typeof n === "number" && Number.isFinite(n) && n >= 0 && Math.floor(n) === n;
+}
+
+function isFinitePositiveInt(n: unknown): n is number {
+  return typeof n === "number" && Number.isFinite(n) && n > 0 && Math.floor(n) === n;
+}
+
+/** True when target has exactly one of reduceToBytes / removeOldestPercent. */
+export function isValidPolicyTarget(target: StorageCleanupPolicy["target"]): boolean {
+  if (!target || typeof target !== "object") return false;
+  const reduce = (target as { reduceToBytes?: unknown }).reduceToBytes;
+  const percent = (target as { removeOldestPercent?: unknown }).removeOldestPercent;
+  const hasReduce = reduce !== undefined;
+  const hasPercent = percent !== undefined;
+  if (hasReduce === hasPercent) return false;
+  if (hasReduce) return isFiniteNonNegInt(reduce);
+  return typeof percent === "number" && Number.isFinite(percent) && percent > 0 && percent <= 100;
+}
+
+/** Normalize persisted or partial policy input without ever enabling implicitly. */
+export function normalizeStorageCleanupPolicy(raw: unknown): StorageCleanupPolicy {
+  const base = defaultStorageCleanupPolicy();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
+  const o = raw as Record<string, unknown>;
+  let enabled = o.enabled === true;
+
+  let archivedBytesOver = base.trigger.archivedBytesOver;
+  if (o.trigger && typeof o.trigger === "object" && !Array.isArray(o.trigger)) {
+    const value = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
+    if (isFiniteNonNegInt(value)) archivedBytesOver = value;
+  }
+
+  let target: StorageCleanupPolicy["target"] = base.target;
+  if (Object.hasOwn(o, "target")) {
+    if (o.target && typeof o.target === "object" && !Array.isArray(o.target)) {
+      const candidate = o.target as StorageCleanupPolicy["target"];
+      if (isValidPolicyTarget(candidate)) {
+        const reduce = (candidate as { reduceToBytes?: number }).reduceToBytes;
+        const percent = (candidate as { removeOldestPercent?: number }).removeOldestPercent;
+        target = reduce !== undefined
+          ? { reduceToBytes: reduce }
+          : { removeOldestPercent: Math.min(100, Math.max(1, Math.floor(percent!))) };
+      } else {
+        enabled = false;
+      }
+    } else {
+      enabled = false;
+    }
+  }
+
+  const schedule: PolicySchedule =
+    o.schedule === "startup" || o.schedule === "daily" || o.schedule === "weekly" || o.schedule === "manual"
+      ? o.schedule
+      : base.schedule;
+  const mode = o.mode === "permanent" ? "permanent" : "quarantine";
+
+  let lastRun: StorageCleanupPolicy["lastRun"];
+  if (o.lastRun && typeof o.lastRun === "object" && !Array.isArray(o.lastRun)) {
+    const row = o.lastRun as Record<string, unknown>;
+    if (isFinitePositiveInt(row.at) && isFiniteNonNegInt(row.freedBytes) && isFiniteNonNegInt(row.removed)) {
+      lastRun = { at: row.at, freedBytes: row.freedBytes, removed: row.removed };
+    }
+  }
+
+  const nextRun = o.nextRun === undefined || o.nextRun === null
+    ? undefined
+    : isFinitePositiveInt(o.nextRun) ? o.nextRun : undefined;
+
+  return {
+    enabled,
+    trigger: { archivedBytesOver },
+    target,
+    schedule,
+    mode,
+    ...(lastRun ? { lastRun } : {}),
+    ...(nextRun !== undefined ? { nextRun } : {}),
+  };
+}
+
+/** Validate a management PUT body and merge it over the latest policy. */
+export function parseStorageCleanupPolicyInput(
+  raw: unknown,
+  previous?: StorageCleanupPolicy,
+): { ok: true; policy: StorageCleanupPolicy } | { ok: false; error: string } {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, error: "body must be a JSON object" };
+  }
+  const o = raw as Record<string, unknown>;
+  const prev = previous ?? defaultStorageCleanupPolicy();
+
+  if (o.enabled !== undefined && typeof o.enabled !== "boolean") {
+    return { ok: false, error: "enabled must be a boolean" };
+  }
+  if (o.mode !== undefined && o.mode !== "quarantine" && o.mode !== "permanent") {
+    return { ok: false, error: "mode must be quarantine or permanent" };
+  }
+  if (o.schedule !== undefined
+    && o.schedule !== "startup"
+    && o.schedule !== "daily"
+    && o.schedule !== "weekly"
+    && o.schedule !== "manual") {
+    return { ok: false, error: "schedule must be startup, daily, weekly, or manual" };
+  }
+
+  const merged: Record<string, unknown> = {
+    ...prev,
+    ...o,
+    trigger: o.trigger !== undefined ? o.trigger : prev.trigger,
+    target: o.target !== undefined ? o.target : prev.target,
+    lastRun: o.lastRun !== undefined ? o.lastRun : prev.lastRun,
+    nextRun: o.nextRun !== undefined ? o.nextRun : prev.nextRun,
+  };
+
+  if (o.trigger !== undefined) {
+    if (!o.trigger || typeof o.trigger !== "object" || Array.isArray(o.trigger)) {
+      return { ok: false, error: "trigger must be an object" };
+    }
+    const bytes = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
+    if (!isFiniteNonNegInt(bytes)) {
+      return { ok: false, error: "trigger.archivedBytesOver must be a non-negative integer" };
+    }
+  }
+  if (o.target !== undefined && !isValidPolicyTarget(o.target as StorageCleanupPolicy["target"])) {
+    return {
+      ok: false,
+      error: "target must set exactly one of reduceToBytes (non-negative int) or removeOldestPercent (1-100)",
+    };
+  }
+
+  const policy = normalizeStorageCleanupPolicy(merged);
+  if ((policy.schedule === "daily" || policy.schedule === "weekly")
+    && o.nextRun === undefined
+    && (policy.nextRun === undefined || (o.schedule !== undefined && o.schedule !== prev.schedule))) {
+    policy.nextRun = computeNextRun(policy.schedule, Date.now());
+  }
+  if ((policy.schedule === "manual" || policy.schedule === "startup") && o.nextRun === undefined) {
+    delete policy.nextRun;
+  }
+  return { ok: true, policy };
+}
+
+/** Wall-clock next run for daily/weekly. Startup/manual → undefined. */
+export function computeNextRun(schedule: PolicySchedule, now: number): number | undefined {
+  if (schedule === "daily") return now + 24 * 60 * 60 * 1000;
+  if (schedule === "weekly") return now + 7 * 24 * 60 * 60 * 1000;
+  return undefined;
+}

package/src/storage/policy.ts

@@ -8,7 +8,7 @@
  * Privacy: logs never include host paths, digests of file contents, or secrets.
  */
 import { resolveCodexHomeDir } from "../codex/home";
-import { loadConfig, saveConfigPreservingClaudeCode } from "../config";
+import { loadConfig, mutatePersistedConfig } from "../config";
 import type { StorageCleanupPolicy } from "../types";
 import {
   computePreviewDigest,
@@ -22,9 +22,21 @@ import {
   type CleanupResult,
   type ExecuteCleanupOptions,
 } from "./cleanup";
+import {
+  computeNextRun,
+  normalizeStorageCleanupPolicy,
+} from "./policy-input";
+export {
+  computeNextRun,
+  defaultStorageCleanupPolicy,
+  isValidPolicyTarget,
+  normalizeStorageCleanupPolicy,
+  parseStorageCleanupPolicyInput,
+  DEFAULT_ARCHIVED_BYTES_OVER,
+  DEFAULT_REMOVE_OLDEST_PERCENT,
+  type PolicySchedule,
+} from "./policy-input";
 
-export const DEFAULT_ARCHIVED_BYTES_OVER = 5 * 1024 ** 3; // 5 GiB
-export const DEFAULT_REMOVE_OLDEST_PERCENT = 25;
 export const BUSY_DEFER_MS = 15 * 60 * 1000;
 
 /** Optional sink so background policy writes stay synced with the live server config. */
@@ -36,7 +48,10 @@ export function setStorageCleanupPolicyLiveSink(
   livePolicySink = sink ?? undefined;
 }
 
-export type PolicySchedule = StorageCleanupPolicy["schedule"];
+function adoptStorageCleanupPolicy(policy: StorageCleanupPolicy): void {
+  livePolicySink?.(policy);
+}
+
 export type PolicyRunReason = "startup" | "schedule" | "manual";
 
 export type PolicySkipReason =
@@ -76,206 +91,20 @@ export interface PolicyRunDeps {
   onPolicyLoaded?: () => void;
 }
 
-/** Canonical defaults — enabled is always false. */
-export function defaultStorageCleanupPolicy(): StorageCleanupPolicy {
-  return {
-    enabled: false,
-    trigger: { archivedBytesOver: DEFAULT_ARCHIVED_BYTES_OVER },
-    target: { removeOldestPercent: DEFAULT_REMOVE_OLDEST_PERCENT },
-    schedule: "manual",
-    mode: "quarantine",
-  };
-}
-
-function isFiniteNonNegInt(n: unknown): n is number {
-  return typeof n === "number" && Number.isFinite(n) && n >= 0 && Math.floor(n) === n;
-}
-
-function isFinitePositiveInt(n: unknown): n is number {
-  return typeof n === "number" && Number.isFinite(n) && n > 0 && Math.floor(n) === n;
-}
-
-/** True when target has exactly one of reduceToBytes / removeOldestPercent. */
-export function isValidPolicyTarget(target: StorageCleanupPolicy["target"]): boolean {
-  if (!target || typeof target !== "object") return false;
-  const reduce = (target as { reduceToBytes?: unknown }).reduceToBytes;
-  const percent = (target as { removeOldestPercent?: unknown }).removeOldestPercent;
-  const hasReduce = reduce !== undefined;
-  const hasPercent = percent !== undefined;
-  if (hasReduce === hasPercent) return false; // none or both
-  if (hasReduce) return isFiniteNonNegInt(reduce);
-  return typeof percent === "number" && Number.isFinite(percent) && percent > 0 && percent <= 100;
-}
-
-/**
- * Normalize a partial/unknown policy into a complete StorageCleanupPolicy.
- * Never flips enabled to true unless the input explicitly sets enabled: true.
- */
-export function normalizeStorageCleanupPolicy(raw: unknown): StorageCleanupPolicy {
-  const base = defaultStorageCleanupPolicy();
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return base;
-  const o = raw as Record<string, unknown>;
-
-  // only explicit true enables — and never when a present target is malformed
-  let enabled = o.enabled === true;
-
-  let archivedBytesOver = base.trigger.archivedBytesOver;
-  if (o.trigger && typeof o.trigger === "object" && !Array.isArray(o.trigger)) {
-    const t = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
-    if (isFiniteNonNegInt(t)) archivedBytesOver = t;
-  }
-
-  let target: StorageCleanupPolicy["target"] = base.target;
-  if (Object.prototype.hasOwnProperty.call(o, "target")) {
-    if (o.target && typeof o.target === "object" && !Array.isArray(o.target)) {
-      const candidate = o.target as StorageCleanupPolicy["target"];
-      if (isValidPolicyTarget(candidate)) {
-        const reduce = (candidate as { reduceToBytes?: number }).reduceToBytes;
-        const percent = (candidate as { removeOldestPercent?: number }).removeOldestPercent;
-        target = reduce !== undefined
-          ? { reduceToBytes: reduce }
-          : { removeOldestPercent: Math.min(100, Math.max(1, Math.floor(percent!))) };
-      } else {
-        // Fail closed: malformed persisted target must not become delete-oldest 25%.
-        enabled = false;
-      }
-    } else {
-      enabled = false;
-    }
-  }
-
-  const schedule: PolicySchedule =
-    o.schedule === "startup" || o.schedule === "daily" || o.schedule === "weekly" || o.schedule === "manual"
-      ? o.schedule
-      : base.schedule;
-
-  const mode: CleanupMode = o.mode === "permanent" ? "permanent" : "quarantine";
-
-  let lastRun: StorageCleanupPolicy["lastRun"];
-  if (o.lastRun && typeof o.lastRun === "object" && !Array.isArray(o.lastRun)) {
-    const lr = o.lastRun as Record<string, unknown>;
-    if (
-      isFinitePositiveInt(lr.at)
-      && isFiniteNonNegInt(lr.freedBytes)
-      && isFiniteNonNegInt(lr.removed)
-    ) {
-      lastRun = { at: lr.at, freedBytes: lr.freedBytes, removed: lr.removed };
-    }
-  }
-
-  let nextRun: number | undefined;
-  if (o.nextRun === undefined || o.nextRun === null) {
-    nextRun = undefined;
-  } else if (isFinitePositiveInt(o.nextRun)) {
-    nextRun = o.nextRun;
-  }
-
-  return {
-    enabled,
-    trigger: { archivedBytesOver },
-    target,
-    schedule,
-    mode,
-    ...(lastRun ? { lastRun } : {}),
-    ...(nextRun !== undefined ? { nextRun } : {}),
-  };
-}
-
-/**
- * Validate a PUT body. Returns a normalized policy or an error string.
- * Does not invent enabled=true.
- */
-export function parseStorageCleanupPolicyInput(
-  raw: unknown,
-  previous?: StorageCleanupPolicy,
-): { ok: true; policy: StorageCleanupPolicy } | { ok: false; error: string } {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return { ok: false, error: "body must be a JSON object" };
-  }
-  const o = raw as Record<string, unknown>;
-  const prev = previous ?? defaultStorageCleanupPolicy();
-
-  if (o.enabled !== undefined && typeof o.enabled !== "boolean") {
-    return { ok: false, error: "enabled must be a boolean" };
-  }
-  if (o.mode !== undefined && o.mode !== "quarantine" && o.mode !== "permanent") {
-    return { ok: false, error: "mode must be quarantine or permanent" };
-  }
-  if (
-    o.schedule !== undefined
-    && o.schedule !== "startup"
-    && o.schedule !== "daily"
-    && o.schedule !== "weekly"
-    && o.schedule !== "manual"
-  ) {
-    return { ok: false, error: "schedule must be startup, daily, weekly, or manual" };
-  }
-
-  const merged: Record<string, unknown> = {
-    ...prev,
-    ...o,
-    trigger: o.trigger !== undefined ? o.trigger : prev.trigger,
-    target: o.target !== undefined ? o.target : prev.target,
-    // Preserve run metadata unless the client explicitly sends replacements.
-    lastRun: o.lastRun !== undefined ? o.lastRun : prev.lastRun,
-    nextRun: o.nextRun !== undefined ? o.nextRun : prev.nextRun,
-  };
-
-  if (o.trigger !== undefined) {
-    if (!o.trigger || typeof o.trigger !== "object" || Array.isArray(o.trigger)) {
-      return { ok: false, error: "trigger must be an object" };
-    }
-    const bytes = (o.trigger as { archivedBytesOver?: unknown }).archivedBytesOver;
-    if (!isFiniteNonNegInt(bytes)) {
-      return { ok: false, error: "trigger.archivedBytesOver must be a non-negative integer" };
-    }
-  }
-
-  if (o.target !== undefined) {
-    if (!isValidPolicyTarget(o.target as StorageCleanupPolicy["target"])) {
-      return {
-        ok: false,
-        error: "target must set exactly one of reduceToBytes (non-negative int) or removeOldestPercent (1-100)",
-      };
-    }
-  }
-
-  // Clients must not clear lastRun/nextRun via null unless intentional — accept omit only.
-  const policy = normalizeStorageCleanupPolicy(merged);
-  // Recompute nextRun only when schedule newly becomes timed, or no valid nextRun exists.
-  // Do not reset nextRun on every PUT that merely re-sends an unchanged schedule.
-  if (
-    (policy.schedule === "daily" || policy.schedule === "weekly")
-    && o.nextRun === undefined
-    && (policy.nextRun === undefined || (o.schedule !== undefined && o.schedule !== prev.schedule))
-  ) {
-    policy.nextRun = computeNextRun(policy.schedule, Date.now());
-  }
-  if (policy.schedule === "manual" || policy.schedule === "startup") {
-    if (o.nextRun === undefined) delete policy.nextRun;
-  }
-
-  return { ok: true, policy };
-}
-
 export function readStorageCleanupPolicyFromConfig(): StorageCleanupPolicy {
   return normalizeStorageCleanupPolicy(loadConfig().storageCleanupPolicy);
 }
 
 export function writeStorageCleanupPolicyToConfig(policy: StorageCleanupPolicy): StorageCleanupPolicy {
   const normalized = normalizeStorageCleanupPolicy(policy);
-  const config = loadConfig();
-  config.storageCleanupPolicy = normalized;
-  saveConfigPreservingClaudeCode(config);
-  livePolicySink?.(normalized);
-  return normalized;
-}
-
-/** Wall-clock next run for daily/weekly. Startup/manual → undefined. */
-export function computeNextRun(schedule: PolicySchedule, now: number): number | undefined {
-  if (schedule === "daily") return now + 24 * 60 * 60 * 1000;
-  if (schedule === "weekly") return now + 7 * 24 * 60 * 60 * 1000;
-  return undefined;
+  const outcome = mutatePersistedConfig(fresh => {
+    const changed = JSON.stringify(fresh.storageCleanupPolicy) !== JSON.stringify(normalized);
+    fresh.storageCleanupPolicy = normalized;
+    return { changed, value: structuredClone(normalized) };
+  });
+  if (outcome.status === "unavailable") throw new Error(`storage cleanup policy persistence unavailable: ${outcome.reason}`);
+  adoptStorageCleanupPolicy(outcome.value);
+  return outcome.value;
 }
 
 export function isPolicyDue(
@@ -401,6 +230,17 @@ export type PolicyRunMetadataPatch = {
   lastRun?: StorageCleanupPolicy["lastRun"];
 };
 
+function applyPolicyRunMetadata(
+  latest: StorageCleanupPolicy,
+  patch: PolicyRunMetadataPatch,
+): StorageCleanupPolicy {
+  let next = patch.nextRun === "defer_busy"
+    ? deferBusy(latest, patch.now)
+    : advanceNextRun(latest, patch.now);
+  if (patch.lastRun) next = { ...next, lastRun: patch.lastRun };
+  return next;
+}
+
 /**
  * Reload the latest persisted policy and write only run-owned metadata
  * (`lastRun` / `nextRun`). Preserves concurrent edits to enabled, trigger,
@@ -412,17 +252,23 @@ export function commitPolicyRunMetadata(
   patch: PolicyRunMetadataPatch,
 ): StorageCleanupPolicy {
   const latest = normalizeStorageCleanupPolicy(load());
-  let next =
-    patch.nextRun === "defer_busy"
-      ? deferBusy(latest, patch.now)
-      : advanceNextRun(latest, patch.now);
-  if (patch.lastRun) {
-    next = { ...next, lastRun: patch.lastRun };
-  }
+  const next = applyPolicyRunMetadata(latest, patch);
   save(next);
   return next;
 }
 
+function commitPersistedPolicyRunMetadata(patch: PolicyRunMetadataPatch): StorageCleanupPolicy {
+  const outcome = mutatePersistedConfig(fresh => {
+    const before = JSON.stringify(fresh.storageCleanupPolicy);
+    const next = applyPolicyRunMetadata(normalizeStorageCleanupPolicy(fresh.storageCleanupPolicy), patch);
+    fresh.storageCleanupPolicy = next;
+    return { changed: JSON.stringify(next) !== before, value: structuredClone(next) };
+  });
+  if (outcome.status === "unavailable") throw new Error(`storage cleanup policy persistence unavailable: ${outcome.reason}`);
+  adoptStorageCleanupPolicy(outcome.value);
+  return outcome.value;
+}
+
 function logPolicyEvent(message: string): void {
   console.log(`[storage-policy] ${message}`);
 }
@@ -434,8 +280,10 @@ function logPolicyEvent(message: string): void {
 export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   const now = deps.now ?? Date.now();
   const load = deps.loadPolicy ?? readStorageCleanupPolicyFromConfig;
-  const save = deps.savePolicy ?? writeStorageCleanupPolicyToConfig;
   const execute = deps.execute ?? executeArchivedCleanup;
+  const commit = deps.savePolicy
+    ? (patch: PolicyRunMetadataPatch) => commitPolicyRunMetadata(load, deps.savePolicy!, patch)
+    : commitPersistedPolicyRunMetadata;
 
   const policy = normalizeStorageCleanupPolicy(load());
   deps.onPolicyLoaded?.();
@@ -454,13 +302,13 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
 
   const selection = selectPolicyPreview(policy, deps.codexHome);
   if (selection.archivedBytes <= policy.trigger.archivedBytesOver) {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const saved = commit({ now, nextRun: "advance" });
     logPolicyEvent("skip under_threshold");
     return { ok: true, skipped: "under_threshold", policy: saved };
   }
 
   if (selection.count === 0) {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const saved = commit({ now, nextRun: "advance" });
     logPolicyEvent("skip nothing_selected");
     return { ok: true, skipped: "nothing_selected", policy: saved };
   }
@@ -476,14 +324,14 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
   });
 
   if (!result.ok && result.error === "codex_busy") {
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "defer_busy" });
+    const saved = commit({ now, nextRun: "defer_busy" });
     logPolicyEvent("defer codex_busy");
     return { ok: false, deferred: "codex_busy", error: "codex_busy", policy: saved };
   }
 
   if (!result.ok) {
     // Non-busy failure: still advance schedule so we do not tight-loop.
-    const saved = commitPolicyRunMetadata(load, save, { now, nextRun: "advance" });
+    const saved = commit({ now, nextRun: "advance" });
     logPolicyEvent(`fail ${result.error ?? "cleanup_failed"}`);
     return {
       ok: false,
@@ -494,7 +342,7 @@ export function runStorageCleanupPolicy(deps: PolicyRunDeps): PolicyRunResult {
     };
   }
 
-  const saved = commitPolicyRunMetadata(load, save, {
+  const saved = commit({
     now,
     nextRun: "advance",
     lastRun: {