fix: preserve invalid config before fallback

Rebuilt on current dev from PR #26 by 0disoft / ZeroDi.

Co-authored-by: 0disoft <rodisoft1@gmail.com>

Author: lidge-jun

src/config.ts

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, chmodSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, chmodSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import * as z from "zod/v4";
 import type { OcxConfig } from "./types";
 
 let _atomicSeq = 0;
@@ -26,6 +27,27 @@ function resolvePidPath(): string {
   return join(resolveConfigDir(), "ocx.pid");
 }
 
+const warnedConfigFallbacks = new Set<string>();
+
+const providerConfigSchema = z.object({
+  adapter: z.string().min(1),
+  baseUrl: z.string().min(1),
+}).passthrough();
+
+const configSchema = z.object({
+  port: z.number().int().min(0).max(65535).default(10100),
+  providers: z.record(z.string(), providerConfigSchema),
+  defaultProvider: z.string().min(1),
+}).passthrough().superRefine((config, ctx) => {
+  if (Object.keys(config.providers).length > 0 && !(config.defaultProvider in config.providers)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultProvider"],
+      message: "defaultProvider must exist in providers",
+    });
+  }
+});
+
 /**
  * Default featured subagent models (native GPT) seeded on a fresh install and when `subagentModels`
  * is unset. Codex's spawn_agent advertises the first 5 featured catalog entries; these are the GPT
@@ -71,8 +93,9 @@ export function loadConfig(): OcxConfig {
   }
   try {
     const raw = readFileSync(configPath, "utf-8");
-    return JSON.parse(raw) as OcxConfig;
-  } catch {
+    return configSchema.parse(JSON.parse(raw)) as OcxConfig;
+  } catch (error) {
+    warnAndBackupInvalidConfig(configPath, error);
     return getDefaultConfig();
   }
 }
@@ -157,3 +180,27 @@ export function removePid(): void {
     unlinkSync(getPidPath());
   } catch { /* ignore */ }
 }
+
+function warnAndBackupInvalidConfig(configPath: string, error: unknown): void {
+  if (warnedConfigFallbacks.has(configPath)) return;
+  warnedConfigFallbacks.add(configPath);
+
+  const backupPath = backupInvalidConfig(configPath);
+  const reason = error instanceof z.ZodError
+    ? error.issues.map(issue => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ")
+    : error instanceof Error ? error.message : String(error);
+  const backupNote = backupPath ? ` A backup was written to ${backupPath}.` : "";
+  console.error(`Could not load opencodex config at ${configPath}: ${reason}. Using default config.${backupNote}`);
+}
+
+function backupInvalidConfig(configPath: string): string | null {
+  if (!existsSync(configPath)) return null;
+  const backupPath = `${configPath}.invalid-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  try {
+    copyFileSync(configPath, backupPath);
+    try { chmodSync(backupPath, 0o600); } catch { /* best-effort */ }
+    return backupPath;
+  } catch {
+    return null;
+  }
+}

tests/config.test.ts

@@ -1,5 +1,33 @@
-import { describe, expect, test } from "bun:test";
-import { codexAutoStartEnabled, getDefaultConfig } from "../src/config";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { codexAutoStartEnabled, getConfigPath, getDefaultConfig, loadConfig } from "../src/config";
+
+let testDir = "";
+
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), "ocx-config-"));
+  process.env.OPENCODEX_HOME = testDir;
+});
+
+afterEach(() => {
+  delete process.env.OPENCODEX_HOME;
+  if (testDir && existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
+  testDir = "";
+});
+
+function backupNames(): string[] {
+  return readdirSync(testDir).filter(name => name.startsWith("config.json.invalid-"));
+}
+
+function writeConfig(content: unknown): void {
+  writeFileSync(
+    getConfigPath(),
+    typeof content === "string" ? content : JSON.stringify(content),
+    "utf-8",
+  );
+}
 
 describe("opencodex config defaults", () => {
   test("Codex autostart is enabled by default", () => {
@@ -11,4 +39,95 @@ describe("opencodex config defaults", () => {
     expect(codexAutoStartEnabled({ codexAutoStart: false })).toBe(false);
     expect(codexAutoStartEnabled({ codexAutoStart: true })).toBe(true);
   });
+
+  test("loads valid config from OPENCODEX_HOME", () => {
+    writeConfig({
+      port: 12345,
+      providers: {
+        custom: { adapter: "openai-chat", baseUrl: "https://example.test/v1" },
+      },
+      defaultProvider: "custom",
+      codexAutoStart: false,
+    });
+
+    expect(loadConfig()).toMatchObject({
+      port: 12345,
+      defaultProvider: "custom",
+      providers: {
+        custom: { adapter: "openai-chat", baseUrl: "https://example.test/v1" },
+      },
+      codexAutoStart: false,
+    });
+  });
+
+  test("backs up invalid JSON config before falling back to defaults", () => {
+    writeConfig("{ invalid json");
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const loaded = loadConfig();
+
+      expect(loaded).toEqual(getDefaultConfig());
+      const backups = backupNames();
+      expect(backups).toHaveLength(1);
+      expect(readFileSync(join(testDir, backups[0]), "utf-8")).toBe("{ invalid json");
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("Could not load opencodex config"));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  test("backs up structurally invalid config before falling back to defaults", () => {
+    writeConfig({ port: 10100 });
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const loaded = loadConfig();
+
+      expect(loaded).toEqual(getDefaultConfig());
+      const backups = backupNames();
+      expect(backups).toHaveLength(1);
+      expect(JSON.parse(readFileSync(join(testDir, backups[0]), "utf-8"))).toEqual({ port: 10100 });
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("providers"));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  test("backs up config when defaultProvider is absent from providers", () => {
+    writeConfig({
+      port: 10100,
+      providers: {
+        openai: { adapter: "openai-responses", baseUrl: "https://chatgpt.com/backend-api/codex" },
+      },
+      defaultProvider: "missing",
+    });
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const loaded = loadConfig();
+
+      expect(loaded).toEqual(getDefaultConfig());
+      const backups = backupNames();
+      expect(backups).toHaveLength(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("defaultProvider must exist in providers"));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  test("warns and backs up once per invalid config path", () => {
+    writeConfig("{ invalid json");
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(loadConfig()).toEqual(getDefaultConfig());
+      expect(loadConfig()).toEqual(getDefaultConfig());
+
+      expect(backupNames()).toHaveLength(1);
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
 });