@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
354 lines (321 loc) • 13 kB
text/typescript
import { replayLabLedger } from "../ledger/store";
import { labLedgerPath } from "../paths";
import { queryLabEvents, queryLabVerdicts } from "../query";
import type { ObservationEvent } from "../events/types";
import {
importCommunityEvidenceBundle,
listCommunityEvidence,
} from "./community";
import { readPrivateRegularFile } from "./file-safety";
import { withPublicEvidenceMutationLock } from "./mutation-lock";
import { recordLocalPublicOrigin } from "./origin";
import type { ProjectPublicEvidenceRecordInput } from "./project";
import { projectPublicEvidenceRecord } from "./project";
import {
signPublicEvidenceBundle,
verifyPublicEvidenceBundle,
} from "./signature";
import { storePublicEvidenceBundle } from "./storage";
import { parseStrictPublicJson } from "./strict-json";
import { publicUtcDay } from "./time";
import { PUBLIC_EVIDENCE_BUNDLE_SCHEMA_VERSION, PUBLIC_EXPORT_POLICY_VERSION } from "./types";
import type {
PublicEvidenceBundleV1,
PublicEvidencePreviewBundleV1,
PublicEvidenceRecordV1,
PublicProjectionNotExportableReason,
} from "./types";
import { PublicEvidenceValidationError } from "./validate";
const MAX_OPERATOR_EVENTS = 256;
const MAX_PUBLIC_FILE_BYTES = 2 * 1024 * 1024;
const EMPTY_PREVIEW_DAY = "1970-01-01";
const PRIVATE_STORAGE_LOCATOR = "<private>";
export interface ProjectPublicEvidenceInput {
records: ProjectPublicEvidenceRecordInput[];
}
export function projectPublicEvidence(input: ProjectPublicEvidenceInput): {
bundle: PublicEvidencePreviewBundleV1;
excluded: Array<{ index: number; reason: PublicProjectionNotExportableReason }>;
} {
const records: PublicEvidenceRecordV1[] = [];
const excluded: Array<{ index: number; reason: PublicProjectionNotExportableReason }> = [];
let latestExportableCompletedAt: number | null = null;
input.records.forEach((recordInput, index) => {
const projected = projectPublicEvidenceRecord(recordInput);
if (projected.status !== "exportable") {
excluded.push({ index, reason: projected.reason });
return;
}
records.push(projected.record);
latestExportableCompletedAt = Math.max(
latestExportableCompletedAt ?? recordInput.observation.completedAt,
recordInput.observation.completedAt,
);
});
records.sort((a, b) => a.recordId < b.recordId ? -1 : a.recordId > b.recordId ? 1 : 0);
return {
bundle: {
schemaVersion: PUBLIC_EVIDENCE_BUNDLE_SCHEMA_VERSION,
exportPolicyVersion: PUBLIC_EXPORT_POLICY_VERSION,
createdDayUtc: latestExportableCompletedAt === null
? EMPTY_PREVIEW_DAY
: publicUtcDay(latestExportableCompletedAt),
records,
artifacts: [],
},
excluded,
};
}
export type PublicOperatorExclusionReason =
| PublicProjectionNotExportableReason
| "event_not_found"
| "not_observation"
| "event_excluded"
| "no_canonical_verdict";
export interface PublicOperatorExclusionV1 {
selectionIndex: number;
reason: PublicOperatorExclusionReason;
}
export interface LocalPublicPreviewV1 {
bundle: PublicEvidencePreviewBundleV1;
excluded: PublicOperatorExclusionV1[];
}
export interface LocalPublicExportV1 {
bundle: PublicEvidenceBundleV1;
stored: { path: typeof PRIVATE_STORAGE_LOCATOR; created: boolean };
excluded: PublicOperatorExclusionV1[];
}
export type PublicVerificationSummaryV1 =
| { status: "cryptographically_valid"; bundleId: string; publisherKeyId: string; locallyVerified: false }
| { status: "schema_rejected" | "digest_invalid" | "signature_invalid"; locallyVerified: false };
function assertOperatorEventIds(eventIds: readonly string[]): Array<{ eventId: string; selectionIndex: number }> {
if (eventIds.length === 0 || eventIds.length > MAX_OPERATOR_EVENTS) {
throw new PublicEvidenceValidationError(
"public_selection_limit",
`public evidence selection must contain 1..${MAX_OPERATOR_EVENTS} event ids`,
);
}
const unique: Array<{ eventId: string; selectionIndex: number }> = [];
const seen = new Set<string>();
for (const [selectionIndex, eventId] of eventIds.entries()) {
if (!/^[0-9a-f]{64}$/.test(eventId)) {
throw new PublicEvidenceValidationError(
"public_selection_event_id",
"public evidence event ids must be lowercase sha256 hex",
);
}
if (seen.has(eventId)) continue;
seen.add(eventId);
unique.push({ eventId, selectionIndex });
}
return unique;
}
function projectedObservationState(
eventIds: readonly string[],
configDir?: string,
): Map<string, { excluded: boolean }> {
const pending = new Set(eventIds);
const state = new Map<string, { excluded: boolean }>();
let cursor: string | undefined;
while (pending.size > 0) {
const page = queryLabEvents({ eventKind: "observation" }, cursor, 200, configDir);
for (const row of page.items) {
if (!pending.has(row.eventId)) continue;
state.set(row.eventId, { excluded: row.excluded });
pending.delete(row.eventId);
}
if (!page.hasMore || !page.nextCursor) break;
cursor = page.nextCursor;
}
return state;
}
function canonicalVerdictsForObservations(
observations: readonly ObservationEvent[],
configDir?: string,
): Map<string, ProjectPublicEvidenceRecordInput["verdict"]> {
const verdictByEventId = new Map<string, ProjectPublicEvidenceRecordInput["verdict"]>();
const groups = new Map<string, {
subjectId: string;
evidenceLayer: ObservationEvent["evidenceLayer"];
suiteId: string;
observations: ObservationEvent[];
}>();
for (const observation of observations) {
const key = `${observation.subjectId}\0${observation.evidenceLayer}\0${observation.suiteId}`;
const existing = groups.get(key);
if (existing) existing.observations.push(observation);
else groups.set(key, {
subjectId: observation.subjectId,
evidenceLayer: observation.evidenceLayer,
suiteId: observation.suiteId,
observations: [observation],
});
}
for (const group of groups.values()) {
const pending = new Map(group.observations.map((observation) => [observation.eventId, observation] as const));
let cursor: string | undefined;
while (pending.size > 0) {
const page = queryLabVerdicts({
subjectId: group.subjectId,
layer: group.evidenceLayer,
suiteId: group.suiteId,
}, cursor, 200, configDir);
for (const row of page.items) {
for (const eventId of row.contributingEventIds) {
const observation = pending.get(eventId);
if (!observation) continue;
if (
row.subjectId !== observation.subjectId
|| row.evidenceLayer !== observation.evidenceLayer
|| row.suiteId !== observation.suiteId
|| row.suiteVersion !== observation.suiteVersion
) {
continue;
}
verdictByEventId.set(eventId, row.verdict);
pending.delete(eventId);
}
}
if (!page.hasMore || !page.nextCursor) break;
cursor = page.nextCursor;
}
}
return verdictByEventId;
}
export function previewLocalPublicEvidence(
input: { eventIds: readonly string[] },
configDir?: string,
): LocalPublicPreviewV1 {
const selections = assertOperatorEventIds(input.eventIds);
const replay = replayLabLedger(labLedgerPath(configDir));
const byId = new Map(replay.events.map((event) => [event.eventId, event] as const));
const observationSelections: Array<{ observation: ObservationEvent; selectionIndex: number }> = [];
const excluded: PublicOperatorExclusionV1[] = [];
for (const { eventId, selectionIndex } of selections) {
const event = byId.get(eventId);
if (!event) {
excluded.push({ selectionIndex, reason: "event_not_found" });
continue;
}
if (event.eventKind !== "observation") {
excluded.push({ selectionIndex, reason: "not_observation" });
continue;
}
observationSelections.push({ observation: event, selectionIndex });
}
if (observationSelections.length === 0) {
throw new PublicEvidenceValidationError("public_selection_empty", "public evidence selection contains no observation events");
}
const projectionByEventId = projectedObservationState(
observationSelections.map(({ observation }) => observation.eventId),
configDir,
);
const candidates: Array<{ observation: ObservationEvent; selectionIndex: number }> = [];
for (const candidate of observationSelections) {
const projectedEvent = projectionByEventId.get(candidate.observation.eventId);
if (!projectedEvent) {
excluded.push({ selectionIndex: candidate.selectionIndex, reason: "event_not_found" });
continue;
}
if (projectedEvent.excluded) {
excluded.push({ selectionIndex: candidate.selectionIndex, reason: "event_excluded" });
continue;
}
candidates.push(candidate);
}
const verdictByEventId = canonicalVerdictsForObservations(
candidates.map((candidate) => candidate.observation),
configDir,
);
const projectInputs: ProjectPublicEvidenceRecordInput[] = [];
const projectSelectionIndices: number[] = [];
for (const { observation, selectionIndex } of candidates) {
const verdict = verdictByEventId.get(observation.eventId);
if (!verdict) {
excluded.push({ selectionIndex, reason: "no_canonical_verdict" });
continue;
}
projectInputs.push({ observation, verdict });
projectSelectionIndices.push(selectionIndex);
}
const projected = projectPublicEvidence({ records: projectInputs });
for (const row of projected.excluded) {
excluded.push({ selectionIndex: projectSelectionIndices[row.index]!, reason: row.reason });
}
excluded.sort((a, b) => a.selectionIndex - b.selectionIndex);
return { bundle: projected.bundle, excluded };
}
export function exportLocalPublicEvidence(
input: { eventIds: readonly string[] },
configDir?: string,
): LocalPublicExportV1 {
const preview = previewLocalPublicEvidence(input, configDir);
if (preview.bundle.records.length === 0) {
throw new PublicEvidenceValidationError("public_export_empty", "selected events produced no exportable public evidence records");
}
const bundle = signPublicEvidenceBundle({
records: preview.bundle.records,
artifacts: preview.bundle.artifacts,
createdDayUtc: preview.bundle.createdDayUtc,
configDir,
});
return withPublicEvidenceMutationLock(configDir, () => {
// Commit purge-owned provenance first. If export publication later fails or the
// process crashes, an orphan marker is conservative and can be reclaimed later;
// the inverse state, a durable export without provenance, is not acceptable.
recordLocalPublicOrigin({ publisherKeyId: bundle.publisher.keyId, bundleId: bundle.bundleId }, configDir);
const stored = storePublicEvidenceBundle(bundle, configDir);
return {
bundle,
stored: { path: PRIVATE_STORAGE_LOCATOR, created: stored.created },
excluded: preview.excluded,
};
});
}
export function summarizePublicEvidenceVerification(raw: unknown): PublicVerificationSummaryV1 {
const result = verifyPublicEvidenceBundle(raw as PublicEvidenceBundleV1);
if (result.status !== "cryptographically_valid") {
return { status: result.status, locallyVerified: false };
}
const bundle = raw as PublicEvidenceBundleV1;
return {
status: "cryptographically_valid",
bundleId: bundle.bundleId,
publisherKeyId: bundle.publisher.keyId,
locallyVerified: false,
};
}
function readBoundedPublicFile(path: string): Buffer {
return readPrivateRegularFile(path, {
maxBytes: MAX_PUBLIC_FILE_BYTES,
errorCode: "public_file_unsafe",
errorMessage: "public evidence input must be a regular non-symlink file",
sizeErrorCode: "public_file_too_large",
sizeErrorMessage: "public evidence input exceeds 2 MiB",
});
}
function parsePublicFile(path: string): unknown {
return parseStrictPublicJson(readBoundedPublicFile(path), "public evidence input", "public_file_json");
}
export function verifyPublicEvidenceFile(path: string): PublicVerificationSummaryV1 {
return summarizePublicEvidenceVerification(parsePublicFile(path));
}
function finishCommunityImport(
stored: { path: string; created: boolean; bundleId: string; publisherKeyId: string },
) {
const { path: _privatePath, ...imported } = stored;
return { ...imported, trustClass: "community_untrusted_v1" as const, locallyVerified: false as const };
}
export function importCommunityEvidenceFile(path: string, configDir?: string) {
return finishCommunityImport(importCommunityEvidenceBundle(readBoundedPublicFile(path), configDir));
}
export function importCommunityEvidenceValue(raw: unknown, configDir?: string) {
return finishCommunityImport(importCommunityEvidenceBundle(raw, configDir));
}
export function listCommunityEvidenceContext(configDir?: string) {
return {
evidence: listCommunityEvidence(configDir),
trustClass: "community_untrusted_v1" as const,
locallyVerified: false as const,
};
}