@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
515 lines (490 loc) • 16.7 kB
text/typescript
import type { FailureRecordV1, RouteSubjectV1 } from "../events/types";
import { labSandboxEnvironment, rejectProxyEnvironment } from "../live/sandbox";
import type { LabDestinationV1, LabRouteContext } from "../live/types";
import { buildRouteSubjectV1 } from "../subject/route-subject";
import { isTrustedFabricPatchExecutor } from "../../lib/fabric-task-execution-authority";
import {
FABRIC_COMPATIBILITY_VERSION,
FABRIC_LIMITS,
FABRIC_TASK_CLASS_ID,
FABRIC_TASK_CLASS_VERSION,
FABRIC_VERIFIER_ID,
SANDBOX_PROFILE_V1,
SYNTHETIC_AFTER_UTF8,
SYNTHETIC_BEFORE_UTF8,
SYNTHETIC_VALUE_PATH,
} from "./constants";
import { applySyntheticPatch, parseSyntheticPatchV1 } from "./patch";
import {
fabricProducerIsolationLimits,
isUnconfirmedProducerTermination,
runIsolatedFabricProducer,
} from "./producer-isolate";
import {
assertNotUnderUserRepo,
createSyntheticScratch,
type ScratchTree,
} from "./scratch";
import {
buildTaskSubjectV1,
sandboxProfileDigest,
taskFixtureDigest,
taskSubjectId,
verifierManifestDigest,
} from "./subject";
import type {
FabricExecutionAuthority,
FabricHarnessProducerKind,
FabricTaskOutcomeV1,
FabricTaskRunResult,
FabricUsageV1,
SyntheticPatchV1,
TrustedFabricPatchExecutor,
} from "./types";
import { FabricTaskError } from "./types";
import { verifyExactTreeDiffV1 } from "./verifier";
/** Options for harness-only fabric task runs (not persistable as production evidence). */
export interface RunFabricTaskHarnessOptions {
routeSubject: RouteSubjectV1;
harnessKind: FabricHarnessProducerKind;
configDir?: string;
userRepoRoot?: string;
sourceRefs?: string[];
now?: () => number;
}
/** Options for authoritative route-bound fabric task execution. */
export interface RunFabricTaskForRouteOptions {
routeContext: LabRouteContext;
destination: LabDestinationV1;
patchExecutor: TrustedFabricPatchExecutor;
configDir?: string;
userRepoRoot?: string;
sourceRefs?: string[];
now?: () => number;
}
/** Map a FabricTaskError into a ledger failure record. */
function failureFromError(error: FabricTaskError): FailureRecordV1 {
return {
class: error.code,
code: error.code,
retryable: error.code === "timeout" || error.code === "inactivity_timeout" || error.code === "budget_exhausted",
attribution: error.attribution,
};
}
/** Map a failure record to the observation outcome kind for persistence. */
function outcomeFromFailure(failure: FailureRecordV1): FabricTaskOutcomeV1["outcome"] {
if (failure.class === "behavioral_failure") return "fail";
if (failure.attribution === "harness") return "inconclusive";
return "blocked";
}
/** Closed successful patch for deterministic harness injection. */
export function correctSyntheticPatch(): SyntheticPatchV1 {
return {
schemaVersion: 1,
operations: [{ op: "replace", path: SYNTHETIC_VALUE_PATH, contentUtf8: SYNTHETIC_AFTER_UTF8 }],
};
}
/**
* Authoritative CL-07 route-bound fabric task execution.
* Route identity is derived from routeContext + destination; patch production runs in an isolated child.
*/
export async function runFabricSyntheticPatchTaskForRoute(
options: RunFabricTaskForRouteOptions,
): Promise<FabricTaskRunResult> {
if (!isTrustedFabricPatchExecutor(options.patchExecutor)) {
throw new FabricTaskError("untrusted fabric patch executor", "sandbox_violation", "harness");
}
const routeSubject = buildRouteSubjectV1(options.routeContext, options.destination, options.configDir);
return runFabricSyntheticPatchTaskInternal({
routeSubject,
routeContext: options.routeContext,
destination: options.destination,
patchExecutor: options.patchExecutor,
harnessKind: undefined,
executionAuthority: "trusted_route",
configDir: options.configDir,
userRepoRoot: options.userRepoRoot,
sourceRefs: options.sourceRefs,
now: options.now,
});
}
/** Harness-only fabric task execution; outcomes are not persistable as production evidence. */
export async function runFabricSyntheticPatchTaskHarness(
options: RunFabricTaskHarnessOptions,
): Promise<FabricTaskRunResult> {
return runFabricSyntheticPatchTaskInternal({
routeSubject: options.routeSubject,
harnessKind: options.harnessKind,
executionAuthority: "harness",
configDir: options.configDir,
userRepoRoot: options.userRepoRoot,
sourceRefs: options.sourceRefs,
now: options.now,
});
}
/**
* @deprecated Use runFabricSyntheticPatchTaskHarness or runFabricSyntheticPatchTaskForRoute.
*/
export async function runFabricSyntheticPatchTask(
options: Omit<RunFabricTaskHarnessOptions, "harnessKind"> & {
producePatch?: never;
harnessKind?: RunFabricTaskHarnessOptions["harnessKind"];
},
): Promise<FabricTaskOutcomeV1> {
const result = await runFabricSyntheticPatchTaskHarness({
routeSubject: options.routeSubject,
harnessKind: options.harnessKind ?? "deterministic_correct",
configDir: options.configDir,
userRepoRoot: options.userRepoRoot,
sourceRefs: options.sourceRefs,
now: options.now,
});
return result.outcome;
}
async function runFabricSyntheticPatchTaskInternal(input: {
routeSubject: RouteSubjectV1;
routeContext?: LabRouteContext;
destination?: LabDestinationV1;
patchExecutor?: TrustedFabricPatchExecutor;
harnessKind?: FabricHarnessProducerKind;
executionAuthority: FabricExecutionAuthority;
configDir?: string;
userRepoRoot?: string;
sourceRefs?: string[];
now?: () => number;
}): Promise<FabricTaskRunResult> {
rejectProxyEnvironment();
labSandboxEnvironment();
const startedAt = input.now?.() ?? Date.now();
const fixtureDigest = taskFixtureDigest();
const verifierDigest = verifierManifestDigest();
const sandboxDigest = sandboxProfileDigest();
const taskSubject = buildTaskSubjectV1({
routeSubject: input.routeSubject,
taskFixtureDigest: fixtureDigest,
verifierManifestDigest: verifierDigest,
sandboxProfileDigest: sandboxDigest,
fabricCompatibilityVersion: FABRIC_COMPATIBILITY_VERSION,
});
const subjectId = taskSubjectId(taskSubject);
const usage: FabricUsageV1 = {
inputBytes: Buffer.byteLength(SYNTHETIC_BEFORE_UTF8, "utf8"),
outputBytes: 0,
patchOperations: 0,
filesTouched: 0,
artifactBytes: 0,
elapsedMs: 0,
inactiveMs: 0,
};
let scratch: ScratchTree | undefined;
let producerCompletedAt = startedAt;
let lastActivityAt = startedAt;
// Rejected while the producer child might still be running: scratch must not
// be removed under it; absence of a termination proof requires manual review.
let producerTerminationUnconfirmed = false;
try {
scratch = createSyntheticScratch(input.configDir);
if (input.userRepoRoot) {
assertNotUnderUserRepo(scratch.root, input.userRepoRoot);
}
const isolation = fabricProducerIsolationLimits();
const inactivityTimeoutMs =
input.harnessKind === "infinite_sync"
? isolation.totalTimeoutMs + 1_000
: isolation.inactivityTimeoutMs;
let patchRaw: unknown;
try {
if (input.harnessKind) {
lastActivityAt = input.now?.() ?? Date.now();
const isolated = await runIsolatedFabricProducer({
harnessKind: input.harnessKind,
scratchRoot: scratch.root,
totalTimeoutMs: isolation.totalTimeoutMs,
inactivityTimeoutMs,
now: input.now,
});
patchRaw = isolated.patch;
lastActivityAt = isolated.lastActivityAt;
producerCompletedAt = input.now?.() ?? Date.now();
} else if (input.patchExecutor && input.routeContext && input.destination) {
lastActivityAt = input.now?.() ?? Date.now();
const isolated = await runIsolatedFabricProducer({
executorModulePath: input.patchExecutor.executorModulePath,
scratchRoot: scratch.root,
totalTimeoutMs: isolation.totalTimeoutMs,
inactivityTimeoutMs: isolation.inactivityTimeoutMs,
executorInput: {
routeContext: input.routeContext,
destination: input.destination,
routeSubject: input.routeSubject,
scratchRoot: scratch.root,
reportActivity: () => undefined,
signal: new AbortController().signal,
},
now: input.now,
});
patchRaw = isolated.patch;
lastActivityAt = isolated.lastActivityAt;
producerCompletedAt = input.now?.() ?? Date.now();
} else {
throw new FabricTaskError("fabric task run missing producer", "harness_failure", "harness");
}
} catch (error) {
const completedAt = input.now?.() ?? Date.now();
usage.elapsedMs = completedAt - startedAt;
usage.inactiveMs = Math.max(0, completedAt - lastActivityAt);
producerTerminationUnconfirmed = isUnconfirmedProducerTermination(error);
if (error instanceof FabricTaskError) {
const failure = failureFromError(error);
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: outcomeFromFailure(failure),
verifier: infrastructureVerifier(verifierDigest, error.code),
failure,
sourceRefs: input.sourceRefs,
}),
};
}
throw error;
}
let patch;
let applied;
try {
patch = parseSyntheticPatchV1(patchRaw);
applied = applySyntheticPatch(scratch.root, patch);
} catch (error) {
const completedAt = input.now?.() ?? Date.now();
usage.elapsedMs = completedAt - startedAt;
usage.inactiveMs = Math.max(0, completedAt - lastActivityAt);
if (error instanceof FabricTaskError) {
const failure = failureFromError(error);
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: outcomeFromFailure(failure),
verifier: infrastructureVerifier(verifierDigest, error.code),
failure,
sourceRefs: input.sourceRefs,
}),
};
}
throw error;
}
usage.outputBytes = applied.bytesWritten;
usage.patchOperations = applied.patchOperations;
usage.filesTouched = applied.filesTouched;
let verifier;
try {
verifier = verifyExactTreeDiffV1(scratch.root);
} catch (error) {
const completedAt = input.now?.() ?? Date.now();
usage.elapsedMs = completedAt - startedAt;
usage.inactiveMs = Math.max(0, completedAt - lastActivityAt);
if (error instanceof FabricTaskError) {
const failure = failureFromError(error);
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: outcomeFromFailure(failure),
verifier: infrastructureVerifier(verifierDigest, error.code),
failure,
sourceRefs: input.sourceRefs,
}),
};
}
throw error;
}
const completedAt = input.now?.() ?? Date.now();
usage.elapsedMs = completedAt - startedAt;
usage.inactiveMs = Math.max(0, completedAt - lastActivityAt);
if (verifier.passed) {
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: "pass",
verifier,
sourceRefs: input.sourceRefs,
}),
};
}
const failure: FailureRecordV1 = {
class: "behavioral_failure",
code: verifier.reason ?? "verifier_failed",
retryable: false,
attribution: "route",
};
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: "fail",
verifier,
failure,
sourceRefs: input.sourceRefs,
}),
};
} catch (error) {
const completedAt = input.now?.() ?? Date.now();
usage.elapsedMs = completedAt - startedAt;
usage.inactiveMs = Math.max(0, completedAt - lastActivityAt);
if (error instanceof FabricTaskError) {
const failure = failureFromError(error);
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: outcomeFromFailure(failure),
verifier: infrastructureVerifier(verifierDigest, error.code),
failure,
sourceRefs: input.sourceRefs,
}),
};
}
const failure: FailureRecordV1 = {
class: "harness_failure",
code: "harness_failure",
retryable: false,
attribution: "harness",
};
return {
executionAuthority: input.executionAuthority,
outcome: sealOutcome({
taskSubject,
subjectId,
fixtureDigest,
verifierDigest,
sandboxDigest,
startedAt,
completedAt,
usage,
outcome: "inconclusive",
verifier: infrastructureVerifier(verifierDigest, "harness_failure"),
failure,
sourceRefs: input.sourceRefs,
}),
};
} finally {
if (scratch) {
if (producerTerminationUnconfirmed) {
// No writes into producer-controlled scratch after uncertain termination.
// Age and later pipe closure cannot prove every descendant has exited.
// Retain the tree, including across parent exit and later task creation.
console.warn("[lab] Producer termination unconfirmed; scratch retained for manual review.");
} else {
scratch.cleanup();
}
}
}
}
function infrastructureVerifier(manifestDigest: string, reason: string): FabricTaskOutcomeV1["verifier"] {
return {
verifierId: FABRIC_VERIFIER_ID,
manifestDigest,
passed: false,
pathSummaries: [],
reason,
};
}
/** Assemble an immutable FabricTaskOutcomeV1 from executor state. */
function sealOutcome(input: {
taskSubject: FabricTaskOutcomeV1["taskSubject"];
subjectId: string;
fixtureDigest: string;
verifierDigest: string;
sandboxDigest: string;
startedAt: number;
completedAt: number;
usage: FabricUsageV1;
outcome: FabricTaskOutcomeV1["outcome"];
verifier: FabricTaskOutcomeV1["verifier"];
failure?: FailureRecordV1;
sourceRefs?: string[];
}): FabricTaskOutcomeV1 {
return {
schemaVersion: 1,
taskClassId: FABRIC_TASK_CLASS_ID,
taskClassVersion: FABRIC_TASK_CLASS_VERSION,
routeSubject: input.taskSubject.routeSubject,
taskSubject: input.taskSubject,
subjectId: input.subjectId,
taskFixtureDigest: input.fixtureDigest,
verifierManifestDigest: input.verifierDigest,
fabricCompatibilityVersion: FABRIC_COMPATIBILITY_VERSION,
sandboxProfileDigest: input.sandboxDigest,
startedAt: input.startedAt,
completedAt: input.completedAt,
limits: { ...FABRIC_LIMITS },
usage: { ...input.usage },
outcome: input.outcome,
verifier: {
...input.verifier,
pathSummaries: [...input.verifier.pathSummaries],
},
...(input.failure ? { failure: { ...input.failure } } : {}),
artifactDigests: [],
...(input.sourceRefs ? { sourceRefs: [...input.sourceRefs] } : {}),
};
}
/** Declared sandbox policy for the frozen scratch producer (not runtime enforcement). */
export function fabricDeclaredSandboxPolicy(): {
network: boolean;
userMcp: boolean;
arbitraryShell: boolean;
userRepository: boolean;
} {
return {
network: SANDBOX_PROFILE_V1.allowNetwork,
userMcp: SANDBOX_PROFILE_V1.allowUserMcp,
arbitraryShell: SANDBOX_PROFILE_V1.allowShell,
userRepository: SANDBOX_PROFILE_V1.allowUserRepository,
};
}
/** @deprecated Use fabricDeclaredSandboxPolicy. */
export const fabricScratchCapabilityProbe = fabricDeclaredSandboxPolicy;