@awak-app/simy-cli 0.5.55 → 0.5.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.55",
+  "version": "0.5.57",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.55";
+export const CLI_VERSION = "0.5.57";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/session-supervision/codex-app-server.js

@@ -4,12 +4,14 @@ import { realpath } from 'node:fs/promises';
 import { inspectBackendExecutable } from '../backend-executable.js';
 import { assessedCheckpointContract, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { boundConversation, boundProviderGoal, textContent } from './conversation-context.js';
+import { JsonDataUrlFilter } from './json-data-url-filter.js';
 
 const REQUEST_TIMEOUT = 15_000;
 const MAX_LINE = 256 * 1024;
 const ANALYSIS_MAX_LINE = 1024 * 1024;
 const ANALYSIS_MAX_TURNS = 16;
 const ANALYSIS_PAGE_SIZE = 6;
+const ANALYSIS_MAX_WIRE_LINE = 8 * 1024 * 1024;
 const SOURCE_KINDS = ['cli', 'vscode', 'exec', 'appServer', 'unknown'];
 
 export class CodexAppServerError extends Error {
@@ -21,7 +23,7 @@ export class CodexAppServerError extends Error {
 }
 
 export class CodexAppServerClient {
-  constructor(child, { maxLineBytes = MAX_LINE } = {}) {
+  constructor(child, { maxLineBytes = MAX_LINE, omitInlineAttachments = false } = {}) {
     this.maxLineBytes = Number.isInteger(maxLineBytes) ? Math.max(MAX_LINE, Math.min(maxLineBytes, 8 * 1024 * 1024)) : MAX_LINE;
     this.child = child;
     this.nextId = 0;
@@ -30,15 +32,21 @@ export class CodexAppServerClient {
     this.closed = false;
     // Provider output can include private text. Hold only one bounded JSON-RPC
     // line at a time, and discard overlong lines before parsing them.
-    let pending = Buffer.alloc(0), discard = false;
+    let pending = Buffer.alloc(0), discard = false, wireBytes = 0;
+    let filter = omitInlineAttachments ? new JsonDataUrlFilter() : null;
     child.stdout.on('data', chunk => {
       let offset = 0;
       while (offset < chunk.length) {
         const newline = chunk.indexOf(10, offset);
         const end = newline < 0 ? chunk.length : newline;
-        const piece = chunk.subarray(offset, end);
+        let piece = chunk.subarray(offset, end);
         if (!discard) {
-          if (pending.length + piece.length > this.maxLineBytes) {
+          wireBytes += piece.length;
+          // Analysis does not use attachment bytes. Remove inline data URLs
+          // before its retained-byte limit, with a separate finite wire cap.
+          const wireLimit = omitInlineAttachments ? ANALYSIS_MAX_WIRE_LINE : this.maxLineBytes;
+          if (wireBytes <= wireLimit && filter) piece = filter.push(piece);
+          if (wireBytes > wireLimit || pending.length + piece.length > this.maxLineBytes) {
             pending = Buffer.alloc(0); discard = true;
             this.rejectPending(new CodexAppServerError('response_too_large', 'Codex response exceeded the bounded context limit.'));
           }
@@ -46,7 +54,9 @@ export class CodexAppServerClient {
         }
         if (newline >= 0) {
           if (!discard && pending.length) this.consume(pending.toString('utf8'));
-          pending = Buffer.alloc(0); discard = false; offset = newline + 1;
+          pending = Buffer.alloc(0); discard = false; wireBytes = 0;
+          filter = omitInlineAttachments ? new JsonDataUrlFilter() : null;
+          offset = newline + 1;
         } else offset = end;
       }
     });
@@ -124,7 +134,7 @@ export function supportsCodexWriterLock(version) {
   return parts[0] > 0 || parts[1] > 158 || parts[1] === 158 && parts[2] >= 0;
 }
 
-export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes } = {}) {
+export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes, omitInlineAttachments = false } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
   const inspection = await inspectExecutable('codex');
   if (!inspection?.available || !inspection.executable) throw new CodexAppServerError('unavailable', 'Codex executable is unavailable.');
@@ -134,7 +144,7 @@ export async function openCodexAppServer({ inspectExecutable = inspectBackendExe
   // restore a temporary read-only override. The caller's signal is checked
   // before spawn and by the turn watcher below.
   const child = spawnImpl(inspection.executable, ['app-server', '--stdio'], { stdio: ['pipe', 'pipe', 'pipe'] });
-  const client = new CodexAppServerClient(child, { maxLineBytes });
+  const client = new CodexAppServerClient(child, { maxLineBytes, omitInlineAttachments });
   try {
     await client.request('initialize', { clientInfo: { name: 'simy_session_supervision', title: 'SIMY Session Supervision', version: '1.0.0' } });
     client.notify('initialized');
@@ -256,7 +266,7 @@ export async function readCodexSession(client, session) {
 
 export async function readCodexConversation(candidate, { openClient = openCodexAppServer, signal } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-  const client = await openClient({ signal, maxLineBytes: ANALYSIS_MAX_LINE });
+  const client = await openClient({ signal, maxLineBytes: ANALYSIS_MAX_LINE, omitInlineAttachments: true });
   const cancelled = () => { void client.close(); };
   signal?.addEventListener('abort', cancelled, { once: true });
   try {
@@ -269,22 +279,28 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     const terminal = turn => ['completed', 'interrupted', 'failed'].includes(turn?.status);
     const turns = [];
     const turnIds = new Set(), cursors = new Set();
+    let pageSize = ANALYSIS_PAGE_SIZE;
+    const readPage = async (cursor, maximum = ANALYSIS_PAGE_SIZE) => {
+      let limit = Math.min(pageSize, maximum);
+      for (;;) {
+        if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
+        try {
+          const page = await client.request('thread/turns/list', { threadId: candidate.session, cursor, limit, sortDirection: 'desc', itemsView: 'summary' });
+          if (!Array.isArray(page?.data) || page.data.length > limit || page.nextCursor != null && (typeof page.nextCursor !== 'string' || !page.nextCursor || page.nextCursor.length > 2048)) {
+            throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid bounded conversation page.');
+          }
+          return page;
+        } catch (error) {
+          if (unsupportedMethod(error)) throw new CodexAppServerError('unsupported', 'This Codex version does not support bounded conversation history.');
+          if (error?.code !== 'response_too_large' || limit <= 1) throw error;
+          pageSize = limit = Math.max(1, Math.floor(limit / 2));
+        }
+      }
+    };
     let cursor = null;
     do {
       if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-      const limit = Math.min(ANALYSIS_PAGE_SIZE, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
-      let page;
-      try {
-        page = await client.request('thread/turns/list', { threadId: candidate.session, cursor, limit, sortDirection: 'desc', itemsView: 'summary' });
-      } catch (error) {
-        if (String(error?.code) === '-32601' || /unknown method|method.*not found|unrecognized method/i.test(String(error?.message || ''))) {
-          throw new CodexAppServerError('unsupported', 'This Codex version does not support bounded conversation history.');
-        }
-        throw error;
-      }
-      if (!Array.isArray(page?.data) || page.data.length > limit || page.nextCursor != null && (typeof page.nextCursor !== 'string' || !page.nextCursor || page.nextCursor.length > 2048)) {
-        throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid bounded conversation page.');
-      }
+      const page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
       for (const turn of page.data) {
         if (typeof turn?.id !== 'string' || !turn.id || turnIds.has(turn.id)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous conversation pagination.');
         turnIds.add(turn.id); turns.push(turn);
@@ -298,13 +314,18 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // to this read-only snapshot, but a newly settled turn must invalidate it.
     const settled = turns.filter(terminal).slice(0, ANALYSIS_MAX_TURNS);
     const boundary = settled[0];
-    const verification = await client.request('thread/turns/list', {
-      threadId: candidate.session, cursor: null, limit: ANALYSIS_PAGE_SIZE, sortDirection: 'desc', itemsView: 'summary',
-    });
-    if (!Array.isArray(verification?.data) || verification.data.length > ANALYSIS_PAGE_SIZE) {
-      throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid snapshot check.');
+    let verification = await readPage(null);
+    const verificationTurns = [...verification.data];
+    const verificationCursors = new Set();
+    // A reduced first page may contain only the running turn. Follow bounded
+    // pages to the terminal boundary rather than mistaking it for a new one.
+    while (!verificationTurns.some(terminal) && verification.nextCursor && verificationTurns.length < ANALYSIS_MAX_TURNS + ANALYSIS_PAGE_SIZE) {
+      if (!verification.data.length || verificationCursors.has(verification.nextCursor)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous snapshot pagination.');
+      verificationCursors.add(verification.nextCursor);
+      verification = await readPage(verification.nextCursor);
+      verificationTurns.push(...verification.data);
     }
-    const latestBoundary = verification.data.find(terminal);
+    const latestBoundary = verificationTurns.find(terminal);
     // Compare the immutable settled summary, never the running turn's prose.
     if (JSON.stringify(boundary) !== JSON.stringify(latestBoundary)) {
       throw new CodexAppServerError('turn_settling', 'The latest turn settled during the snapshot read.');
@@ -322,7 +343,7 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // A display summary omits intermediate reasoning/tool context even when
     // every turn fits. Never represent it as the complete conversation; the
     // classifier must establish a self-contained objective from retained text.
-    const awaitingTurn = latestMetadata.isRunning === true || [...turns, ...verification.data].some(turn => ['inProgress', 'in_progress'].includes(turn?.status));
+    const awaitingTurn = latestMetadata.isRunning === true || [...turns, ...verificationTurns].some(turn => ['inProgress', 'in_progress'].includes(turn?.status));
     let incomplete = !settled.length || turns.some(turn => !terminal(turn) && !['inProgress', 'in_progress'].includes(turn?.status)), truncated = true;
     for (const [index, turn] of settled.toReversed().entries()) {
       if (turn.itemsView === 'notLoaded') { truncated = true; if (turn === boundary) incomplete = true; continue; }

package/src/session-supervision/json-data-url-filter.js

@@ -0,0 +1,66 @@
+// JSON remains validated by JSON.parse after this lexical filter. Only inline
+// URL values are removed; prose, identities, cursors and escaped quotes retain
+// their original bytes. Latin-1 here preserves split UTF-8 sequences verbatim.
+export class JsonDataUrlFilter {
+  constructor() {
+    this.inString = false;
+    this.escaped = false;
+    this.token = '';
+    this.lastString = null;
+    this.valueKey = null;
+    this.probe = null;
+    this.dropping = false;
+  }
+
+  push(bytes) {
+    let output = '';
+    for (const char of bytes.toString('latin1')) {
+      if (!this.inString) {
+        output += char;
+        if (char === '"') {
+          this.inString = true;
+          this.token = '';
+          this.escaped = false;
+          this.probe = ['url', 'imageUrl', 'image_url'].includes(this.valueKey) ? '' : null;
+          this.dropping = false;
+          this.valueKey = null;
+        } else if (char === ':') {
+          this.valueKey = this.lastString;
+          this.lastString = null;
+        } else if (!/\s/.test(char)) {
+          this.lastString = null;
+          this.valueKey = null;
+        }
+        continue;
+      }
+      const closing = char === '"' && !this.escaped;
+      if (closing) {
+        if (this.probe !== null) output += this.probe;
+        output += char;
+        this.inString = false;
+        this.lastString = null;
+        if (this.token !== null && !this.dropping) {
+          try { this.lastString = JSON.parse(Buffer.from(`"${this.token}"`, 'latin1').toString('utf8')); } catch { /* Final JSON validation rejects malformed input. */ }
+        }
+        this.probe = null;
+        this.dropping = false;
+        continue;
+      }
+      if (this.token !== null) this.token = this.token.length < 128 ? this.token + char : null;
+      if (this.escaped) this.escaped = false;
+      else if (char === '\\') this.escaped = true;
+      if (this.dropping) continue;
+      if (this.probe !== null) {
+        this.probe += char;
+        if (!'data:'.startsWith(this.probe)) {
+          output += this.probe;
+          this.probe = null;
+        } else if (this.probe === 'data:') {
+          this.dropping = true;
+          this.probe = null;
+        }
+      } else output += char;
+    }
+    return Buffer.from(output, 'latin1');
+  }
+}