diff --git a/CHANGELOG.md b/CHANGELOG.md index 1ec801e..866630b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Security and behavior changes +## Unreleased — inference diagnostics + +- Preserve correlated per-request primary and cleanup errors, bounded HTTP/SSE metadata and allowlisted transport causes. A consumer closing after a completed SSE response is no longer mislabeled as a provider failure; successful retries clear stale failures. +- Distinguish fixed engine rejection reasons for incomplete/inconclusive results, invalid schema/head, quarantine and truncation. Incomplete reviews still fail CI and publish only a non-approving fallback. +- Add native pinned-Codex Docker regressions for completed-but-open HTTP streams and malformed structured output. No prompts, inference timeouts, context budgets, authorization or review/merge policy change. + ## 0.1.0 — verified PNG input and large-PR context - Verify PNG evidence separately from textual patches and supply immutable base/head images through official Codex localImage inputs. Require image-capable models and actual image transport; independently verify publication evidence. Image findings appear in the summary without invented inline locations. Unsupported formats and incomplete visual coverage remain non-approving. diff --git a/docs/review-rollout.md b/docs/review-rollout.md index 3a67752..b3941b5 100644 --- a/docs/review-rollout.md +++ b/docs/review-rollout.md @@ -74,3 +74,14 @@ After approval, drain existing reviews, deploy the merged Worker source with its 4. Report local/CI validation before deployment. Deploy the reviewed Worker with `TRUSTED_WORKFLOW=OWNER/codexbot/.github/workflows/review.yml@THAT_SAME_SHA`, preserving existing bindings, OAuth gate, secrets and domain settings. Merge the caller PR using normal protection checks. There is no atomic transaction across Cloudflare and GitHub: during the short mismatch window requests fail closed. Do not relax either SHA check to hide it. 5. Read back both actual pins and compare them byte-for-byte. Run the credential-only workflow check under the owning actor/installation Environment. Then request a new advisory/no-merge review for end-to-end broker/provider acceptance. Old Actions review attempts are not rerun to borrow a new credential/pin; use a new authorized comment. 6. Inspect the same progress comment, workflow link, sanitized failures and native review. Provider inference remains a distinct live test with the owner's authorization/allowance, never an API-key fallback. Roll back both pins together on failure; keep additive DB columns. A backend/caller protected-branch or deployment-permission block is a release blocker, not permission to bypass safeguards. + + +## Correlated inference diagnostics + +The credential proxy emits an allowlisted `codexbot_proxy_request` record at request start and finish, with an ordinal (1–101), separate primary/cleanup errors, observed HTTP status/category/body presence, bounded elapsed time/byte/frame counts, SSE terminal state and owned abort origin. No provider IDs, arbitrary headers, exception messages, prompts, code or response bodies enter diagnostics. Diagnostic counts are capped; inference resource budgets are unchanged. + +Only the latest request is authoritative. A started or successful later request clears an older recovered error; late completion of an older request cannot replace it. On failure, the Docker host forwards at most four sanitized failed-request records plus the latest request state to runner logs. It exposes the final safe request state as `proxy_request`, plus independent `proxy_failure` and `proxy_cleanup` when present. Startup failures keep the existing process-level envelope. An HTTP consumer closing after consuming `response.completed` is not itself a provider outage. Premature EOF, stream/frame limits, upstream events/read errors, deadline aborts, downstream disconnections, internal writes and cleanup remain separately diagnosed. + +Engine `rejection_reason` is a fixed enum: `context_incomplete`, `schema_invalid`, `head_mismatch`, `quarantined`, `output_truncated`, `model_incomplete`, `model_inconclusive`, or `output_invalid`. Malformed JSON retains `codex_output_not_json`. These fields explain the existing failure decision; they never authorize approval or merging. Original model text remains private. The historical two production failures cannot be retrospectively classified from their old generic diagnostics. + +The native Docker harness holds valid completed Responses streams open for clean/incomplete fixtures, uses the actual pinned Codex binary and exercises schema/JSON-invalid output. All provider responses are synthetic. The diagnostic rollout needs no D1 migration or new live inference; use the existing closed-merge-gate pin coordination and restore the gate after actual Worker/caller pins agree. Do not initiate a repository review merely to test diagnostics. diff --git a/src/core/diagnostics.ts b/src/core/diagnostics.ts index 1e2d366..779e872 100644 --- a/src/core/diagnostics.ts +++ b/src/core/diagnostics.ts @@ -1,5 +1,5 @@ import { AppError } from './errors.js'; -import { ExecutionError, executionFailure, type ExecutionFailure } from './execution.js'; +import { ExecutionError, executionFailure, proxyRequestDiagnostic, type ProxyRequestDiagnostic, type ExecutionFailure } from './execution.js'; export const REVIEW_STAGES = ['environment','prepare','context','credentials','analyzing','result','publish','release'] as const; export const FAILURE_CODES = new Set(['missing_environment_credentials','ambiguous_environment_credentials','credential_owner_mismatch','missing_read_token', @@ -30,15 +30,16 @@ github_actions_oidc_unavailable invalid_oidc_endpoint github_oidc_request_failed export class BrokerError extends AppError { constructor(public readonly operation: string, status: number, public readonly remoteCode: string | null) { super(`broker_${operation}_failed`, status); } } -export function diagnostic(error: unknown, stage: string): { event: string; stage: string; code: string; status?: number; broker_code?: string; execution?: ExecutionFailure; proxy_failure?: ExecutionFailure } { +export function diagnostic(error: unknown, stage: string): { event: string; stage: string; code: string; status?: number; broker_code?: string; execution?: ExecutionFailure; proxy_failure?: ExecutionFailure; proxy_cleanup?: ExecutionFailure; proxy_request?: Omit } { const result: ReturnType = { event: 'review_failed', stage: REVIEW_STAGES.includes(stage as typeof REVIEW_STAGES[number]) ? stage : 'environment', code: 'external_or_execution_failure' }; if (error instanceof ExecutionError) { result.code = error.code; result.execution = executionFailure(error.detail)!; - const proxy = executionFailure(error.proxyFailure); - if (proxy) result.proxy_failure = proxy; + const request=proxyRequestDiagnostic(error.proxyRequest); + if(request){const {primary,cleanup,...state}=request;result.proxy_request=state;if(primary)result.proxy_failure=primary;if(cleanup)result.proxy_cleanup=cleanup;} + else {const proxy=executionFailure(error.proxyFailure),cleanup=executionFailure(error.proxyCleanup);if(proxy)result.proxy_failure=proxy;if(cleanup)result.proxy_cleanup=cleanup;} return result; } if (error instanceof BrokerError && OPERATIONS.has(error.operation)) { diff --git a/src/core/execution.ts b/src/core/execution.ts index 5b6a2f5..6a8185b 100644 --- a/src/core/execution.ts +++ b/src/core/execution.ts @@ -7,7 +7,7 @@ proxy_start_failed proxy_startup_failed proxy_route_denied proxy_body_too_large proxy_requires_private_streaming_request proxy_requires_explicit_input_array proxy_invalid_client_metadata proxy_invalid_tool_list proxy_hosted_tools_denied proxy_hosted_tool_choice_denied proxy_invalid_tool_choice proxy_acceptance_input_budget proxy_model_or_effort_change_denied proxy_request_limit proxy_concurrent_request_denied proxy_transport_failed -provider_http_failed provider_stream_failed provider_stream_content_type_invalid provider_stream_truncated provider_stream_limit +proxy_pipeline_failed proxy_client_disconnected proxy_deadline_exceeded proxy_stream_cleanup_failed provider_stream_read_failed provider_http_failed provider_stream_failed provider_stream_content_type_invalid provider_stream_truncated provider_stream_limit provider_frame_limit invalid_provider_event provider_event_type_missing provider_credential_echo provider_stream_incomplete codex_process_failed codex_process_exited codex_rpc_message_too_large codex_rpc_rejected invalid_codex_protocol image_context_invalid image_context_limit configured_model_does_not_support_images proxy_unsupported_media_input proxy_image_source_denied proxy_image_inputs_missing configured_model_not_in_codex_catalog effort_not_supported_by_selected_model codex_invalid_model_catalog codex_invalid_model_cursor @@ -22,13 +22,48 @@ const PROVIDER_PARAMS = new Set(['model', 'reasoning.effort', 'tools', 'tool_cho const METHODS = new Set(['initialize', 'model/list', 'thread/start', 'turn/start']); const SIGNALS = new Set(['SIGKILL', 'SIGTERM', 'SIGABRT', 'SIGSEGV', 'SIGINT']); const CONTENT_TYPES = new Set(['event-stream', 'json', 'html', 'missing', 'other']); -export interface ExecutionFailure { +export type TerminalEvent = 'none' | 'completed' | 'failed' | 'incomplete' | 'error'; +const ORIGINS = new Set(['validation','transport','upstream_event','upstream_read','framing','limit','deadline','downstream','pipeline','cleanup']); +const TRANSPORT_CODES = new Set(['ECONNRESET','ECONNREFUSED','ENOTFOUND','EPIPE','ETIMEDOUT','UND_ERR_SOCKET','UND_ERR_BODY_TIMEOUT','UND_ERR_HEADERS_TIMEOUT','ABORT_ERR','TIMEOUT_ERR','ERR_STREAM_PREMATURE_CLOSE','ERR_STREAM_DESTROYED','ERR_STREAM_WRITE_AFTER_END']); +const REJECTION_REASONS = ['context_incomplete','schema_invalid','head_mismatch','quarantined','output_truncated','model_incomplete','model_inconclusive','output_invalid'] as const; +export type EngineRejectionReason = typeof REJECTION_REASONS[number]; +const REJECTIONS = new Set(REJECTION_REASONS); +interface RequestMetadata { + request_index?: number; elapsed_ms?: number; stream_bytes?: number; stream_frames?: number; terminal_event?: TerminalEvent; + upstream_status?: number; content_type_category?: string; body_present?: boolean; abort_origin?: 'none' | 'deadline' | 'downstream' | 'pipeline'; +} +export interface ProxyRequestDiagnostic extends RequestMetadata { request_index: number; phase: 'started' | 'finished'; primary: ExecutionFailure | null; cleanup: ExecutionFailure | null } +export interface ExecutionFailure extends RequestMetadata { component: string; code: string; exit_code?: number; signal?: string; rpc_code?: number; rpc_method?: string; - upstream_status?: number; content_type_category?: string; body_present?: boolean; provider_code?: string; provider_param?: string; + provider_code?: string; provider_param?: string; origin?: string; transport_code?: string; rejection_reason?: EngineRejectionReason; } function object(value: unknown): Record { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record : {}; } +function projectRequestMetadata(source: Record, result: RequestMetadata): void { + for (const [key, maximum] of [['request_index',101],['elapsed_ms',1_320_000],['stream_bytes',20_000_001],['stream_frames',1_000_000],['upstream_status',599]] as const) { + const value=source[key]; if(typeof value==='number'&&Number.isInteger(value)&&value>=(key==='request_index'?1:key==='upstream_status'?200:0)&&value<=maximum)result[key]=value; + } + if(typeof source.content_type_category==='string'&&CONTENT_TYPES.has(source.content_type_category))result.content_type_category=source.content_type_category; + if(typeof source.body_present==='boolean')result.body_present=source.body_present; + if(typeof source.terminal_event==='string'&&['none','completed','failed','incomplete','error'].includes(source.terminal_event))result.terminal_event=source.terminal_event as TerminalEvent; + if(typeof source.abort_origin==='string'&&['none','deadline','downstream','pipeline'].includes(source.abort_origin))result.abort_origin=source.abort_origin as NonNullable; +} +/** Only exact machine codes leave the exception chain; never messages or arbitrary names. */ +export function transportCode(error: unknown): string | undefined { + for(let depth=0;depth<4;depth++) {const value=object(error);if(typeof value.code==='string'&&TRANSPORT_CODES.has(value.code))return value.code; if(value.name==='AbortError')return 'ABORT_ERR';if(value.name==='TimeoutError')return 'TIMEOUT_ERR';error=value.cause;} +} +export function proxyRequestDiagnostic(value: unknown): ProxyRequestDiagnostic | null { + const source=object(value);if(source.phase!=='started'&&source.phase!=='finished')return null; + const result:ProxyRequestDiagnostic={request_index:0,phase:source.phase,primary:executionFailure(source.primary),cleanup:executionFailure(source.cleanup)}; + projectRequestMetadata(source,result);if(!result.request_index)return null; + if((source.primary!==null&&!result.primary)||(source.cleanup!==null&&!result.cleanup))return null; + if([result.primary,result.cleanup].some(detail=>detail&&!['proxy','provider'].includes(detail.component)))return null; + if([result.primary,result.cleanup].some(detail=>detail?.request_index!==undefined&&detail.request_index!==result.request_index))return null; + if(result.phase==='started'&&(result.primary||result.cleanup))return null; + return result; +} +export function proxyRequestEnvelope(value: ProxyRequestDiagnostic): string {return JSON.stringify({event:'codexbot_proxy_request',...proxyRequestDiagnostic(value)});} export function executionFailure(value: unknown): ExecutionFailure | null { const source = object(value); const { component, code } = source; @@ -38,10 +73,11 @@ export function executionFailure(value: unknown): ExecutionFailure | null { if (typeof source.signal === 'string' && SIGNALS.has(source.signal)) result.signal = source.signal; if (typeof source.rpc_method === 'string' && METHODS.has(source.rpc_method)) result.rpc_method = source.rpc_method; if (Number.isInteger(source.rpc_code) && Number(source.rpc_code) >= -32768 && Number(source.rpc_code) <= -32000) result.rpc_code = Number(source.rpc_code); + if(typeof source.rejection_reason==='string'&&component==='engine'&&REJECTIONS.has(source.rejection_reason))result.rejection_reason=source.rejection_reason as EngineRejectionReason; + if((component==='proxy'||component==='provider')&&typeof source.origin==='string'&&ORIGINS.has(source.origin))result.origin=source.origin; + if((component==='proxy'||component==='provider')&&typeof source.transport_code==='string'&&TRANSPORT_CODES.has(source.transport_code))result.transport_code=source.transport_code; + if(component==='proxy'||component==='provider')projectRequestMetadata(source,result); if (component === 'provider') { - if (Number.isInteger(source.upstream_status) && Number(source.upstream_status) >= 200 && Number(source.upstream_status) <= 599) result.upstream_status = Number(source.upstream_status); - if (typeof source.content_type_category === 'string' && CONTENT_TYPES.has(source.content_type_category)) result.content_type_category = source.content_type_category; - if (typeof source.body_present === 'boolean') result.body_present = source.body_present; if (typeof source.provider_code === 'string' && PROVIDER_CODES.has(source.provider_code)) result.provider_code = source.provider_code; if (typeof source.provider_param === 'string' && PROVIDER_PARAMS.has(source.provider_param)) result.provider_param = source.provider_param; } @@ -50,6 +86,8 @@ export function executionFailure(value: unknown): ExecutionFailure | null { export class ExecutionError extends AppError { readonly detail: ExecutionFailure; proxyFailure?: ExecutionFailure; + proxyCleanup?: ExecutionFailure; + proxyRequest?: ProxyRequestDiagnostic; constructor(detail: ExecutionFailure) { const safe = executionFailure(detail) ?? { component: 'engine', code: 'engine_failed' }; super('isolated_review_failed'); this.detail = safe; @@ -67,13 +105,16 @@ export class ExecutionDiagnostics { private dropping = false; private bytes = 0; last: ExecutionFailure | null = null; + request: ProxyRequestDiagnostic | null = null; + history: ProxyRequestDiagnostic[] = []; write(chunk: string): void { this.bytes += Buffer.byteLength(chunk); if (this.bytes > 64_000) return; for (const part of chunk.split(/(\n)/)) { if (part === '\n') { if (!this.dropping) { - try { const value = object(JSON.parse(this.line)); if (value.event === 'codexbot_execution_failure') this.last = executionFailure(value) ?? this.last; } catch { /* Untrusted stderr is never forwarded. */ } + try { const value = object(JSON.parse(this.line)); if (value.event === 'codexbot_execution_failure') this.last = executionFailure(value) ?? this.last; + if(value.event==='codexbot_proxy_request'){const request=proxyRequestDiagnostic(value);if(request){if(request.phase==='finished'&&(request.primary||request.cleanup))this.history=[...this.history.filter(x=>x.request_index!==request.request_index),request].slice(-4);if(request.request_index>=(this.request?.request_index??0)){this.request=request;this.last=request.primary;}}} } catch { /* Untrusted stderr is never forwarded. */ } } this.line = ''; this.dropping = false; } else if (!this.dropping) { diff --git a/src/core/review.ts b/src/core/review.ts index ae092a1..e578152 100644 --- a/src/core/review.ts +++ b/src/core/review.ts @@ -46,14 +46,17 @@ const validate = new Ajv().compile({ ...REVIEW_SCHEMA, properties: { ... output_truncated: { type: 'boolean' }, quarantined: { type: 'boolean' } } }); /** Applied before transport, persistence and publication. No suspicious source text escapes. */ -export function normalizeReview(value: unknown, head: string): Review { +export type ReviewRejectionReason = 'schema_invalid' | 'head_mismatch' | 'quarantined' | 'output_truncated'; +export function normalizeReview(value: unknown, head: string, onReject: (reason: ReviewRejectionReason) => void = () => {}): Review { const fallback = failedReview(head); - if (scanSecrets(value).length) return { ...fallback, quarantined: true }; - if (!validate(value) || value.head_sha !== head) return fallback; + if (scanSecrets(value).length) {onReject('quarantined');return { ...fallback, quarantined: true };} + if (!validate(value)) {onReject('schema_invalid');return fallback;} + if (value.head_sha !== head) {onReject('head_mismatch');return fallback;} const review = structuredClone(value); const size = () => Buffer.byteLength(JSON.stringify(review)); - if (size() > MAX_RAW_REVIEW_BYTES) return { ...fallback, output_truncated: true }; + if (size() > MAX_RAW_REVIEW_BYTES) {onReject('output_truncated');return { ...fallback, output_truncated: true };} if (size() > MAX_REVIEW_BYTES) { + onReject('output_truncated'); // Retain severity, confidence and locations. Any information loss disables approval. review.complete = false; review.output_truncated = true; const shorten = (text: string, bytes: number) => { @@ -65,7 +68,8 @@ export function normalizeReview(value: unknown, head: string): Review { } if (review.result === 'clean') review.result = 'inconclusive'; } - return size() <= MAX_REVIEW_BYTES ? review : { ...fallback, output_truncated: true }; + if(size()<=MAX_REVIEW_BYTES)return review; + onReject('output_truncated');return { ...fallback, output_truncated: true }; } export function safePath(path: string): boolean { diff --git a/src/runner/docker.ts b/src/runner/docker.ts index 1afb914..0a9e239 100644 --- a/src/runner/docker.ts +++ b/src/runner/docker.ts @@ -1,7 +1,7 @@ import { spawn } from 'node:child_process'; import { requireCondition } from '../core/errors.js'; import type { InferenceLimits } from './proxy.js'; -import { ExecutionDiagnostics, ExecutionError, executionError, executionFailure } from '../core/execution.js'; +import { ExecutionDiagnostics, ExecutionError, executionError, executionFailure, proxyRequestEnvelope } from '../core/execution.js'; export async function docker(args: string[], maxBytes = 100_000, diagnostics = new ExecutionDiagnostics()): Promise { const child = spawn('docker', args, { stdio: ['ignore', 'pipe', 'pipe'] }); @@ -66,7 +66,10 @@ export async function isolatedReview(image: string, directory: string, credentia // Only this run's credential proxy can report an actual upstream HTTP status. const observed = new ExecutionDiagnostics(); try { observed.write(await docker(['logs', '--tail', '32', proxy], 64_000, observed)); } catch { /* The primary failure remains authoritative when logs are unavailable. */ } - if (observed.last) failure.proxyFailure = observed.last; + for(const request of observed.history)console.error(proxyRequestEnvelope(request)); + if(observed.request&&!observed.history.some(x=>x.request_index===observed.request!.request_index))console.error(proxyRequestEnvelope(observed.request)); + if (observed.request) { failure.proxyRequest=observed.request;if(observed.request.primary)failure.proxyFailure=observed.request.primary;if(observed.request.cleanup)failure.proxyCleanup=observed.request.cleanup; } + else if (observed.last) failure.proxyFailure = observed.last; primary = failure; } finally { try { await cleanupReviewContainers(id); } diff --git a/src/runner/engine-main.ts b/src/runner/engine-main.ts index a186e04..d859642 100644 --- a/src/runner/engine-main.ts +++ b/src/runner/engine-main.ts @@ -4,20 +4,21 @@ import type { RequestSnapshot } from '../worker/store.js'; import { readFile, mkdir } from 'node:fs/promises'; import { once } from 'node:events'; import { createSocketRelay } from './relay.js'; -import { executionEnvelope, executionError } from '../core/execution.js'; -import { normalizeReview, validateReview, type ChangedFile } from '../core/review.js'; -import { AppError, record, requireCondition } from '../core/errors.js'; +import { ExecutionError, executionEnvelope, executionError } from '../core/execution.js'; +import { normalizeReview, validateReview, type ChangedFile, type ReviewRejectionReason } from '../core/review.js'; +import { record } from '../core/errors.js'; const relay = createSocketRelay('/run/proxy/inference.sock'); try { await mkdir('/home/codex/.codex', { mode: 0o700 }); relay.listen(8080, '127.0.0.1'); await once(relay, 'listening'); const snapshot = JSON.parse(await readFile('/workspace/request.json', 'utf8')) as RequestSnapshot; const manifest = await readFile('/workspace/manifest.json', 'utf8'); - requireCondition(record(JSON.parse(manifest) as unknown).complete === true, 'review_incomplete'); - const output = normalizeReview(await runCodex(snapshot, manifest), snapshot.head); + if(record(JSON.parse(manifest) as unknown).complete!==true)throw new ExecutionError({component:'engine',code:'review_incomplete',rejection_reason:'context_incomplete'}); + let rejection: ReviewRejectionReason | undefined; + const output = normalizeReview(await runCodex(snapshot, manifest), snapshot.head,reason=>{rejection=reason;}); try { validateReview(output, snapshot.head, JSON.parse(await readFile('/workspace/diff.json', 'utf8')) as ChangedFile[],binaryLocations((record(JSON.parse(manifest) as unknown).binaryFiles??[]) as BinaryChange[])); } - catch { throw new AppError('review_output_invalid'); } - requireCondition(output.complete && output.result !== 'inconclusive' && !output.quarantined && !output.output_truncated, 'review_incomplete'); + catch { throw new ExecutionError({component:'engine',code:'review_output_invalid',rejection_reason:'output_invalid'}); } + if(!(output.complete&&output.result!=='inconclusive'&&!output.quarantined&&!output.output_truncated))throw new ExecutionError({component:'engine',code:'review_incomplete',rejection_reason:rejection??(output.quarantined?'quarantined':output.output_truncated?'output_truncated':!output.complete?'model_incomplete':'model_inconclusive')}); process.stdout.write(JSON.stringify(output)); } catch (error) { process.stderr.write(`${executionEnvelope(executionError(error, 'engine', 'engine_failed').detail)}\n`); process.exitCode = 1; } finally { relay.closeAllConnections(); relay.close(); } diff --git a/src/runner/proxy-main.ts b/src/runner/proxy-main.ts index 063f7b3..598c10a 100644 --- a/src/runner/proxy-main.ts +++ b/src/runner/proxy-main.ts @@ -1,13 +1,13 @@ import { readFile } from 'node:fs/promises'; import { createInferenceServer } from './proxy.js'; import type { InferenceLimits } from './proxy.js'; -import { executionEnvelope } from '../core/execution.js'; +import { executionEnvelope, proxyRequestEnvelope } from '../core/execution.js'; const report = (failure: Parameters[0]) => process.stderr.write(`${executionEnvelope(failure)}\n`); try { const token = (await readFile('/run/credential', 'utf8')).trim(); if (!token || /[\r\n]/.test(token)) throw new Error('invalid_credential'); process.umask(0o077); const limits = JSON.parse(process.env.CODEXBOT_ACCEPTANCE_LIMITS ?? '{}') as InferenceLimits; - createInferenceServer(token, limits, report).on('error', () => { report({ component: 'proxy', code: 'proxy_startup_failed' }); process.exitCode = 1; }) + createInferenceServer(token, limits, report, value => process.stderr.write(proxyRequestEnvelope(value)+'\n')).on('error', () => { report({ component: 'proxy', code: 'proxy_startup_failed' }); process.exitCode = 1; }) .listen('/run/proxy/inference.sock', () => process.stdout.write('codexbot-proxy-ready\n')); } catch { report({ component: 'proxy', code: 'proxy_startup_failed' }); process.exitCode = 1; } diff --git a/src/runner/proxy.ts b/src/runner/proxy.ts index 1619cc7..b359562 100644 --- a/src/runner/proxy.ts +++ b/src/runner/proxy.ts @@ -2,9 +2,9 @@ import { createServer } from 'node:http'; import type { IncomingMessage, ServerResponse } from 'node:http'; import { Readable } from 'node:stream'; import { pipeline } from 'node:stream/promises'; -import { safeEvents } from './stream.js'; +import { safeEvents, type StreamProgress } from './stream.js'; import { record, requireCondition } from '../core/errors.js'; -import { executionError, providerFailure, type ExecutionFailure } from '../core/execution.js'; +import { executionError, providerFailure, transportCode, type ExecutionFailure, type ProxyRequestDiagnostic } from '../core/execution.js'; // client_metadata is emitted by pinned Codex's Responses transport (core/src/responses_metadata.rs). const RESPONSE_FIELDS = new Set(['model', 'instructions', 'input', 'tools', 'tool_choice', 'parallel_tool_calls', 'reasoning', 'store', 'stream', 'include', 'service_tier', 'prompt_cache_key', 'text', 'context_management', 'stream_options', 'client_metadata']); function checkTools(tools: unknown, depth = 0): void { @@ -74,11 +74,24 @@ export function inspectMedia(value:unknown,depth=0):number { return Object.values(item).reduce((count,item)=>count+inspectMedia(item,depth+1),0); } -export async function inferenceProxy(request: IncomingMessage, response: ServerResponse, token: string, fetcher: typeof fetch = fetch, enforceSelection: (body: Record) => void = () => {}, report: (failure: ExecutionFailure) => void = () => {}): Promise { - const disconnected = new AbortController(); - let stage: 'validation' | 'transport' | 'stream' = 'validation'; - response.once('close', () => disconnected.abort()); +export async function inferenceProxy(request: IncomingMessage, response: ServerResponse, token: string, fetcher: typeof fetch = fetch, enforceSelection: (body: Record) => void = () => {}, report: (failure: ExecutionFailure) => void = () => {}, onRequest?: (value: ProxyRequestDiagnostic) => void, requestIndex = 1): Promise { + const disconnected = new AbortController(), started = Date.now(); + const progress: StreamProgress = { bytes: 0, frames: 0, terminal: 'none' }; + let stage: 'validation' | 'transport' | 'stream' = 'validation', deadline: AbortSignal | undefined; + let primary: ExecutionFailure | null = null, cleanup: ExecutionFailure | null = null, localPipeline = false; + let metadata: Pick = {}; + const recordFailure = (detail: ExecutionFailure) => { + if(detail.origin==='cleanup'){cleanup??=detail;return;} + if(detail.origin==='upstream_read'&&(deadline?.aborted||disconnected.signal.aborted)) { + const origin=deadline?.aborted?'deadline':localPipeline?'pipeline':'downstream'; + const local=transportCode(response.errored); + primary??=localPipeline&&!deadline?.aborted?{component:'proxy',code:'proxy_pipeline_failed',origin,...(local?{transport_code:local}:{})}:{...detail,component:'proxy',code:origin==='deadline'?'proxy_deadline_exceeded':'proxy_client_disconnected',origin}; + } else primary??=detail; + }; + const consumerCompleted = () => disconnected.signal.aborted && !localPipeline && !deadline?.aborted && progress.terminal==='completed' && primary===null; + response.once('close', () => { if(!response.writableFinished){localPipeline=response.errored!==null&&response.errored!==undefined&&!['ECONNRESET','EPIPE','ERR_STREAM_PREMATURE_CLOSE'].includes(transportCode(response.errored)??'');disconnected.abort();} }); try { + onRequest?.({request_index:requestIndex,phase:'started',primary:null,cleanup:null}); requireCondition(request.method === 'POST' && request.url === '/v1/responses', 'proxy_route_denied', 403); const chunks: Buffer[] = []; let bytes = 0; for await (const chunk of request) { @@ -87,7 +100,7 @@ export async function inferenceProxy(request: IncomingMessage, response: ServerR } let decoded: unknown; try { decoded = JSON.parse(Buffer.concat(chunks).toString('utf8')) as unknown; } - catch { report({ component: 'proxy', code: 'proxy_invalid_json' }); response.writeHead(403); response.end(); return; } + catch { recordFailure({ component: 'proxy', code: 'proxy_invalid_json' }); response.writeHead(403); response.end(); return; } const body = record(decoded); requireCondition(Object.keys(body).every(key => RESPONSE_FIELDS.has(key)), 'proxy_unsupported_request_field'); requireCondition(body.store === false && body.stream === true && typeof body.model === 'string', 'proxy_requires_private_streaming_request'); @@ -107,34 +120,43 @@ export async function inferenceProxy(request: IncomingMessage, response: ServerR inspectMedia(body.input); enforceSelection(body); stage = 'transport'; + deadline = AbortSignal.timeout(20 * 60_000); const upstream = await fetcher('https://api.openai.com/v1/responses', { - method: 'POST', headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'User-Agent': 'CodexBot/0.1.0', + method: 'POST', headers: { Authorization: 'Bearer '+token, 'Content-Type': 'application/json', 'User-Agent': 'CodexBot/0.1.0', ...(typeof request.headers['originator'] === 'string' && request.headers['originator'] === 'CodexBot' ? { originator: 'CodexBot' } : {}) }, - body: JSON.stringify(body), redirect: 'error', signal: AbortSignal.any([AbortSignal.timeout(20 * 60_000), disconnected.signal]) + body: JSON.stringify(body), redirect: 'error', signal: AbortSignal.any([deadline, disconnected.signal]) }); - const metadata = { upstream_status: upstream.status, content_type_category: contentTypeCategory(upstream.headers.get('content-type')), body_present: upstream.body !== null }; - // A documented Codex SSE success can omit Content-Type. In that one case, -// require an SSE-looking prefix before handing the unmodified stream to -// safeEvents, which enforces bounded frames and terminal response.completed. -// Never accept JSON/HTML/other explicit media types as streaming responses. - const headerlessSse = upstream.ok && upstream.body && metadata.content_type_category === 'missing' - ? await hasEventStreamPrefix(upstream) : false; + metadata = { upstream_status: upstream.status, content_type_category: contentTypeCategory(upstream.headers.get('content-type')), body_present: upstream.body !== null }; + // Headerless success still requires SSE framing and a terminal response.completed event. + const headerlessSse = upstream.ok && upstream.body && metadata.content_type_category === 'missing' ? await hasEventStreamPrefix(upstream) : false; if (!upstream.ok || !upstream.body || (metadata.content_type_category !== 'event-stream' && !headerlessSse)) { - report({ ...await responseFailure(upstream), ...metadata, code: upstream.ok ? 'provider_stream_content_type_invalid' : 'provider_http_failed' }); + recordFailure({ ...await responseFailure(upstream), code: upstream.ok ? 'provider_stream_content_type_invalid' : 'provider_http_failed', origin: 'transport' }); response.writeHead(upstream.ok ? 403 : upstream.status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); response.end(upstream.ok ? '{"error":"inference_proxy_denied_or_unavailable"}' : '{"error":{"message":"OpenAI inference unavailable; check authentication, entitlement or usage allowance.","type":"codexbot_inference_error"}}'); return; } stage = 'stream'; response.writeHead(upstream.status, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-store' }); - await pipeline(Readable.from(safeEvents(upstream.body, token, failure => report({ ...failure, ...metadata }))), response); + await pipeline(Readable.from(safeEvents(upstream.body, token, recordFailure, progress, consumerCompleted)), response); } catch (error) { - report(executionError(error, stage === 'stream' ? 'provider' : 'proxy', stage === 'transport' ? 'proxy_transport_failed' : stage === 'stream' ? 'provider_stream_failed' : 'proxy_invalid_json').detail); - if (!response.headersSent) response.writeHead(403, { 'Content-Type': 'application/json' }); response.end('{"error":"inference_proxy_denied_or_unavailable"}'); + if(!consumerCompleted()) { + const abort = deadline?.aborted ? 'deadline' : localPipeline ? 'pipeline' : disconnected.signal.aborted ? 'downstream' : null; + const detail = abort ? {component:'proxy',code:abort==='deadline'?'proxy_deadline_exceeded':abort==='pipeline'?'proxy_pipeline_failed':'proxy_client_disconnected'} + : executionError(error, 'proxy', stage==='stream'?'proxy_pipeline_failed':stage==='transport'?'proxy_transport_failed':'proxy_invalid_json').detail; + const transport=transportCode(error); + const observed: ExecutionFailure = { ...detail, origin: abort ?? (stage==='stream'?'pipeline':stage), ...(transport?{transport_code:transport}:{}) }; + // A downstream/pipeline consequence never replaces an already diagnosed upstream failure. + if(primary)cleanup??=observed;else primary=observed; + } + if(!response.destroyed&&!response.writableEnded){if(!response.headersSent)response.writeHead(403, { 'Content-Type': 'application/json' });response.end('{"error":"inference_proxy_denied_or_unavailable"}');} + } finally { + const fields = { ...metadata, request_index: requestIndex, elapsed_ms: Math.min(1_320_000,Math.max(0,Date.now()-started)), stream_bytes: progress.bytes, stream_frames: progress.frames, terminal_event: progress.terminal, abort_origin: deadline?.aborted ? 'deadline' as const : localPipeline ? 'pipeline' as const : disconnected.signal.aborted ? 'downstream' as const : 'none' as const }; + const value: ProxyRequestDiagnostic = { ...fields, phase:'finished', primary: primary ? { ...primary, ...fields } : null, cleanup: cleanup ? { ...cleanup, ...fields } : null }; + if(onRequest)onRequest(value);else {if(value.primary)report(value.primary);if(value.cleanup)report(value.cleanup);} } } export interface InferenceLimits { maxRequests?: number; maxOutputTokens?: number; maxInputBytes?: number; minimumImages?:number } -export function createInferenceServer(token: string, limits: InferenceLimits = {}, report: (failure: ExecutionFailure) => void = () => {}) { +export function createInferenceServer(token: string, limits: InferenceLimits = {}, report: (failure: ExecutionFailure) => void = () => {}, onRequest?: (value: ProxyRequestDiagnostic) => void) { requireCondition(Number.isInteger(limits.maxRequests ?? 100) && (limits.maxRequests ?? 100) >= 1 && (limits.maxRequests ?? 100) <= 100, 'invalid_proxy_request_limit'); if (limits.maxOutputTokens !== undefined) requireCondition(Number.isInteger(limits.maxOutputTokens) && limits.maxOutputTokens >= 1 && limits.maxOutputTokens <= 2048, 'invalid_acceptance_token_limit'); requireCondition(Number.isInteger(limits.minimumImages??0)&&(limits.minimumImages??0)>=0&&(limits.minimumImages??0)<=16,'invalid_proxy_image_limit'); @@ -152,9 +174,11 @@ export function createInferenceServer(token: string, limits: InferenceLimits = { requireCondition(selection === next, 'proxy_model_or_effort_change_denied'); }; return createServer((request, response) => { - if (++requests > (limits.maxRequests ?? 100)) { report({ component: 'proxy', code: 'proxy_request_limit' }); response.writeHead(429); response.end(); return; } - if (active) { report({ component: 'proxy', code: 'proxy_concurrent_request_denied' }); response.writeHead(429); response.end(); return; } + const index=Math.min(++requests,101); + const denied=(code:string)=>{const primary:ExecutionFailure={component:'proxy',code,origin:'validation',request_index:index};if(onRequest)onRequest({request_index:index,phase:'finished',primary,cleanup:null});else report(primary);response.writeHead(429);response.end();}; + if (requests > (limits.maxRequests ?? 100)) { denied('proxy_request_limit'); return; } + if (active) { denied('proxy_concurrent_request_denied'); return; } active = true; - void inferenceProxy(request, response, token, fetch, enforceSelection, report).then(() => { active = false; }, () => { active = false; response.destroy(); }); + void inferenceProxy(request, response, token, fetch, enforceSelection, report, onRequest, index).then(() => { active = false; }, () => { active = false; response.destroy(); }); }); } diff --git a/src/runner/stream.ts b/src/runner/stream.ts index c6e8ea2..793c567 100644 --- a/src/runner/stream.ts +++ b/src/runner/stream.ts @@ -1,24 +1,29 @@ import { requireCondition } from '../core/errors.js'; -import { executionError, providerFailure, type ExecutionFailure } from '../core/execution.js'; +import { executionError, providerFailure, transportCode, type ExecutionFailure, type TerminalEvent } from '../core/execution.js'; const FAILURE = 'data: {"type":"error","code":"codexbot_inference_error","message":"OpenAI inference unavailable; check credentials, entitlement and usage allowance.","param":null}\n\n'; +export interface StreamProgress { bytes: number; frames: number; terminal: TerminalEvent } /** Responses SSE framing only; never expose provider error text or an injected credential. */ -export async function* safeEvents(body: ReadableStream, credential: string, report: (failure: ExecutionFailure) => void = () => {}): AsyncGenerator { +export async function* safeEvents(body: ReadableStream, credential: string, report: (failure: ExecutionFailure) => void = () => {}, progress: StreamProgress = { bytes: 0, frames: 0, terminal: 'none' }, consumerCompleted: () => boolean = () => false): AsyncGenerator { const reader = body.getReader(), decoder = new TextDecoder('utf-8', { fatal: true }); - let buffer = '', bytes = 0, completed = false; + let buffer = '', bytes = 0, completed = false, phase: 'upstream_read' | 'framing' = 'upstream_read'; try { for (;;) { + phase = 'upstream_read'; const chunk = await reader.read(); + phase = 'framing'; if (chunk.done) { buffer += decoder.decode(); requireCondition(buffer.trim().length === 0, 'provider_stream_truncated'); requireCondition(completed, 'provider_stream_incomplete'); break; } - bytes += chunk.value.length; requireCondition(bytes <= 20_000_000, 'provider_stream_limit'); + bytes += chunk.value.length; progress.bytes = Math.min(bytes, 20_000_001); + requireCondition(bytes <= 20_000_000, 'provider_stream_limit'); buffer += decoder.decode(chunk.value, { stream: true }); requireCondition(buffer.length <= 4_000_000, 'provider_frame_limit'); for (;;) { const boundary = /\r?\n\r?\n/.exec(buffer); if (!boundary || boundary.index === undefined) break; const frame = buffer.slice(0, boundary.index); buffer = buffer.slice(boundary.index + boundary[0].length); + progress.frames = Math.min(progress.frames + 1, 1_000_000); const data = frame.split(/\r?\n/).filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n'); if (!data) continue; // Drop comments/unknown side-channel fields. if (data === '[DONE]') { requireCondition(completed, 'provider_stream_incomplete'); yield 'data: [DONE]\n\n'; continue; } @@ -28,13 +33,25 @@ export async function* safeEvents(body: ReadableStream, credential: requireCondition(typeof value.type === 'string', 'provider_event_type_missing'); const response = value.response && typeof value.response === 'object' ? value.response as Record : null; if (data.includes(credential) || value.type === 'error' || value.type === 'response.failed' || value.type === 'response.incomplete' || value.error || response?.error || /^event:\s*error\s*$/m.test(frame)) { - report(data.includes(credential) ? { component: 'provider', code: 'provider_credential_echo' } : value.type === 'response.incomplete' ? { component: 'provider', code: 'provider_stream_incomplete' } : providerFailure(value)); + progress.terminal = value.type === 'response.incomplete' ? 'incomplete' : value.type === 'response.failed' ? 'failed' : 'error'; + report({ ...(data.includes(credential) ? { component: 'provider', code: 'provider_credential_echo' } : value.type === 'response.incomplete' ? { component: 'provider', code: 'provider_stream_incomplete' } : providerFailure(value)), origin: 'upstream_event' }); yield FAILURE; return; } - if (value.type === 'response.completed') completed = true; + if (value.type === 'response.completed') { completed = true; progress.terminal = 'completed'; } yield `data: ${JSON.stringify(event)}\n\n`; } } - } catch (error) { report(executionError(error, 'provider', 'invalid_provider_event').detail); yield FAILURE; } - finally { try { await reader.cancel(); } finally { reader.releaseLock(); } } + } catch (error) { + // Codex may close HTTP after consuming the terminal SSE event; nothing remains to deliver. + if (!consumerCompleted()) { + const detail = executionError(error, 'provider', phase === 'upstream_read' ? 'provider_stream_read_failed' : 'invalid_provider_event').detail; + const transport = transportCode(error); + report({ ...detail, origin: ['provider_stream_limit','provider_frame_limit'].includes(detail.code) ? 'limit' : phase, ...(transport?{transport_code:transport}:{}) }); + yield FAILURE; + } + } finally { + const cleanupFailure=(error:unknown)=>{const transport=transportCode(error);if(!consumerCompleted())report({component:'proxy',code:'proxy_stream_cleanup_failed',origin:'cleanup',...(transport?{transport_code:transport}:{})});}; + try { await reader.cancel(); } catch(error) { cleanupFailure(error); } + finally { try { reader.releaseLock(); } catch(error) { cleanupFailure(error); } } + } } diff --git a/tests/backend.test.ts b/tests/backend.test.ts index da92a74..3341da1 100644 --- a/tests/backend.test.ts +++ b/tests/backend.test.ts @@ -11,7 +11,7 @@ await test('hosted config, manifest and generated callers agree on Workers.dev w assert.equal(DEFAULT_BACKEND, 'https://codexbot.appsolves.workers.dev'); const config = JSON.parse(await readFile('wrangler.jsonc', 'utf8')); assert.equal(config.name, 'codexbot'); assert.equal(config.workers_dev, true); assert.equal(config.preview_urls, false); - assert.equal(config.vars.PUBLIC_URL, DEFAULT_BACKEND); assert.equal(config.vars.MERGE_DEPLOYMENT_AUTHORIZED, 'true'); + assert.equal(config.vars.PUBLIC_URL, DEFAULT_BACKEND); assert.equal(config.vars.MERGE_DEPLOYMENT_AUTHORIZED, 'false'); assert.equal(config.vars.TRUSTED_WORKFLOW, 'AppSolves/codexbot/.github/workflows/review.yml@aca7720ff30bedf740e1726054224510c6f610ed'); assert.equal(config.vars.WEB_ENABLED,'false');assert.equal(config.vars.OPENAI_HOSTED_INFERENCE_AUTHORIZED,'false'); assert.equal(config.vars.ACCEPTANCE_USER_PER_DAY,'');assert.equal(config.vars.MERGE_ACCEPTANCE_REPOSITORY_ID,'');assert.equal(config.vars.MERGE_ACCEPTANCE_INSTALLATION_ID,''); diff --git a/tests/inference-diagnostics.test.ts b/tests/inference-diagnostics.test.ts new file mode 100644 index 0000000..c202737 --- /dev/null +++ b/tests/inference-diagnostics.test.ts @@ -0,0 +1,80 @@ +import {test,mock} from 'node:test'; +import assert from 'node:assert/strict'; +import {createServer,request as httpRequest,type IncomingMessage,type ServerResponse} from 'node:http'; +import {Readable,Writable} from 'node:stream'; +import {once} from 'node:events'; +import {safeEvents} from '../src/runner/stream.js'; +import {inferenceProxy} from '../src/runner/proxy.js'; +import {ExecutionDiagnostics,ExecutionError,executionFailure,proxyRequestEnvelope,proxyRequestDiagnostic,transportCode,type ExecutionFailure,type ProxyRequestDiagnostic} from '../src/core/execution.js'; +import {diagnostic} from '../src/core/diagnostics.js'; +import {normalizeReview,type ReviewRejectionReason} from '../src/core/review.js'; +import {clean,HEAD} from './fixtures.js'; +const privateText='fixture-private-provider-text OAuth-code source prompt'; +const frame=(value:unknown)=>'data: '+JSON.stringify(value)+'\n\n'; +const completed=frame({type:'response.completed'}),created=frame({type:'response.created'}); +const failure=frame({type:'response.failed',response:{error:{code:'subscription_sharing_usage_limit_exceeded',message:privateText}}}); +function source(chunks:string[],readError?:Error,cancelError?:Error){let index=0;return new ReadableStream({pull(c){if(index{ + const reports:ExecutionFailure[]=[];let output='';for await(const chunk of safeEvents(source([failure],undefined,new Error(privateText)),'fixture-credential',value=>reports.push(value)))output+=chunk; + assert.equal(reports.length,2);assert.equal(reports[0]!.provider_code,'subscription_sharing_usage_limit_exceeded');assert.equal(reports[0]!.origin,'upstream_event');assert.equal(reports[1]!.code,'proxy_stream_cleanup_failed');assert.equal(reports[1]!.origin,'cleanup');assert(output.includes('codexbot_inference_error'));assert(!output.includes(privateText));assert(!JSON.stringify(reports).includes(privateText)); +}); +await test('upstream read failures retain only exact transport codes; EOF and size failures stay distinct',async()=>{ + for(const code of ['ECONNRESET','UND_ERR_SOCKET','UND_ERR_BODY_TIMEOUT','ABORT_ERR']){ + const reports:ExecutionFailure[]=[];const error=new TypeError(privateText,{cause:Object.assign(new Error(privateText),{code})}); + for await(const chunk of safeEvents(source([created],error),'fixture-credential',value=>reports.push(value))){ assert(!chunk.includes(privateText)); } + assert.equal(reports[0]!.code,'provider_stream_read_failed');assert.equal(reports[0]!.origin,'upstream_read');assert.equal(reports[0]!.transport_code,code);assert.equal(reports[1]!.code,'proxy_stream_cleanup_failed');assert(!JSON.stringify(reports).includes(privateText)); + } + for(const [chunks,expected]of [[ [created],'provider_stream_incomplete'],[['data: {'],'provider_stream_truncated'],[['data: invalid\n\n'],'invalid_provider_event'],[['data: '+'x'.repeat(4_000_001)],'provider_frame_limit'],[Array.from({length:11},()=>frame({type:'response.output_text.delta',delta:'x'.repeat(2_000_000)})),'provider_stream_limit']] as const){ + const reports:ExecutionFailure[]=[];for await(const chunk of safeEvents(source([...chunks]),'fixture-credential',value=>reports.push(value))){ assert(!chunk.includes(privateText)); }assert.equal(reports[0]!.code,expected); + } + assert.equal(transportCode(Object.assign(new Error(privateText),{code:privateText})),undefined); +}); +async function proxyCase(options:{data:string;close?:boolean;deadline?:AbortController;cancelError?:Error;readError?:Error;fetchError?:Error}):Promise{ + let finish!:(value:ProxyRequestDiagnostic)=>void;const done=new Promise(resolve=>{finish=resolve;}); + const fetcher:typeof fetch=async(_url,init)=>{if(options.fetchError)throw options.fetchError;return new Response(options.readError?source([options.data],options.readError):new ReadableStream({start(c){c.enqueue(new TextEncoder().encode(options.data));init?.signal?.addEventListener('abort',()=>c.error(init.signal!.reason),{once:true});},cancel(){if(options.cancelError)throw options.cancelError;}}),{headers:{'content-type':'text/event-stream'}});}; + const server=createServer((req,res)=>{void inferenceProxy(req,res,'fixture-credential',fetcher,()=>{},()=>{},value=>{if(value.phase==='finished')finish(value);},7);});server.listen(0,'127.0.0.1');await once(server,'listening');const address=server.address();assert(address&&typeof address!=='string'); + try{ + await new Promise((resolve,reject)=>{const req=httpRequest({hostname:'127.0.0.1',port:address.port,path:'/v1/responses',method:'POST'},res=>{res.on('data',()=>{if(options.deadline&&!options.deadline.signal.aborted)options.deadline.abort(new DOMException(privateText,'TimeoutError'));if(options.close){res.destroy();resolve();}});res.on('end',resolve);res.on('close',resolve);res.on('error',()=>resolve());});req.on('error',reject);req.end(JSON.stringify({model:'fixture',store:false,stream:true,input:[]}));}); + const result=await done;assert(!proxyRequestEnvelope(result).includes(privateText));if(options.fetchError){assert.equal(result.upstream_status,undefined);assert.equal(result.content_type_category,undefined);}else{assert.equal(result.upstream_status,200);assert.equal(result.content_type_category,'event-stream');}assert.equal(result.request_index,7);assert(result.elapsed_ms!>=0&&result.elapsed_ms!<=1_320_000);return result; + }finally{server.closeAllConnections();await new Promise(resolve=>server.close(()=>resolve()));} +} +await test('closing after response.completed is not a provider failure; premature closure remains a failure',async()=>{ + const complete=await proxyCase({data:completed,close:true});assert.equal(complete.primary,null);assert.equal(complete.cleanup,null);assert.equal(complete.terminal_event,'completed');assert.equal(complete.abort_origin,'downstream'); + const early=await proxyCase({data:created,close:true});assert.equal(early.primary!.code,'proxy_client_disconnected');assert.equal(early.primary!.origin,'downstream');assert.equal(early.terminal_event,'none'); +}); +await test('proxy preserves primary HTTP/event information through cleanup, termination and owned deadline abort',async()=>{ + const event=await proxyCase({data:failure,cancelError:new Error(privateText)});assert.equal(event.primary!.provider_code,'subscription_sharing_usage_limit_exceeded');assert.equal(event.primary!.upstream_status,200);assert.equal(event.cleanup!.code,'proxy_stream_cleanup_failed');assert.equal(event.terminal_event,'failed'); + const network=await proxyCase({data:created,readError:new TypeError(privateText,{cause:Object.assign(new Error(privateText),{code:'UND_ERR_SOCKET'})})});assert.equal(network.primary!.code,'provider_stream_read_failed');assert.equal(network.primary!.transport_code,'UND_ERR_SOCKET');assert.equal(network.cleanup!.code,'proxy_stream_cleanup_failed'); + const deadline=new AbortController(),stub=mock.method(AbortSignal,'timeout',()=>deadline.signal);try{const result=await proxyCase({data:created,deadline});assert.equal(result.primary!.code,'proxy_deadline_exceeded');assert.equal(result.abort_origin,'deadline');}finally{stub.mock.restore();} +}); +await test('bounded correlated records survive envelopes and outer diagnostics; success clears recovered failures and late records cannot replace it',()=>{ + const primary:ExecutionFailure={component:'provider',code:'provider_stream_failed',provider_code:'rate_limit_exceeded',upstream_status:200}; + const cleanup:ExecutionFailure={component:'proxy',code:'proxy_stream_cleanup_failed',origin:'cleanup'}; + const parser=new ExecutionDiagnostics();parser.write(proxyRequestEnvelope({request_index:1,phase:'finished',primary,cleanup})+'\n');assert.deepEqual(parser.request!.primary,primary);assert.deepEqual(parser.request!.cleanup,cleanup); + const error=new ExecutionError({component:'engine',code:'review_incomplete',rejection_reason:'model_incomplete'});error.proxyFailure=primary;error.proxyCleanup=cleanup;assert.deepEqual(diagnostic(error,'analyzing').proxy_cleanup,cleanup); + parser.write(proxyRequestEnvelope({request_index:2,phase:'started',primary:null,cleanup:null})+'\n');assert.equal(parser.last,null); + parser.write(proxyRequestEnvelope({request_index:2,phase:'finished',primary:null,cleanup:null,terminal_event:'completed'})+'\n');parser.write(proxyRequestEnvelope({request_index:1,phase:'finished',primary,cleanup})+'\n');assert.equal(parser.last,null);assert.equal(parser.request!.request_index,2);assert.equal(parser.request!.primary,null); + const projected=proxyRequestDiagnostic({request_index:3,phase:'finished',primary:null,cleanup:null,headers:privateText,terminal_event:['completed'],elapsed_ms:1_320_001,stream_bytes:-1,abort_origin:privateText});assert.deepEqual(projected,{request_index:3,phase:'finished',primary:null,cleanup:null}); + for(let index=3;index<=8;index++)parser.write(proxyRequestEnvelope({request_index:index,phase:'finished',primary,cleanup})+'\n');assert.equal(parser.history.length,4);assert.deepEqual(parser.history.map(x=>x.request_index),[5,6,7,8]); + assert.equal(proxyRequestDiagnostic({request_index:102,phase:'finished',primary:null,cleanup:null}),null); + assert.deepEqual(executionFailure({component:'engine',code:'review_incomplete',rejection_reason:privateText,upstream_status:401}),{component:'engine',code:'review_incomplete'}); + error.proxyRequest={request_index:2,phase:'finished',primary:null,cleanup:null,terminal_event:'completed'};const recovered=diagnostic(error,'analyzing');assert.equal(recovered.proxy_failure,undefined);assert.equal(recovered.proxy_cleanup,undefined);assert.equal(recovered.proxy_request!.terminal_event,'completed'); + const maximum=proxyRequestEnvelope({request_index:101,phase:'finished',primary:{...primary,request_index:101,elapsed_ms:1_320_000,stream_bytes:20_000_001,stream_frames:1_000_000,terminal_event:'failed',abort_origin:'none'},cleanup});assert(Buffer.byteLength(maximum)<2048);assert(!maximum.includes(privateText)); +}); +await test('normalization reports explicit fixed rejection enums without changing output or review decisions',()=>{ + const huge={...clean(),result:'findings',findings:Array.from({length:40},(_,i)=>({severity:'high',confidence:1,path:'src/auth.ts',line:2,side:'RIGHT',title:'Finding '+i,explanation:'x'.repeat(4000),remediation:'y'.repeat(2000)}))}; + for(const [value,reason]of [[{unexpected:true},'schema_invalid'],[{...clean(),head_sha:'b'.repeat(40)},'head_mismatch'],[{...clean(),summary:'sk-'+'x'.repeat(40)},'quarantined'],[huge,'output_truncated']] as const){const reasons:ReviewRejectionReason[]=[];const output=normalizeReview(value,HEAD,x=>reasons.push(x));assert(reasons.includes(reason));assert.equal(output.complete,false);assert(!JSON.stringify(reasons).includes(privateText));} + const reasons:ReviewRejectionReason[]=[];assert.deepEqual(normalizeReview(clean(),HEAD,x=>reasons.push(x)),clean());assert.deepEqual(reasons,[]); +}); + +await test('an internal pipeline write exception is distinct from a downstream or provider failure',async()=>{ + const records:ProxyRequestDiagnostic[]=[]; + const req=Object.assign(Readable.from([Buffer.from(JSON.stringify({model:'fixture',store:false,stream:true,input:[]}))]),{method:'POST',url:'/v1/responses',headers:{}}) as unknown as IncomingMessage; + const sink=Object.assign(new Writable({write(_chunk,_encoding,done){done(Object.assign(new Error(privateText),{code:'ERR_STREAM_WRITE_AFTER_END'}));}}),{headersSent:false,writeHead(){this.headersSent=true;return this;}}) as unknown as ServerResponse; + await inferenceProxy(req,sink,'fixture-credential',async()=>new Response(completed,{headers:{'content-type':'text/event-stream'}}),()=>{},()=>{},value=>records.push(value)); + const result=records.at(-1)!;assert.equal(result.phase,'finished');assert.equal(result.primary!.component,'proxy');assert.equal(result.primary!.code,'proxy_pipeline_failed');assert.equal(result.primary!.transport_code,'ERR_STREAM_WRITE_AFTER_END');assert.equal(result.abort_origin,'pipeline');assert(!proxyRequestEnvelope(result).includes(privateText)); +}); + +await test('transport failures before response headers never invent an upstream status',async()=>{ + const result=await proxyCase({data:'',fetchError:new TypeError(privateText,{cause:Object.assign(new Error(privateText),{code:'ECONNREFUSED'})})});assert.equal(result.primary!.code,'proxy_transport_failed');assert.equal(result.primary!.transport_code,'ECONNREFUSED');assert.equal(result.primary!.upstream_status,undefined);assert.equal(result.primary!.origin,'transport');assert.equal(result.cleanup,null); +}); diff --git a/tests/inspection-check.mjs b/tests/inspection-check.mjs index d75d4ca..92ae4db 100644 --- a/tests/inspection-check.mjs +++ b/tests/inspection-check.mjs @@ -26,7 +26,7 @@ function events(items) { ].map((value, sequence_number) => `data: ${JSON.stringify({ ...value, sequence_number })}\n\n`).join(''); } // Scripted Responses only; real app-server policy, shell execution, mounts and output validation. -for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision','vision-invalid']) { +for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision','vision-invalid','schema-invalid','json-invalid']) { const id = randomUUID(), proxy = `codexbot-inspection-proxy-${id}`, review = `codexbot-inspection-review-${id}`, volume = `codexbot-inspection-${id}`; const root = await mkdtemp(resolve('.local/inspection-')), directory = join(root, 'context'), head = 'a'.repeat(40); const config = globalThis.structuredClone(DEFAULT_CONFIG), request = { id, head, base: 'b'.repeat(40), config, command: { merge: false, effort: null, instructions: '' } }; @@ -42,6 +42,7 @@ for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision', summary: 'Scripted protocol fixture after verified file inspection; not a live AI review.', findings: scenario === 'clean' || scenario === 'incomplete' ? [] : [{ severity: 'high', confidence: 0.99, path: 'src/access.js', line: 3, side: 'RIGHT', title: 'Reject unauthorized roles', explanation: 'The nonempty owner string makes the authorization result truthy for every other role.', remediation: 'Compare role against owner explicitly.' }] }; + const encodedResult=scenario==='json-invalid'?'not-json':JSON.stringify(scenario==='schema-invalid'?{unexpected:true}:result); const probe = `import assert from 'node:assert/strict';import fs from 'node:fs';import net from 'node:net';import http from 'node:http';import {createHash} from 'node:crypto'; const lookup=body=>new Promise((resolve,reject)=>{const r=http.request({socketPath:'/run/proxy/context.sock',path:'/file',method:'POST'},s=>{let text='';s.on('data',b=>text+=b);s.on('end',()=>resolve(JSON.parse(text)))});r.on('error',reject);r.end(JSON.stringify(body))}); assert.deepEqual(await lookup({snapshot:'head',path:'src/caller.js'}),{available:true}); @@ -58,7 +59,7 @@ for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision', const preload = `import cp from 'node:child_process';import {syncBuiltinESMExports} from 'node:module'; const spawn=cp.spawn;cp.spawn=(...args)=>{const child=spawn(...args);const write=child.stdin.write.bind(child.stdin);child.stdin.write=(chunk,...rest)=>{const msg=JSON.parse(String(chunk));if(msg.method==='thread/start')msg.params.approvalPolicy='untrusted';return write(JSON.stringify(msg)+'\\n',...rest)};return child};syncBuiltinESMExports();`; await writeFile(join(directory, 'untrusted-control.mjs'), preload); - const proxyScript = `import {createInferenceServer} from '/app/dist/src/runner/proxy.js';import {contextServer} from '/app/dist/src/runner/context-server.js';import {executionEnvelope} from '/app/dist/src/core/execution.js';import {readFile} from 'node:fs/promises'; + const proxyScript = `import {createInferenceServer} from '/app/dist/src/runner/proxy.js';import {contextServer} from '/app/dist/src/runner/context-server.js';import {executionEnvelope,proxyRequestEnvelope} from '/app/dist/src/core/execution.js';import {readFile} from 'node:fs/promises'; await contextServer('/run/proxy/context.sock',async(snapshot,path)=>snapshot==='head'&&path==='src/caller.js'); const token=(await readFile('/run/credential','utf8')).trim(); const evidence=${JSON.stringify(evidence)};let calls=0; @@ -71,8 +72,8 @@ for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision', const output=JSON.stringify(body.input.filter(item=>['function_call_output','custom_tool_call_output'].includes(item.type))); if(calls!==2||!Object.entries(evidence).every(([key,value])=>output.includes('fixture_read_'+key+'='+value))||!output.includes('fixture_isolation_verified'))throw new Error('Fixture inspection or isolation failed'); console.log('fixture_inspection_verified'); - return new Response(events([{id:'msg_fixture',type:'message',role:'assistant',status:'completed',content:[{type:'output_text',text:${JSON.stringify(JSON.stringify(result))},annotations:[]}]}]),{headers:{'content-type':'text/event-stream'}}); - };createInferenceServer(token,{minimumImages:${scenario.startsWith('vision')?1:0}},detail=>process.stderr.write(executionEnvelope(detail)+'\\n')).listen('/run/proxy/inference.sock',()=>console.log('ready'));`; + return new Response(events([{id:'msg_fixture',type:'message',role:'assistant',status:'completed',content:[{type:'output_text',text:${JSON.stringify(encodedResult)},annotations:[]}]}]),{headers:{'content-type':'text/event-stream'}}); + };const finite=globalThis.fetch;globalThis.fetch=async(url,init)=>{const value=await finite(url,init);if(calls!==2||!${JSON.stringify(['clean','incomplete'])}.includes(${JSON.stringify(scenario)}))return value;const bytes=new Uint8Array(await value.arrayBuffer());return new Response(new ReadableStream({start(controller){controller.enqueue(bytes);init.signal.addEventListener('abort',()=>controller.error(init.signal.reason),{once:true});}}),{status:value.status,headers:value.headers});};createInferenceServer(token,{minimumImages:${scenario.startsWith('vision')?1:0}},detail=>process.stderr.write(executionEnvelope(detail)+'\\n'),value=>process.stderr.write(proxyRequestEnvelope(value)+'\\n')).listen('/run/proxy/inference.sock',()=>console.log('ready'));`; const common = ['--label', `codexbot.run=${id}`, '--network=none', '--read-only', '--cap-drop=ALL', '--security-opt=no-new-privileges', '--pids-limit=128', '--memory=2g', '--cpus=2', `--user=${uid}:${gid}`, `--tmpfs=/tmp:rw,noexec,nosuid,size=128m,uid=${uid}`, `--tmpfs=/home/codex:rw,nosuid,size=128m,uid=${uid}`]; try { docker(['volume', 'create', volume]); @@ -92,17 +93,19 @@ for (const scenario of ['untrusted', 'findings', 'clean', 'incomplete','vision', const logs = spawnSync('docker', ['--config', dockerConfig, 'logs', proxy], { encoding: 'utf8', stdio: 'pipe', timeout: 10_000 }); const inspected = (logs.stdout ?? '').includes('fixture_inspection_verified'); const proxyFailure = new ExecutionDiagnostics(); proxyFailure.write(logs.stderr ?? ''); - if (run.status !== (['untrusted','incomplete','vision-invalid'].includes(scenario) ? 1 : 0) || (scenario === 'untrusted' && observed.last?.code !== 'codex_inspection_denied')) console.error(JSON.stringify({ scenario, failure: observed.last, proxy: proxyFailure.last, selected: (logs.stdout ?? '').includes('fixture_tool_selected'), inspected })); - if (scenario === 'untrusted' || scenario === 'incomplete' || scenario === 'vision-invalid') { + if (run.status !== (['untrusted','incomplete','vision-invalid','schema-invalid','json-invalid'].includes(scenario) ? 1 : 0) || (scenario === 'untrusted' && observed.last?.code !== 'codex_inspection_denied')) console.error(JSON.stringify({ scenario, failure: observed.last, proxy: proxyFailure.last, selected: (logs.stdout ?? '').includes('fixture_tool_selected'), inspected })); + if (['untrusted','incomplete','vision-invalid','schema-invalid','json-invalid'].includes(scenario)) { assert.equal(run.status, 1); assert.equal(run.stdout.trim(), ''); - if(scenario!=='vision-invalid')assert.equal(observed.last?.code, scenario === 'untrusted' ? 'codex_inspection_denied' : 'review_incomplete'); + if(scenario!=='vision-invalid')assert.equal(observed.last?.code, scenario === 'untrusted' ? 'codex_inspection_denied' : scenario==='json-invalid'?'codex_output_not_json':'review_incomplete'); else assert.equal((logs.stdout??'').includes('fixture_tool_selected'),false,'Invalid images must not reach upstream inference'); - assert.equal(inspected, scenario === 'incomplete'); + assert.equal(inspected, ['incomplete','schema-invalid','json-invalid'].includes(scenario)); + if(scenario==='incomplete'||scenario==='schema-invalid')assert.equal(observed.last?.rejection_reason,scenario==='incomplete'?'model_incomplete':'schema_invalid'); } else { assert.equal(run.status, 0, 'Actual Codex inspection failed; raw logs withheld'); assert.equal(inspected, true); const output = validateReview(JSON.parse(run.stdout), head, fixture.files); assert.deepEqual(output, result); assert.equal(decision(output, config, true), scenario === 'clean' ? 'APPROVE' : 'REQUEST_CHANGES'); } + if(['clean','incomplete'].includes(scenario)){assert.equal(proxyFailure.request?.request_index,2);assert.equal(proxyFailure.request.primary,null);assert.equal(proxyFailure.request.cleanup,null);assert.equal(proxyFailure.request.terminal_event,'completed');assert.equal(proxyFailure.last,null);} console.log(`Actual pinned Codex inspection/isolation scenario passed: ${scenario} (scripted Responses, no live AI inference).`); } finally { await cleanupReviewContainers(id); docker(['volume','rm',volume]); assert.equal(dirname(root), resolve('.local')); await rm(root, { recursive:true, force:true }); } } diff --git a/tests/proxy.test.ts b/tests/proxy.test.ts index f79bde8..4c35bd0 100644 --- a/tests/proxy.test.ts +++ b/tests/proxy.test.ts @@ -4,6 +4,10 @@ import { createServer } from 'node:http'; import { once } from 'node:events'; import { inferenceProxy, createInferenceServer } from '../src/runner/proxy.js'; import type { ExecutionFailure } from '../src/core/execution.js'; +function rejectionMetadata(value: ExecutionFailure) { + assert(Number.isInteger(value.elapsed_ms)&&value.elapsed_ms!>=0&&value.elapsed_ms!<=1_320_000); + return {request_index:1,elapsed_ms:value.elapsed_ms,stream_bytes:0,stream_frames:0,terminal_event:'none',abort_origin:'none'}; +} await test('API-key and ChatGPT adapters inject only their own bearer at the isolated inference boundary', async () => { for (const credential of ['fixture-personal-api-key', 'fixture-personal-oauth-token']) { const requests: { url: string; auth: string; body: string }[] = []; @@ -51,9 +55,9 @@ await test('proxy diagnostics retain only proven HTTP status and exact provider const result = await post(body); assert.equal(result.status, status); assert.ok(!(await result.text()).includes(secret)); assert.deepEqual(diagnostics[0], { component: 'provider', code: 'provider_http_failed', upstream_status: status, content_type_category: 'other', body_present: true, - ...(!['oversized', secret].includes(code) ? { provider_code: code } : {}), ...(param && param !== secret ? { provider_param: param } : {}) }); + origin:'transport',...rejectionMetadata(diagnostics[0]!),...(!['oversized', secret].includes(code) ? { provider_code: code } : {}), ...(param && param !== secret ? { provider_param: param } : {}) }); const denied = await post({ ...body, [secret]: secret }); assert.equal(denied.status, 403); await denied.text(); - assert.deepEqual(diagnostics[1], { component: 'proxy', code: 'proxy_unsupported_request_field' }); + assert.deepEqual(diagnostics[1], { component: 'proxy', code: 'proxy_unsupported_request_field',origin:'validation',...rejectionMetadata(diagnostics[1]!) }); assert.equal(calls, 1); assert.ok(!JSON.stringify(diagnostics).includes(secret)); } finally { server.closeAllConnections(); server.close(); } } @@ -96,7 +100,7 @@ await test('upstream 2xx requires a real SSE body; only classified response meta assert.equal(result.status, valid ? input.status : 403); if (valid) { assert.match(output, /response.completed/); assert.deepEqual(diagnostics, []); } else assert.deepEqual(diagnostics, [{ component: 'provider', code: 'provider_stream_content_type_invalid', upstream_status: input.status, - content_type_category: input.category, body_present: input.body !== null, ...(input.approvedCode ? { provider_code: 'model_not_found', provider_param: 'model' } : {}) }]); + content_type_category: input.category, body_present: input.body !== null, origin:'transport',...rejectionMetadata(diagnostics[0]!),...(input.approvedCode ? { provider_code: 'model_not_found', provider_param: 'model' } : {}) }]); assert.ok(!output.includes(secret)); assert.ok(!JSON.stringify(diagnostics).includes(secret)); assert.equal(result.headers.get('x-private-header'), null); } finally { server.closeAllConnections(); server.close(); } @@ -111,7 +115,7 @@ await test('unreadable/cancellation-failed upstream bodies preserve only observe try { const result = await fetch(`http://127.0.0.1:${address.port}/v1/responses`, { method: 'POST', body: JSON.stringify({ model: 'fixture', store: false, stream: true, input: [] }) }); assert.equal(result.status, 403); assert.ok(!(await result.text()).includes(secret)); - assert.deepEqual(diagnostics, [{ component: 'provider', code: 'provider_stream_content_type_invalid', upstream_status: 200, content_type_category: 'json', body_present: true }]); + assert.deepEqual(diagnostics, [{ component: 'provider', code: 'provider_stream_content_type_invalid', upstream_status: 200, content_type_category: 'json', body_present: true,origin:'transport',...rejectionMetadata(diagnostics[0]!) }]); } finally { server.closeAllConnections(); server.close(); } }); await test('inference locks model/effort and denies stored prompts and additional hosted tools', async () => { diff --git a/tests/sandbox-check.mjs b/tests/sandbox-check.mjs index 5dccb26..a14c25b 100644 --- a/tests/sandbox-check.mjs +++ b/tests/sandbox-check.mjs @@ -34,7 +34,7 @@ const events = [ { type: 'response.completed', response: { id: 'resp_fixture', status: 'completed', output: [item], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } } ].map((event, sequence_number) => `event: ${event.type}\ndata: ${JSON.stringify({ ...event, sequence_number })}\n\n`).join(''); const proxyScript = `import {createInferenceServer} from '/app/dist/src/runner/proxy.js'; -import {executionEnvelope} from '/app/dist/src/core/execution.js'; +import {executionEnvelope,proxyRequestEnvelope} from '/app/dist/src/core/execution.js'; let calls=0; globalThis.fetch = async (url, init) => { if(url !== 'https://api.openai.com/v1/responses' || init.headers.Authorization !== 'Bearer fixture-only') throw new Error('Invalid inference boundary'); @@ -43,7 +43,7 @@ globalThis.fetch = async (url, init) => { if(++calls > 1) return Response.json({error:{code:calls===2?'subscription_sharing_unsupported_capability':'model_not_found',param:calls===2?'tools':'model',message:'private-fixture-provider-body'}},{status:calls===2?400:200}); return new Response(${JSON.stringify(events)}, {headers:{'content-type':'text/event-stream'}}); }; -createInferenceServer('fixture-only',{},detail=>process.stderr.write(executionEnvelope(detail)+'\\n')).listen('/run/proxy/inference.sock',()=>process.stdout.write('ready\\n'));`; +createInferenceServer('fixture-only',{},detail=>process.stderr.write(executionEnvelope(detail)+'\\n'),value=>process.stderr.write(proxyRequestEnvelope(value)+'\\n')).listen('/run/proxy/inference.sock',()=>process.stdout.write('ready\\n'));`; const common = ['--label', `codexbot.run=${id}`, '--network=none', '--read-only', '--cap-drop=ALL', '--security-opt=no-new-privileges', '--pids-limit=128', '--memory=2g', '--user=1000:1000', '--tmpfs=/tmp:rw,noexec,nosuid,size=128m,uid=1000', '--tmpfs=/home/codex:rw,nosuid,size=128m,uid=1000']; const partial = randomUUID(); try { @@ -101,8 +101,9 @@ try { logs.stderr.setEncoding('utf8'); logs.stderr.on('data', chunk => observed.write(chunk)); logs.on('error', reject); logs.on('close', code => code === 0 ? resolveLogs() : reject(new Error('Synthetic proxy observation failed'))); }); + assert(observed.request.request_index>=2&&observed.request.request_index<=101);assert(Number.isInteger(observed.last.elapsed_ms)&&observed.last.elapsed_ms>=0&&observed.last.elapsed_ms<=1_320_000); assert.deepEqual(observed.last, { component: 'provider', code: status === 400 ? 'provider_http_failed' : 'provider_stream_content_type_invalid', - upstream_status: status, content_type_category: 'json', body_present: true, + upstream_status: status, content_type_category: 'json', body_present: true,origin:'transport',request_index:observed.request.request_index,elapsed_ms:observed.last.elapsed_ms,stream_bytes:0,stream_frames:0,terminal_event:'none',abort_origin:'none', provider_code: status === 400 ? 'subscription_sharing_unsupported_capability' : 'model_not_found', provider_param: status === 400 ? 'tools' : 'model' }); } process.stdout.write('Pinned Codex failed turns for HTTP 400 and HTTP 200 JSON preserve safe proxy metadata, exit 1 and no review output.\n'); diff --git a/wrangler.jsonc b/wrangler.jsonc index dd1e247..81d2c85 100644 --- a/wrangler.jsonc +++ b/wrangler.jsonc @@ -33,7 +33,7 @@ "GITHUB_APP_SLUG": "codexbot-review", "TRUSTED_WORKFLOW": "AppSolves/codexbot/.github/workflows/review.yml@aca7720ff30bedf740e1726054224510c6f610ed", "CHATGPT_DEPLOYMENT_AUTHORIZED": "true", - "MERGE_DEPLOYMENT_AUTHORIZED": "true", + "MERGE_DEPLOYMENT_AUTHORIZED": "false", "MERGE_ACCEPTANCE_REPOSITORY_ID": "", "MERGE_ACCEPTANCE_INSTALLATION_ID": "", "ACCEPTANCE_USER_PER_DAY": "",