@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
94 lines (86 loc) • 5.24 kB
text/typescript
import { chmodSync, mkdirSync, readFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { atomicWriteFile } from "../config/atomic-write";
import { withConfigMutationLockSync } from "../config/mutation-lock";
import { assertNotRealHomeUnderTest } from "../lib/test-home-guard";
import { hardenSecretDir } from "../lib/windows-secret-acl";
import { linkDir } from "./paths";
/**
* How this Home keeps its Children current (050), in <configDir>/link/child-policy.json, never in config.json. Strict,
* unlike the observation cache: an operator's opt-out lives here, so a damaged file must not read as the defaults.
*/
export const CHILD_POLICY_SCHEMA = "ocx.link.child-policy/1" as const;
export const CATALOG_FANOUT = ["auto", "manual"] as const;
export const CHILD_CODEX_RESTART = ["never", "app-server-when-idle"] as const;
export const CHILD_UPDATES = ["off", "notify", "auto-when-idle"] as const;
export const IDLE_AFTER_MIN_MS = 60_000;
export const IDLE_AFTER_MAX_MS = 3_600_000;
export interface ChildPolicy {
catalogFanout: typeof CATALOG_FANOUT[number];
childCodexRestart: typeof CHILD_CODEX_RESTART[number];
updates: typeof CHILD_UPDATES[number];
idleAfterMs: number;
}
export const DEFAULT_CHILD_POLICY: Readonly<ChildPolicy> = Object.freeze({
catalogFanout: "auto", childCodexRestart: "never", updates: "auto-when-idle", idleAfterMs: 600_000,
});
/** Revision 4 (4529522051): what a damaged or unreadable file means. Nothing automatic runs until the operator saves. */
export const FAIL_CLOSED_CHILD_POLICY: Readonly<ChildPolicy> = Object.freeze({
catalogFanout: "manual", childCodexRestart: "never", updates: "off", idleAfterMs: 600_000,
});
export type ChildPolicyWarning = "policy-file-invalid";
export interface ChildPolicyRead { policy: ChildPolicy; warning: ChildPolicyWarning | null }
const KEYS = ["schema", "catalogFanout", "childCodexRestart", "updates", "idleAfterMs"] as const;
export function childPolicyPath(configDir?: string): string {
return join(linkDir(configDir), "child-policy.json");
}
/** Field-wise check shared by the file reader and PUT; returns null on any unknown key or invalid value. */
export function validPolicyPatch(value: Record<string, unknown>): Partial<ChildPolicy> | null {
const out: Partial<ChildPolicy> = {};
for (const [key, v] of Object.entries(value)) {
if (key === "catalogFanout" && (CATALOG_FANOUT as readonly unknown[]).includes(v)) out.catalogFanout = v as ChildPolicy["catalogFanout"];
else if (key === "childCodexRestart" && (CHILD_CODEX_RESTART as readonly unknown[]).includes(v)) out.childCodexRestart = v as ChildPolicy["childCodexRestart"];
else if (key === "updates" && (CHILD_UPDATES as readonly unknown[]).includes(v)) out.updates = v as ChildPolicy["updates"];
else if (key === "idleAfterMs" && typeof v === "number" && Number.isSafeInteger(v) && v >= IDLE_AFTER_MIN_MS && v <= IDLE_AFTER_MAX_MS) out.idleAfterMs = v;
else return null;
}
return out;
}
const failClosed = (): ChildPolicyRead => ({ policy: { ...FAIL_CLOSED_CHILD_POLICY }, warning: "policy-file-invalid" });
/**
* Absent file ⇒ defaults, no warning. Unreadable, unknown key or bad value ⇒ FAIL_CLOSED_CHILD_POLICY plus a warning.
* A damaged file is never rewritten here: the warning stays visible until the operator saves a policy.
*/
export function readChildPolicy(path = childPolicyPath()): ChildPolicyRead {
let text: string;
try { text = readFileSync(path, "utf8"); } catch (error) {
return (error as NodeJS.ErrnoException).code === "ENOENT" ? { policy: { ...DEFAULT_CHILD_POLICY }, warning: null } : failClosed();
}
try {
const parsed: unknown = JSON.parse(text);
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return failClosed();
const record = parsed as Record<string, unknown>;
if (record.schema !== CHILD_POLICY_SCHEMA || Object.keys(record).some(key => !(KEYS as readonly string[]).includes(key))) return failClosed();
const { schema: _schema, ...fields } = record;
const patch = validPolicyPatch(fields);
return patch ? { policy: { ...DEFAULT_CHILD_POLICY, ...patch }, warning: null } : failClosed();
} catch { return failClosed(); }
}
/**
* Read-merge-write under the config mutation lock; the file always holds every key. Same guard, directory mode and
* Windows ACL hardening as updateChildObservations (child-observations.ts). Over an invalid file the patch merges onto
* the fail-closed policy, so the operator chooses every automatic mode again.
*/
export function updateChildPolicy(patch: Partial<ChildPolicy>, path = childPolicyPath()): ChildPolicy {
const dir = dirname(path), configDir = dirname(dir);
assertNotRealHomeUnderTest(configDir);
return withConfigMutationLockSync(() => {
const next: ChildPolicy = { ...readChildPolicy(path).policy, ...patch };
mkdirSync(dir, { recursive: true, mode: 0o700 });
if (process.platform === "win32") hardenSecretDir(dir, { required: true });
else chmodSync(dir, 0o700);
atomicWriteFile(path, `${JSON.stringify({ schema: CHILD_POLICY_SCHEMA, ...next }, null, 2)}\n`);
if (process.platform !== "win32") chmodSync(path, 0o600);
return next;
}, configDir);
}