@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
86 lines (76 loc) • 5.45 kB
text/typescript
import { existsSync, readFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import { fixtureDigest } from "../digest";
import type { CaseAuthority, CaseRecord, FailureClassification, FailureRule } from "../conformance/types";
import { CL03_LIVE_SUITES, SYNTHETIC_MARKER } from "../conformance/types";
const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
const AUTHORITY_FILE = "024_live_v1_cases.json";
const RUNTIME_AUTHORITY = join(MODULE_DIR, "..", "conformance", "fixtures", "live-v1-cases.json");
const REPO_AUTHORITY = join(MODULE_DIR, "..", "..", "..", "devlog", "_fin", "260807_compatibility_lab", AUTHORITY_FILE);
function readAuthority(path: string): CaseAuthority { return JSON.parse(readFileSync(path, "utf8")) as CaseAuthority; }
/** During source-tree execution, fail closed unless the runtime copy is byte-identical to normative 024. */
export function assertLiveAuthorityMirror(): void {
if (!existsSync(REPO_AUTHORITY)) return;
const runtimeBytes = readFileSync(RUNTIME_AUTHORITY);
const normativeBytes = readFileSync(REPO_AUTHORITY);
if (!runtimeBytes.equals(normativeBytes)) throw new Error("harness_failure: live authority runtime copy drift");
}
export function loadLiveCaseAuthority(): CaseAuthority {
assertLiveAuthorityMirror();
const raw = readAuthority(RUNTIME_AUTHORITY);
validateLiveAuthority(raw);
return raw;
}
export function discoverLiveScenarios(authority: CaseAuthority, suites: readonly string[] = CL03_LIVE_SUITES): CaseRecord[] {
return authority.cases.filter((row) => suites.includes(row.suite));
}
export function expandLiveScenario(caseRecord: CaseRecord, authority: CaseAuthority): Record<string, unknown> {
const defaults = authority.manifestDefaults;
const fixtures = caseRecord.initiatingRequest ? [fixtureRef(caseRecord.initiatingRequest, authority), fixtureRef(caseRecord.fixture, authority)] : [fixtureRef(caseRecord.fixture, authority)];
return {
schemaVersion: authority.schemaVersion, id: caseRecord.id, version: defaults.version,
suite: { id: caseRecord.suite, version: defaults.suiteVersion, evidenceLayer: defaults.evidenceLayer },
evidenceLayer: defaults.evidenceLayer, capability: caseRecord.capability,
verificationRole: caseRecord.verificationRole ?? defaults.verificationRole, requirements: caseRecord.requirements,
fixtures, executionLimits: defaults.executionLimits, executionMode: defaults.executionMode, assertions: caseRecord.assertions,
...(caseRecord.expectedFailure ? { expectedFailure: caseRecord.expectedFailure } : {}),
failureRules: expandLiveFailureRules(caseRecord, authority), artifactPolicy: defaults.artifactPolicy, freshness: defaults.freshness,
};
}
function fixtureRef(fixture: CaseRecord["fixture"], authority: CaseAuthority): Record<string, unknown> {
const bytes = new TextEncoder().encode(fixture.bytesUtf8);
return { id: fixture.id, role: fixture.role, mediaType: fixture.mediaType, digest: fixture.digest, byteLength: bytes.byteLength,
syntheticMarker: SYNTHETIC_MARKER, provenance: { kind: "lab_authored", authority: AUTHORITY_FILE, sourceCommit: authority.sourceCommit } };
}
function expandLiveFailureRules(caseRecord: CaseRecord, authority: CaseAuthority): FailureRule[] {
const setName = authority.manifestDefaults.failureRuleSet;
const ruleSet = authority.failureRuleSets[setName];
if (!Array.isArray(ruleSet)) throw new Error(`harness_failure: contract_integrity unknown failureRuleSet ${setName}`);
const base = [...ruleSet];
if (!caseRecord.expectedFailure) return base;
const template = authority.expectedFailureRuleTemplate;
const controlRule: FailureRule = { id: template.id, match: [...template.match], classification: caseRecord.expectedFailure.expectedClass as FailureClassification,
secondaryCode: caseRecord.expectedFailure.expectedCode, verdictEffect: caseRecord.expectedFailure.onMatch === "unsupported" ? "unsupported" : "none",
retry: template.retry, expected: template.expected };
const idx = base.findIndex((row) => row.id === "required-assertion");
if (idx >= 0) base.splice(idx, 0, controlRule); else base.push(controlRule);
return base;
}
function validateLiveAuthority(authority: CaseAuthority): void {
if (authority.schemaVersion !== 1 || authority.manifestDefaults.evidenceLayer !== "live_route_compatibility") throw new Error("invalid live authority");
if (!authority.sourceCommit || !Array.isArray(authority.cases) || authority.cases.length !== 10) throw new Error("invalid live authority case set");
const ids = new Set<string>();
for (const caseRecord of authority.cases) {
if (ids.has(caseRecord.id)) throw new Error(`duplicate live scenario ${caseRecord.id}`);
ids.add(caseRecord.id);
if (!caseRecord.id.split(".").includes("live")) throw new Error(`non-live scenario in CL-03 authority: ${caseRecord.id}`);
const bytes = new TextEncoder().encode(caseRecord.fixture.bytesUtf8);
if (fixtureDigest(bytes) !== caseRecord.fixture.digest) throw new Error(`${caseRecord.id}: fixture digest mismatch`);
if (caseRecord.initiatingRequest) {
const initBytes = new TextEncoder().encode(caseRecord.initiatingRequest.bytesUtf8);
if (fixtureDigest(initBytes) !== caseRecord.initiatingRequest.digest) throw new Error(`${caseRecord.id}: initiatingRequest digest mismatch`);
}
expandLiveScenario(caseRecord, authority);
}
}