@brunobracaioli/aibrain 0.3.0-beta.14 → 0.3.0-beta.15

package/dist/assets/jev-paid-pilot-terminal.mjs

@@ -9,6 +9,8 @@ import { fileURLToPath } from 'node:url';
 import { WebSocketServer, WebSocket } from 'ws';
 
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
+const MAX_MONITOR_RESPONSE_BYTES = 64 * 1024 * 1024;
+const MAX_MONITOR_PENDING_BYTES = 32 * 1024 * 1024;
 const MAX_QUEUED_FRAMES = 64;
 const MAX_QUEUED_BYTES = 32 * 1024 * 1024;
 const STARTUP_HANDOFF_GRACE_MS = 5_000;
@@ -113,6 +115,12 @@ async function main() {
   let monitorLineCount = 0;
   let monitorByteCount = 0;
   let monitorExitCode = null;
+  let transportAbortReason = null;
+  let transportAbortBytes = null;
+  let transportAbortMethod = null;
+  let maxMonitorFrameBytes = 0;
+  let maxMonitorFrameMethod = null;
+  let outputPauseCount = 0;
   let terminalExitCode = null;
   let server;
   let webSocketServer;
@@ -189,7 +197,10 @@ async function main() {
       child: null,
       connection: null,
       retiring: false,
-      monitorBuffer: Buffer.alloc(0),
+      monitorFrameParts: [],
+      monitorFrameBytes: 0,
+      monitorPendingChunk: Buffer.alloc(0),
+      monitorPaused: false,
       monitorWritable: true,
       pendingToMonitor: [],
       queuedFrames: 0,
@@ -232,22 +243,30 @@ async function main() {
     });
     child.stdout.on('data', (chunk) => {
       if (generation.retiring || shuttingDown) return;
-      generation.monitorBuffer = Buffer.concat([generation.monitorBuffer, Buffer.from(chunk)]);
-      while (true) {
-        const newline = generation.monitorBuffer.indexOf(10);
-        if (newline < 0) break;
-        const line = generation.monitorBuffer.subarray(0, newline);
-        generation.monitorBuffer = generation.monitorBuffer.subarray(newline + 1);
-        handleMonitorLine(generation, line);
-      }
-      if (generation.monitorBuffer.length > MAX_FRAME_BYTES) {
-        abortGeneration(generation, 'monitor_frame_limit');
+      const part = Buffer.from(chunk);
+      if (generation.monitorPaused) {
+        if (generation.monitorPendingChunk.length + part.length > MAX_MONITOR_PENDING_BYTES) {
+          abortGeneration(
+            generation,
+            'monitor_backpressure_limit',
+            generation.monitorPendingChunk.length + part.length,
+          );
+          return;
+        }
+        generation.monitorPendingChunk =
+          generation.monitorPendingChunk.length === 0
+            ? part
+            : Buffer.concat([generation.monitorPendingChunk, part]);
+        return;
       }
+      processMonitorChunk(generation, part);
     });
     child.on('exit', (code) => {
       if (generation.retiring || shuttingDown) {
         generation.pendingToMonitor.length = 0;
-        generation.monitorBuffer = Buffer.alloc(0);
+        generation.monitorFrameParts = [];
+        generation.monitorFrameBytes = 0;
+        generation.monitorPendingChunk = Buffer.alloc(0);
         return;
       }
       fail(code ?? 0);
@@ -256,6 +275,56 @@ async function main() {
   };
 
   let initialGeneration;
+  const resumeMonitor = (generation) => {
+    if (!generation.monitorPaused || generation.retiring || shuttingDown) return;
+    generation.monitorPaused = false;
+    processMonitorBuffer(generation);
+    if (!generation.retiring && !shuttingDown && !generation.monitorPaused)
+      generation.child.stdout.resume();
+  };
+  const pauseMonitor = (generation) => {
+    if (generation.monitorPaused || generation.retiring || shuttingDown) return;
+    generation.monitorPaused = true;
+    outputPauseCount += 1;
+    generation.child.stdout.pause();
+  };
+  const processMonitorChunk = (generation, incoming) => {
+    if (generation.retiring || shuttingDown) return;
+    let offset = 0;
+    while (offset < incoming.length && !generation.monitorPaused && !generation.retiring) {
+      const newline = incoming.indexOf(10, offset);
+      const end = newline < 0 ? incoming.length : newline;
+      const part = incoming.subarray(offset, end);
+      if (generation.monitorFrameBytes + part.length > MAX_MONITOR_RESPONSE_BYTES) {
+        abortGeneration(
+          generation,
+          'monitor_frame_limit',
+          generation.monitorFrameBytes + part.length,
+        );
+        return;
+      }
+      if (part.length > 0) {
+        generation.monitorFrameParts.push(part);
+        generation.monitorFrameBytes += part.length;
+      }
+      offset = newline < 0 ? incoming.length : newline + 1;
+      if (newline >= 0) {
+        const line = Buffer.concat(generation.monitorFrameParts, generation.monitorFrameBytes);
+        generation.monitorFrameParts = [];
+        generation.monitorFrameBytes = 0;
+        handleMonitorLine(generation, line);
+      }
+    }
+    if (offset < incoming.length) generation.monitorPendingChunk = incoming.subarray(offset);
+  };
+  const processMonitorBuffer = (generation) => {
+    if (generation.retiring || shuttingDown) return;
+    if (generation.monitorPendingChunk.length > 0) {
+      const pending = generation.monitorPendingChunk;
+      generation.monitorPendingChunk = Buffer.alloc(0);
+      processMonitorChunk(generation, pending);
+    }
+  };
   const flushGeneration = (generation) => {
     while (generation.monitorWritable && generation.pendingToMonitor.length > 0) {
       const frame = generation.pendingToMonitor.shift();
@@ -287,12 +356,31 @@ async function main() {
     generation.retirementTimer = setTimeout(() => {
       killOwned(generation.child, 'SIGKILL');
       generation.pendingToMonitor.length = 0;
-      generation.monitorBuffer = Buffer.alloc(0);
+      generation.monitorFrameParts = [];
+      generation.monitorFrameBytes = 0;
+      generation.monitorPendingChunk = Buffer.alloc(0);
       generations.delete(generation);
     }, 500);
   };
-  const abortGeneration = (generation, reason) => {
+  const abortGeneration = (generation, reason, bytes = null, method = null) => {
     const connection = generation.connection;
+    const primaryConnection = connection?.isCandidate !== true && connection?.isAuxiliary !== true;
+    if (transportAbortReason === null || primaryConnection) {
+      transportAbortReason = reason;
+      transportAbortBytes = Number.isSafeInteger(bytes) ? bytes : null;
+      transportAbortMethod = typeof method === 'string' ? method : null;
+    }
+    if (primaryConnection && cleanupInitiator === 'unknown') {
+      cleanupInitiator = `transport_${reason}`;
+      process.stderr.write(
+        `${JSON.stringify({
+          event: 'codex_terminal_bridge_error',
+          category: reason,
+          ...(transportAbortBytes === null ? {} : { bytes: transportAbortBytes }),
+          ...(transportAbortMethod === null ? {} : { method: transportAbortMethod }),
+        })}\n`,
+      );
+    }
     if (connection?.isCandidate) {
       rejectCandidate(connection, 1013, reason);
       return;
@@ -374,6 +462,12 @@ async function main() {
             monitor_line_count: monitorLineCount,
             monitor_byte_count: monitorByteCount,
             monitor_exit_code: monitorExitCode,
+            transport_abort_reason: transportAbortReason,
+            transport_abort_bytes: transportAbortBytes,
+            transport_abort_method: transportAbortMethod,
+            max_monitor_frame_bytes: maxMonitorFrameBytes,
+            max_monitor_frame_method: maxMonitorFrameMethod,
+            output_pause_count: outputPauseCount,
             terminal_exit_code: terminalExitCode,
             handoff_count: handoffCount,
             handoff_attempt_count: handoffAttemptCount,
@@ -523,11 +617,12 @@ async function main() {
     if (line.length === 0) return;
     const connection = generation.connection;
     if (!connection || connection.retiring) return;
-    if (line.length > MAX_FRAME_BYTES) {
-      abortGeneration(generation, 'monitor_frame_limit');
+    if (line.length > MAX_MONITOR_RESPONSE_BYTES) {
+      abortGeneration(generation, 'monitor_frame_limit', line.length);
       return;
     }
     let parsed;
+    let responseMethod;
     try {
       parsed = JSON.parse(line.toString('utf8'));
       const isInitializeResponse =
@@ -587,6 +682,7 @@ async function main() {
         connection.pendingRequests.has(parsed.id)
       ) {
         const method = connection.pendingRequests.get(parsed.id);
+        responseMethod = method;
         connection.pendingRequests.delete(parsed.id);
         if (parsed.error === undefined && PRIMARY_DISCOVERY.has(method)) {
           connection.discoverySatisfied = true;
@@ -617,8 +713,13 @@ async function main() {
                     : 'native_internal_error';
         }
       }
+      if (line.length > maxMonitorFrameBytes) {
+        maxMonitorFrameBytes = line.length;
+        maxMonitorFrameMethod = responseMethod ?? null;
+      }
     } catch {
-      parsed = null;
+      abortGeneration(generation, 'monitor_frame_invalid', line.length, responseMethod);
+      return;
     }
     if (connection.isAuxiliary && parsed === null) {
       auxiliaryUnknownResponseCount += 1;
@@ -626,11 +727,14 @@ async function main() {
       return;
     }
     if (connection.socket.readyState !== WebSocket.OPEN) return;
-    if (connection.socket.bufferedAmount + line.length > MAX_QUEUED_BYTES) {
-      abortGeneration(generation, 'bridge_queue_limit');
-      return;
-    }
-    connection.socket.send(line.toString('utf8'), { binary: false });
+    pauseMonitor(generation);
+    connection.socket.send(line.toString('utf8'), { binary: false }, (error) => {
+      if (error && !generation.retiring && !shuttingDown) {
+        abortGeneration(generation, 'bridge_output_failed', line.length, responseMethod);
+        return;
+      }
+      resumeMonitor(generation);
+    });
   };
   const handleClientMessage = (connection, data, isBinary) => {
     if (shuttingDown) return;

package/dist/cli.mjs

@@ -24,7 +24,7 @@ import { codexPolicyJson, makePolicy, publicPolicy, isProfile } from './policy.m
 import { readDiagnostics } from './claude-observation.mjs';
 import { readCodexDiagnostics } from './codex-diagnostics.mjs';
 
-const VERSION = '0.3.0-beta.14';
+const VERSION = '0.3.0-beta.15';
 const ENDPOINT = 'https://mcp.ai-brain.aisac.cloud/mcp';
 const PACKAGE_ROOT = dirname(fileURLToPath(import.meta.url));
 const LEGACY_DISCLOSURE_VERSION = 'aibrain-paid-context-v1-2026-10-09';

package/dist/codex-diagnostics.mjs

@@ -2,11 +2,28 @@
 
 import { createHash } from 'node:crypto';
 import { chmod, lstat, mkdir, open, readFile, readdir, rename, rm, stat } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { constants, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 
 export const CODEX_DIAGNOSTIC_SCHEMA_VERSION = 1;
-export const CODEX_DIAGNOSTIC_ADAPTER_VERSION = '0.3.0-beta.13';
+const PACKAGE_VERSION_PATTERN =
+  /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/u;
+function packageVersion() {
+  for (const packageUrl of [
+    new URL('./package.json', import.meta.url),
+    new URL('../package.json', import.meta.url),
+  ]) {
+    try {
+      const value = JSON.parse(readFileSync(packageUrl, 'utf8'));
+      if (typeof value?.version === 'string' && PACKAGE_VERSION_PATTERN.test(value.version))
+        return value.version;
+    } catch {
+      // Source and packaged dist use different relative package metadata locations.
+    }
+  }
+  throw new Error('codex_diagnostics_package_version_unavailable');
+}
+export const CODEX_DIAGNOSTIC_ADAPTER_VERSION = packageVersion();
 export const CODEX_DIAGNOSTIC_MAX_LOG_BYTES = 512 * 1024;
 export const CODEX_DIAGNOSTIC_MAX_LOG_FILES = 3;
 export const CODEX_DIAGNOSTIC_MAX_RECORDS = 128;

package/dist/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.14",
+  "version": "0.3.0-beta.15",
   "type": "module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.14",
+  "version": "0.3.0-beta.15",
   "private": false,
   "description": "AI Brain assisted context beta client for Claude Code and Codex",
   "license": "UNLICENSED",