farming-code 2.2.6

package/backend/acp-session-state.js

@@ -0,0 +1,448 @@
+const MAX_ACP_UPDATES = 2_000;
+const MAX_ACP_UPDATE_LOG_VALUE_CHARS = 32 * 1024;
+const {
+  isCodexInjectedContextMessage,
+  stripCodexInternalContextBlocks,
+} = require('./codex-transcript-sanitizer');
+
+function clone(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function compactUpdateForLog(update) {
+  let serialized = '';
+  try {
+    serialized = JSON.stringify(update);
+  } catch {
+    return { sessionUpdate: String(update?.sessionUpdate || ''), truncated: true };
+  }
+  if (serialized.length <= MAX_ACP_UPDATE_LOG_VALUE_CHARS) return clone(update);
+  return {
+    sessionUpdate: String(update?.sessionUpdate || ''),
+    toolCallId: String(update?.toolCallId || ''),
+    messageId: String(update?.messageId || ''),
+    truncated: true,
+    originalChars: serialized.length,
+  };
+}
+
+function appendContent(blocks, content) {
+  if (!content || typeof content !== 'object') return;
+  const next = clone(content);
+  const previous = blocks[blocks.length - 1];
+  if (previous?.type === 'text' && next.type === 'text') {
+    previous.text = `${previous.text || ''}${next.text || ''}`;
+    return;
+  }
+  blocks.push(next);
+}
+
+function contentText(content) {
+  return (Array.isArray(content) ? content : [])
+    .filter(block => block?.type === 'text')
+    .map(block => String(block.text || ''))
+    .join('');
+}
+
+function isContextCompactionText(content) {
+  return /^\*?Context compacted(?: to fit the model's context window)?\.?\*?$/i.test(contentText(content).trim());
+}
+
+function canMergeMessageIds(existing, incoming) {
+  return !existing || !incoming || existing === incoming;
+}
+
+class AcpSessionState {
+  constructor(options = {}) {
+    this.provider = String(options.provider || '');
+    this.sessionId = String(options.sessionId || '');
+    this.cwd = String(options.cwd || '');
+    this.maxUpdates = Number.isFinite(options.maxUpdates)
+      ? Math.max(1, Math.floor(options.maxUpdates))
+      : MAX_ACP_UPDATES;
+    // ACP history replay and live session/update notifications both reduce
+    // into this one ordered entry stream. There is deliberately no synthetic
+    // turn model here.
+    this.entries = [];
+    this.updates = [];
+    this.toolEntries = new Map();
+    this.compactionEntries = new Map();
+    this.activePlanEntry = null;
+    this.plan = null;
+    this.usage = null;
+    this.availableCommands = [];
+    this.currentModeId = '';
+    this.configOptions = [];
+    this.title = '';
+    this.updatedAt = '';
+    this.truncated = false;
+    this.sequence = 0;
+    this.revision = Number.isFinite(Number(options.revisionBase))
+      ? Math.max(0, Math.floor(Number(options.revisionBase)))
+      : 0;
+    this.resetBeforeRevision = Number.isFinite(Number(options.resetBeforeRevision))
+      ? Math.max(0, Math.floor(Number(options.resetBeforeRevision)))
+      : 0;
+  }
+
+  setSessionId(sessionId) {
+    this.sessionId = String(sessionId || this.sessionId);
+  }
+
+  nextEntryId(prefix) {
+    return `${prefix}-${++this.sequence}`;
+  }
+
+  pushEntry(entry) {
+    this.touchEntry(entry);
+    this.entries.push(entry);
+    return entry;
+  }
+
+  touchEntry(entry) {
+    if (!entry) return this.revision;
+    entry._revision = ++this.revision;
+    return this.revision;
+  }
+
+  touchCurrentTurn() {
+    const entry = this.entries[this.entries.length - 1];
+    if (entry) this.touchEntry(entry);
+    else this.revision += 1;
+    return this.revision;
+  }
+
+  beginPrompt(prompt) {
+    const content = Array.isArray(prompt)
+      ? clone(prompt)
+      : [{ type: 'text', text: String(prompt || '') }];
+    this.activePlanEntry = null;
+    const startedAt = Date.now();
+    return this.pushEntry({
+      id: this.nextEntryId('user'),
+      type: 'message',
+      role: 'user',
+      messageId: '',
+      optimistic: true,
+      content,
+      turnStartedAt: startedAt,
+      turnCompletedAt: null,
+      turnDurationMs: null,
+    });
+  }
+
+  completePrompt() {
+    // Runtime completion changes the visible state of the last turn. Touch the
+    // existing entry so delta readers can refresh that turn without inventing
+    // a protocol entry boundary.
+    const userEntry = this.entries.findLast(entry => entry?.type === 'message' && entry.role === 'user' && entry.turnStartedAt);
+    if (userEntry && !userEntry.turnCompletedAt) {
+      userEntry.turnCompletedAt = Date.now();
+      const startedAt = Number(userEntry.turnStartedAt);
+      const completedAt = Number(userEntry.turnCompletedAt);
+      userEntry.turnDurationMs = Number.isFinite(startedAt) && Number.isFinite(completedAt)
+        ? Math.max(0, completedAt - startedAt)
+        : null;
+      this.touchEntry(userEntry);
+    } else {
+      this.touchCurrentTurn();
+    }
+  }
+
+  recordError(message, kind = 'unknown') {
+    const text = String(message || '').trim();
+    if (!text) return null;
+    return this.pushEntry({
+      id: this.nextEntryId('error'),
+      type: 'error',
+      message: text,
+      kind: String(kind || 'unknown'),
+      status: 'failed',
+    });
+  }
+
+  finishHistoryReplay() {
+    // History replay uses the same reducer as live updates; nothing to close.
+  }
+
+  apply(notification) {
+    if (!notification || notification.sessionId !== this.sessionId) return false;
+    const update = notification.update;
+    if (!update || typeof update !== 'object') return false;
+    this.updates.push({
+      sequence: this.updates.length + 1,
+      at: new Date().toISOString(),
+      update: compactUpdateForLog(update),
+    });
+    if (this.updates.length > this.maxUpdates) {
+      this.updates.splice(0, this.updates.length - this.maxUpdates);
+      this.truncated = true;
+    }
+
+    const kind = update.sessionUpdate;
+    if (kind === 'user_message_chunk' || kind === 'agent_message_chunk' || kind === 'agent_thought_chunk') {
+      this.applyMessageChunk(update, kind);
+    } else if (kind === 'tool_call') {
+      this.applyToolCall(update, false);
+    } else if (kind === 'tool_call_update') {
+      this.applyToolCall(update, true);
+    } else if (kind === 'plan') {
+      this.applyPlan({ type: 'items', entries: clone(update.entries || []) });
+    } else if (kind === 'plan_update') {
+      this.applyPlan(clone(update.plan));
+    } else if (kind === 'plan_removed') {
+      this.removePlan();
+    } else if (kind === 'context_compaction' || kind === 'context_compaction_update') {
+      this.applyCompaction(update);
+    } else if (kind === 'usage_update') {
+      this.usage = clone(update);
+    } else if (kind === 'available_commands_update') {
+      this.availableCommands = clone(update.availableCommands || []);
+    } else if (kind === 'current_mode_update') {
+      this.currentModeId = String(update.currentModeId || '');
+    } else if (kind === 'config_option_update') {
+      this.configOptions = clone(update.configOptions || []);
+    } else if (kind === 'session_info_update') {
+      if (Object.prototype.hasOwnProperty.call(update, 'title')) this.title = String(update.title || '');
+      if (Object.prototype.hasOwnProperty.call(update, 'updatedAt')) this.updatedAt = String(update.updatedAt || '');
+    }
+    return true;
+  }
+
+  applyMessageChunk(update, kind) {
+    const role = kind === 'user_message_chunk' ? 'user' : 'assistant';
+    const type = kind === 'agent_thought_chunk' ? 'thought' : 'message';
+    const messageId = String(update.messageId || '');
+    const last = this.entries[this.entries.length - 1];
+
+    const compactionMeta = update?._meta?.context_compaction;
+    if (kind === 'agent_message_chunk' && (isContextCompactionText([update.content]) || compactionMeta)) {
+      this.applyCompaction({
+        compactionId: compactionMeta?.id || messageId,
+        status: compactionMeta?.status || 'completed',
+        summary: compactionMeta?.summary || '',
+      });
+      return;
+    }
+
+    // Farming inserts the local prompt optimistically. ACP Agents may echo the
+    // same prompt during live updates; attach its protocol id without rendering
+    // the user message twice.
+    if (
+      role === 'user'
+      && last?.type === 'message'
+      && last.role === 'user'
+      && last.optimistic
+      && (last.content || []).some(content => JSON.stringify(content) === JSON.stringify(update.content))
+    ) {
+      if (!last.messageId) last.messageId = messageId;
+      this.touchEntry(last);
+      return;
+    }
+
+    if (
+      last?.type === type
+      && last.role === role
+      && canMergeMessageIds(last.messageId, messageId)
+    ) {
+      if (!last.messageId) last.messageId = messageId;
+      appendContent(last.content, update.content);
+      this.touchEntry(last);
+      return;
+    }
+
+    if (role === 'user') this.activePlanEntry = null;
+    this.pushEntry({
+      id: messageId || this.nextEntryId(type),
+      type,
+      role,
+      messageId,
+      content: [],
+    });
+    appendContent(this.entries[this.entries.length - 1].content, update.content);
+  }
+
+  applyToolCall(update, isPatch) {
+    const id = String(update.toolCallId || '');
+    if (!id) return;
+    let entry = this.toolEntries.get(id);
+    if (!entry) {
+      entry = this.pushEntry({
+        id,
+        type: 'tool',
+        title: '',
+        kind: 'other',
+        status: 'pending',
+        content: [],
+      });
+      this.toolEntries.set(id, entry);
+    }
+    for (const field of ['title', 'kind', 'status', 'content', 'locations', 'rawInput', 'rawOutput', '_meta']) {
+      if (!isPatch || Object.prototype.hasOwnProperty.call(update, field)) {
+        if (update[field] !== undefined) entry[field] = clone(update[field]);
+      }
+    }
+    this.touchEntry(entry);
+  }
+
+  applyCompaction(update) {
+    const id = String(update.compactionId || update.id || this.nextEntryId('compaction'));
+    let entry = this.compactionEntries.get(id);
+    if (!entry) {
+      entry = this.pushEntry({ id, type: 'compaction', status: 'in_progress', summary: '' });
+      this.compactionEntries.set(id, entry);
+    }
+    if (Object.prototype.hasOwnProperty.call(update, 'status')) entry.status = String(update.status || 'completed');
+    if (Object.prototype.hasOwnProperty.call(update, 'summary')) entry.summary = String(update.summary || '');
+    this.touchEntry(entry);
+  }
+
+  applyPlan(plan) {
+    this.plan = clone(plan);
+    if (!this.activePlanEntry) {
+      this.activePlanEntry = this.pushEntry({
+        id: this.nextEntryId('plan'),
+        type: 'plan',
+        plan: clone(plan),
+      });
+      return;
+    }
+    this.activePlanEntry.plan = clone(plan);
+    this.touchEntry(this.activePlanEntry);
+  }
+
+  removePlan() {
+    if (this.activePlanEntry) {
+      const index = this.entries.indexOf(this.activePlanEntry);
+      if (index >= 0) this.entries.splice(index, 1);
+    }
+    this.activePlanEntry = null;
+    this.plan = null;
+    this.touchCurrentTurn();
+  }
+
+  transcriptSlice(options = {}) {
+    const maxTurns = Number.isFinite(Number(options.maxTurns))
+      ? Math.max(1, Math.floor(Number(options.maxTurns)))
+      : 80;
+    const requestedRevision = Number(options.sinceRevision);
+    const resetRequired = this.resetBeforeRevision > 0
+      && Number.isFinite(requestedRevision)
+      && requestedRevision <= this.resetBeforeRevision;
+    const delta = Number.isFinite(requestedRevision) && requestedRevision >= 0 && !resetRequired;
+    let startIndex = 0;
+
+    if (delta) {
+      startIndex = this.entries.findIndex(entry => Number(entry?._revision || 0) > requestedRevision);
+      if (startIndex < 0) startIndex = this.entries.length;
+      if (startIndex < this.entries.length) {
+        while (startIndex > 0) {
+          const entry = this.entries[startIndex];
+          if (entry?.type === 'message' && entry.role === 'user') break;
+          startIndex -= 1;
+        }
+      }
+    } else {
+      let remaining = maxTurns;
+      startIndex = this.entries.length;
+      while (startIndex > 0) {
+        startIndex -= 1;
+        const entry = this.entries[startIndex];
+        if (entry?.type === 'message' && entry.role === 'user') {
+          remaining -= 1;
+          if (remaining <= 0) break;
+        }
+      }
+    }
+
+    return {
+      entries: this.sanitizedEntries(startIndex, { forTranscript: true }),
+      revision: this.revision,
+      delta,
+      hasMoreBefore: startIndex > 0,
+    };
+  }
+
+  sanitizedEntries(startIndex = 0, options = {}) {
+    const safeStart = Math.min(this.entries.length, Math.max(0, Math.floor(startIndex)));
+    const entries = options.forTranscript === true
+      ? this.entries.slice(safeStart).map(entry => {
+        const visible = { ...entry };
+        delete visible._revision;
+        if (entry.type !== 'tool') return clone(visible);
+        // Tool details are read synchronously by the transcript projector and
+        // never mutated there. Keep their potentially large protocol payloads
+        // by reference so an initial page does not deep-clone megabytes merely
+        // to produce a compact summary.
+        return visible;
+      })
+      : clone(this.entries.slice(safeStart));
+    if (options.forTranscript !== true) {
+      for (const entry of entries) delete entry._revision;
+    }
+    if (this.provider !== 'codex') return entries;
+
+    let internalSegment = false;
+    for (let index = 0; index < safeStart; index += 1) {
+      const entry = this.entries[index];
+      if (entry?.type !== 'message' || entry.role !== 'user') continue;
+      const hasAttachment = (entry.content || []).some(content => content.type !== 'text');
+      internalSegment = !hasAttachment && isCodexInjectedContextMessage(contentText(entry.content));
+    }
+    for (const entry of entries) {
+      if (entry.type === 'message' && entry.role === 'user') {
+        const hasAttachment = (entry.content || []).some(content => content.type !== 'text');
+        const rawText = contentText(entry.content);
+        internalSegment = !hasAttachment && isCodexInjectedContextMessage(rawText);
+      }
+      entry.internal = internalSegment;
+      if (!['message', 'thought'].includes(entry.type)) continue;
+      for (const content of entry.content || []) {
+        if (content.type === 'text') content.text = stripCodexInternalContextBlocks(content.text);
+      }
+    }
+    return entries;
+  }
+
+  isInternalEntry(targetEntry) {
+    if (this.provider !== 'codex' || !targetEntry) return false;
+    let internalSegment = false;
+    for (const entry of this.entries) {
+      if (entry.type === 'message' && entry.role === 'user') {
+        const hasAttachment = (entry.content || []).some(content => content.type !== 'text');
+        internalSegment = !hasAttachment && isCodexInjectedContextMessage(contentText(entry.content));
+      }
+      if (entry === targetEntry) return internalSegment;
+    }
+    return false;
+  }
+
+  snapshot(extra = {}, options = {}) {
+    const entries = options.includeEntries === false ? [] : this.sanitizedEntries(0);
+    const snapshot = {
+      version: 2,
+      protocol: 'acp',
+      provider: this.provider,
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      title: this.title,
+      updatedAt: this.updatedAt || extra.updatedAt || '',
+      truncated: this.truncated,
+      revision: this.revision,
+      entries,
+      usage: clone(this.usage),
+      availableCommands: clone(this.availableCommands),
+      currentModeId: this.currentModeId,
+      configOptions: clone(this.configOptions),
+      ...clone(extra),
+    };
+    if (options.includeUpdates === true) snapshot.updates = clone(this.updates);
+    return snapshot;
+  }
+}
+
+module.exports = {
+  AcpSessionState,
+  MAX_ACP_UPDATES,
+  MAX_ACP_UPDATE_LOG_VALUE_CHARS,
+};

package/backend/acp-transcript.js

@@ -0,0 +1,169 @@
+const { createTwoFilesPatch, diffLines } = require('diff');
+
+const MAX_RENDERED_DIFF_CHARS = 64 * 1024;
+
+function diffBlocks(content) {
+  return (Array.isArray(content) ? content : [])
+    .filter(block => block?.type === 'diff' && typeof block.path === 'string' && block.path.trim());
+}
+
+function diffAction(block) {
+  const kind = String(block?._meta?.kind || '').trim().toLowerCase();
+  if (['add', 'added', 'create', 'created'].includes(kind)) return 'Added';
+  if (['delete', 'deleted', 'remove', 'removed'].includes(kind)) return 'Deleted';
+  if (['move', 'moved'].includes(kind)) return 'Moved';
+  if (['rename', 'renamed'].includes(kind)) return 'Renamed';
+  return 'Updated';
+}
+
+function patchLineStats(oldText, newText) {
+  return diffLines(oldText, newText).reduce((stats, part) => {
+    const count = Number(part.count || 0);
+    if (part.added) stats.added += count;
+    if (part.removed) stats.removed += count;
+    return stats;
+  }, { added: 0, removed: 0 });
+}
+
+function patchChanges(content, options = {}) {
+  return diffBlocks(content).map(block => {
+    const path = String(block.path || '').trim();
+    const oldText = block.oldText == null ? '' : String(block.oldText);
+    const newText = block.newText == null ? '' : String(block.newText);
+    const stats = patchLineStats(oldText, newText);
+    return {
+      path,
+      kind: diffAction(block).toLowerCase(),
+      added: stats.added,
+      removed: stats.removed,
+      ...(options.includeDiff === true
+        ? { diff: boundedDiffText(createTwoFilesPatch(path, path, oldText, newText, 'before', 'after', { context: 3 })) }
+        : {}),
+    };
+  });
+}
+
+function patchReviewChanges(content) {
+  return diffBlocks(content).map(block => ({
+    kind: diffAction(block).toLowerCase(),
+    newText: block.newText == null ? '' : String(block.newText),
+    oldText: block.oldText == null ? '' : String(block.oldText),
+    path: String(block.path || '').trim(),
+  }));
+}
+
+function boundedDiffText(value) {
+  const text = String(value || '');
+  if (text.length <= MAX_RENDERED_DIFF_CHARS) return text;
+  return `${text.slice(0, MAX_RENDERED_DIFF_CHARS)}\n\n[Diff detail truncated]`;
+}
+
+function renderedDiffText(block) {
+  const path = String(block.path || '').trim();
+  const oldText = block.oldText == null ? '' : String(block.oldText);
+  const newText = block.newText == null ? '' : String(block.newText);
+  const patch = createTwoFilesPatch(path, path, oldText, newText, 'before', 'after', { context: 3 });
+  return `File: ${path}\n${boundedDiffText(patch)}`.trim();
+}
+
+function jsonText(value) {
+  if (value === undefined || value === null) return '';
+  if (typeof value === 'string') return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+function toolContentText(content) {
+  return (Array.isArray(content) ? content : []).map(block => {
+    if (!block || typeof block !== 'object') return '';
+    if (block.type === 'content') {
+      const inner = block.content;
+      if (inner?.type === 'text') return String(inner.text || '');
+      if (inner?.type === 'resource_link') return [inner.name, inner.uri].filter(Boolean).join(' — ');
+      if (inner?.type === 'resource') return jsonText(inner.resource);
+      if (inner?.type === 'image') return `[Image: ${inner.mimeType || 'image'}]`;
+      if (inner?.type === 'audio') return `[Audio: ${inner.mimeType || 'audio'}]`;
+      return jsonText(inner);
+    }
+    if (block.type === 'diff') {
+      return renderedDiffText(block);
+    }
+    if (block.type === 'terminal') {
+      const terminal = block.terminal && typeof block.terminal === 'object' ? block.terminal : null;
+      const status = terminal?.exitStatus
+        ? `Exited ${terminal.exitStatus.exitCode ?? terminal.exitStatus.signal ?? ''}`.trim()
+        : 'Running';
+      const output = String(terminal?.output || '').trim();
+      return [`Terminal: ${block.terminalId || ''} (${status})`.trim(), output].filter(Boolean).join('\n');
+    }
+    if (block.type === 'text') return String(block.text || '');
+    return jsonText(block);
+  }).filter(Boolean).join('\n\n').trim();
+}
+
+function equivalentJsonText(text, value) {
+  const candidate = String(text || '').trim();
+  if (!candidate || value === undefined || value === null) return false;
+  if (candidate === jsonText(value).trim()) return true;
+  try {
+    return JSON.stringify(JSON.parse(candidate)) === JSON.stringify(value);
+  } catch {
+    return false;
+  }
+}
+
+function toolOutputText(entry) {
+  const output = entry.rawOutput;
+  if (
+    String(entry.kind || '').toLowerCase() === 'execute'
+    && output
+    && typeof output === 'object'
+    && !Array.isArray(output)
+  ) {
+    const stdout = typeof output.stdout === 'string' ? output.stdout.trimEnd() : '';
+    const stderr = typeof output.stderr === 'string' ? output.stderr.trimEnd() : '';
+    const sections = [];
+    if (stdout) sections.push(stdout);
+    if (stderr) sections.push(`stderr\n${stderr}`);
+    if (output.interrupted === true) sections.push('Interrupted');
+    if (sections.length > 0) return sections.join('\n\n');
+  }
+  return jsonText(output).trim();
+}
+
+function detailForTool(entry) {
+  const sections = [];
+  const rawInput = jsonText(entry.rawInput).trim();
+  // Terminal blocks have a dedicated, live presentation populated by the ACP
+  // client terminal manager. Rendering the same block through generic detail
+  // text duplicates its output directly below the terminal card.
+  let structuredContent = toolContentText(
+    (Array.isArray(entry.content) ? entry.content : []).filter(block => block?.type !== 'terminal')
+  );
+  const rawOutput = toolOutputText(entry);
+  // Some ACP adapters mirror rawOutput as a text content block. Keep the
+  // canonical output once instead of presenting the same JSON twice.
+  if (equivalentJsonText(structuredContent, entry.rawOutput)) structuredContent = '';
+  const locations = (Array.isArray(entry.locations) ? entry.locations : [])
+    .map(location => {
+      const path = String(location?.path || location?.uri || '');
+      const line = location?.line == null ? '' : `:${location.line}`;
+      return `${path}${line}`;
+    })
+    .filter(Boolean)
+    .join('\n');
+  if (rawInput) sections.push(`Input\n${rawInput}`);
+  if (structuredContent) sections.push(structuredContent);
+  if (rawOutput) sections.push(`Output\n${rawOutput}`);
+  if (locations) sections.push(`Locations\n${locations}`);
+  return sections.join('\n\n');
+}
+
+module.exports = {
+  acpToolChanges: entry => patchChanges(entry?.content, { includeDiff: true }),
+  acpToolDetail: detailForTool,
+  acpToolReviewChanges: entry => patchReviewChanges(entry?.content),
+};