farming-code 2.2.8 → 2.2.11

package/backend/session-engine-bridge.js

@@ -16,6 +16,9 @@ class SessionEngineBridge extends EventEmitter {
       engine.on('session-output', (payload) => {
         this.emit('session-output', { engineName, ...payload });
       });
+      engine.on('session-transition', (payload) => {
+        this.emit('session-transition', { engineName, ...payload });
+      });
       engine.on('session-sync', (payload) => {
         this.emit('session-sync', { engineName, ...payload });
       });
@@ -54,10 +57,10 @@ class SessionEngineBridge extends EventEmitter {
     return resolution;
   }
 
-  async sendInput(engineName, sessionId, input) {
+  async sendInput(engineName, sessionId, input, options = {}) {
     const engine = this.getEngine(engineName);
     if (!engine) return;
-    return engine.sendInput(sessionId, input);
+    return engine.sendInput(sessionId, input, options);
   }
 
   async resizeSession(engineName, sessionId, cols, rows) {
@@ -84,6 +87,12 @@ class SessionEngineBridge extends EventEmitter {
     return engine.getSessionState(sessionId);
   }
 
+  async getSessionAttachCheckpoint(engineName, sessionId) {
+    const engine = this.getEngine(engineName);
+    if (!engine || !engine.getSessionAttachCheckpoint) return null;
+    return engine.getSessionAttachCheckpoint(sessionId);
+  }
+
   async getSessionPreview(engineName, sessionId) {
     const engine = this.getEngine(engineName);
     if (!engine) return '';
@@ -102,6 +111,16 @@ class SessionEngineBridge extends EventEmitter {
     return recovered;
   }
 
+  consumeRuntimeRotations() {
+    const rotations = [];
+    for (const [engineName, engine] of Object.entries(this.router.engines)) {
+      if (!engine || typeof engine.consumeRuntimeRotation !== 'function') continue;
+      const rotation = engine.consumeRuntimeRotation();
+      if (rotation) rotations.push({ engineName, ...rotation });
+    }
+    return rotations;
+  }
+
   dispose(options = {}) {
     return this.router.dispose(options);
   }

package/backend/session-engine-router.js

@@ -10,7 +10,7 @@ class SessionEngineRouter {
       : process.env.FARMING_NATIVE_PTY_HOST_PERSIST !== '0';
     this.engines = {
       native: new NativeSessionEngine({ configDir, preserveHostOnDispose: preserveNativeHost }),
-      local: new LocalSessionEngine()
+      local: new LocalSessionEngine({ configDir })
     };
     this.overrideEngineName = process.env.FARMING_SESSION_ENGINE || '';
     this.defaultEngineName = options.defaultEngineName || this.overrideEngineName || 'native';

package/backend/session-engine.js

@@ -9,7 +9,7 @@ class SessionEngine extends EventEmitter {
     throw new Error('sendInput() must be implemented by subclasses');
   }
 
-  async interruptSession(_sessionId, _input) {
+  async interruptSession(_sessionId, _input, _options = {}) {
     throw new Error('interruptSession() must be implemented by subclasses');
   }
 

package/backend/session-stream-protocol.js

@@ -0,0 +1,185 @@
+function finiteNumber(value) {
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function transitionKind(value) {
+  return value === 'resize' || value === 'clear' ? value : 'output';
+}
+
+function transitionChunks(stream, data, runtimeEpoch, outputSeq, stateRevision) {
+  if (Array.isArray(stream.chunks)) {
+    return stream.chunks.map(chunk => ({
+      kind: transitionKind(chunk.kind),
+      data: typeof chunk.data === 'string' ? chunk.data : String(chunk.data || ''),
+      runtimeEpoch: nonEmptyString(chunk.runtimeEpoch),
+      outputSeq: finiteNumber(chunk.outputSeq),
+      stateRevision: finiteNumber(chunk.stateRevision),
+      cols: finiteNumber(chunk.cols),
+      rows: finiteNumber(chunk.rows),
+    }));
+  }
+  if (stream.replace === true || !runtimeEpoch || outputSeq === undefined || stateRevision === undefined) {
+    return undefined;
+  }
+  return [{
+    kind: transitionKind(stream.kind),
+    data,
+    runtimeEpoch,
+    outputSeq,
+    stateRevision,
+    cols: finiteNumber(stream.cols),
+    rows: finiteNumber(stream.rows),
+  }];
+}
+
+function normalizeSessionStream(stream) {
+  const data = typeof stream.data === 'string' ? stream.data : String(stream.data || '');
+  const runtimeEpoch = nonEmptyString(stream.runtimeEpoch);
+  const outputSeq = finiteNumber(stream.outputSeq);
+  const stateRevision = finiteNumber(stream.stateRevision);
+  return {
+    ...stream,
+    kind: transitionKind(stream.kind),
+    data,
+    replace: stream.replace === true,
+    runtimeEpoch,
+    outputSeq,
+    stateRevision,
+    cols: finiteNumber(stream.cols),
+    rows: finiteNumber(stream.rows),
+    chunks: transitionChunks(stream, data, runtimeEpoch, outputSeq, stateRevision),
+  };
+}
+
+function coalesceSessionStream(existingStream, incomingStream) {
+  const incoming = normalizeSessionStream(incomingStream);
+  if (!existingStream) {
+    return incoming;
+  }
+
+  const existing = normalizeSessionStream(existingStream);
+  if (incoming.replace) {
+    if (
+      !existing.runtimeEpoch ||
+      !incoming.runtimeEpoch ||
+      existing.runtimeEpoch !== incoming.runtimeEpoch
+    ) {
+      return incoming;
+    }
+    const existingRevision = finiteNumber(existing.stateRevision);
+    const incomingRevision = finiteNumber(incoming.stateRevision);
+    if (
+      existing.replace &&
+      existingRevision !== undefined &&
+      incomingRevision !== undefined &&
+      existingRevision > incomingRevision
+    ) {
+      return existing;
+    }
+    if (incomingRevision === undefined) return incoming;
+    const uncoveredChunks = (existing.chunks || []).filter(chunk => (
+      chunk.runtimeEpoch === incoming.runtimeEpoch &&
+      Number.isFinite(chunk.stateRevision) &&
+      chunk.stateRevision > incomingRevision
+    ));
+    return {
+      ...incoming,
+      chunks: uncoveredChunks.length > 0 ? uncoveredChunks : undefined,
+    };
+  }
+
+  if (
+    !existing.runtimeEpoch ||
+    !incoming.runtimeEpoch ||
+    existing.runtimeEpoch !== incoming.runtimeEpoch
+  ) {
+    return incoming;
+  }
+
+  const incomingHasProof = incoming.outputSeq !== undefined && incoming.stateRevision !== undefined;
+  if (!incomingHasProof) {
+    // Do not let unproved bytes inherit a previous checkpoint's proof. The
+    // browser will enter its checkpoint barrier when it receives this stream.
+    return incoming;
+  }
+
+  if (existing.replace) {
+    return {
+      ...existing,
+      data: existing.data,
+      replace: true,
+      cols: existing.cols,
+      rows: existing.rows,
+      chunks: [
+        ...(existing.chunks || []),
+        ...(incoming.chunks || []),
+      ],
+    };
+  }
+
+  return {
+    ...existing,
+    ...incoming,
+    data: `${existing.data}${incoming.data}`,
+    replace: false,
+    runtimeEpoch: incoming.runtimeEpoch,
+    outputSeq: incoming.outputSeq,
+    stateRevision: incoming.stateRevision,
+    cols: incoming.cols ?? existing.cols,
+    rows: incoming.rows ?? existing.rows,
+    chunks: [
+      ...(existing.chunks || []),
+      ...(incoming.chunks || []),
+    ],
+  };
+}
+
+function shouldBroadcastSessionStreamImmediately(options = {}) {
+  const pendingCount = Number.isFinite(options.pendingCount) ? options.pendingCount : 0;
+  const lastBroadcastAt = Number.isFinite(options.lastBroadcastAt) ? options.lastBroadcastAt : 0;
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const intervalMs = Number.isFinite(options.intervalMs) ? Math.max(0, options.intervalMs) : 0;
+  return pendingCount === 0 && (lastBroadcastAt === 0 || now - lastBroadcastAt >= intervalMs);
+}
+
+function deliverSessionStreamToClients(clients, stream, options = {}) {
+  const openState = options.openState ?? 1;
+  const maxBufferedAmount = Number.isFinite(options.maxBufferedAmount)
+    ? options.maxBufferedAmount
+    : 4 * 1024 * 1024;
+  const message = options.message || JSON.stringify({
+    type: 'session-output',
+    stream,
+  });
+  const result = { sent: 0, closed: 0, skipped: 0 };
+
+  for (const client of clients || []) {
+    if (!client || client.readyState !== openState) {
+      result.skipped += 1;
+      continue;
+    }
+    if (client.streamScope === 'focused' && client.focusedAgentId !== stream.agentId) {
+      result.skipped += 1;
+      continue;
+    }
+    if (client.bufferedAmount > maxBufferedAmount) {
+      client.close(1013, 'terminal stream backpressure');
+      result.closed += 1;
+      continue;
+    }
+    client.send(message);
+    result.sent += 1;
+  }
+  return result;
+}
+
+module.exports = {
+  coalesceSessionStream,
+  deliverSessionStreamToClients,
+  normalizeSessionStream,
+  shouldBroadcastSessionStreamImmediately,
+};

package/backend/storage-layout.js

@@ -22,6 +22,10 @@ function sessionsDir(configDir) {
   return path.join(configDir, 'sessions');
 }
 
+function acpCheckpointsDir(configDir) {
+  return path.join(sessionsDir(configDir), 'acp-checkpoints');
+}
+
 function historyDir(configDir) {
   return path.join(configDir, 'history');
 }
@@ -58,6 +62,22 @@ function nativePtyHostLogFile(configDir) {
   return path.join(configDir, 'native-pty-host.log');
 }
 
+function nativePtyControllerGenerationFile(configDir) {
+  return path.join(configDir, 'native-pty-controller-generation');
+}
+
+function nativePtyControllerGenerationLockDir(configDir) {
+  return path.join(configDir, '.native-pty-controller-generation.lock');
+}
+
+function nativePtyRuntimeGenerationFile(configDir) {
+  return path.join(configDir, 'native-pty-runtime-generation');
+}
+
+function nativePtyRuntimeGenerationLockDir(configDir) {
+  return path.join(configDir, '.native-pty-runtime-generation.lock');
+}
+
 function updateStateFile(configDir) {
   return path.join(configDir, 'farming-update.json');
 }
@@ -66,6 +86,30 @@ function updateLogFile(configDir) {
   return path.join(configDir, 'farming-update.log');
 }
 
+function farmingNetInstancesFile(configDir) {
+  return path.join(configDir, 'instances.json');
+}
+
+function farmingNetServerStateFile(configDir) {
+  return path.join(configDir, 'farming-net-server.json');
+}
+
+function farmingNetServerLogFile(configDir) {
+  return path.join(configDir, 'farming-net-server.log');
+}
+
+function farmingNetSigningPrivateKeyFile(configDir) {
+  return path.join(configDir, 'signing-private-key.pem');
+}
+
+function farmingNetSigningPublicKeyFile(configDir) {
+  return path.join(configDir, 'signing-public-key.pem');
+}
+
+function farmingNetTrustFile(configDir) {
+  return path.join(configDir, 'farming-net-trust.json');
+}
+
 function codexAppServerRuntimeDir(configDir) {
   return path.join(configDir, 'c');
 }
@@ -80,11 +124,22 @@ function codexAppServerAgentHome(configDir, agentId) {
 }
 
 module.exports = {
+  acpCheckpointsDir,
   codexAppServerAgentHome,
   codexAppServerRuntimeDir,
+  farmingNetInstancesFile,
+  farmingNetServerLogFile,
+  farmingNetServerStateFile,
+  farmingNetSigningPrivateKeyFile,
+  farmingNetSigningPublicKeyFile,
+  farmingNetTrustFile,
   farmingConfigDir,
   historyDir,
+  nativePtyControllerGenerationFile,
+  nativePtyControllerGenerationLockDir,
   nativePtyHostLogFile,
+  nativePtyRuntimeGenerationFile,
+  nativePtyRuntimeGenerationLockDir,
   runHistoryFile,
   reviewSessionsFile,
   reviewStateFile,

package/backend/terminal-attach-checkpoint.js

@@ -0,0 +1,74 @@
+const DEFAULT_TERMINAL_ATTACH_CHECKPOINT_TIMEOUT_MS = 2000;
+
+function finiteNonNegativeInteger(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : null;
+}
+
+function finitePositiveInteger(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : null;
+}
+
+async function captureTerminalAttachCheckpoint(session, options = {}) {
+  if (session?.finalCheckpoint) {
+    return { ...session.finalCheckpoint };
+  }
+  if (
+    !session
+    || !session.screenWorker
+    || session.stateProofAvailable === false
+    || typeof session.runtimeEpoch !== 'string'
+    || !session.runtimeEpoch
+  ) {
+    return null;
+  }
+
+  const timeoutMs = Number.isFinite(options.timeoutMs)
+    ? Math.max(1, Math.floor(options.timeoutMs))
+    : DEFAULT_TERMINAL_ATTACH_CHECKPOINT_TIMEOUT_MS;
+  const state = await session.screenWorker.getState({ timeoutMs }).catch(() => null);
+  const outputSeq = finiteNonNegativeInteger(state?.outputSeq);
+  const stateRevision = finiteNonNegativeInteger(state?.stateRevision);
+  const currentOutputSeq = finiteNonNegativeInteger(session.outputSeq);
+  const currentStateRevision = finiteNonNegativeInteger(session.stateRevision);
+  const cols = finitePositiveInteger(state?.cols);
+  const rows = finitePositiveInteger(state?.rows);
+  const requireCurrentCut = options.requireCurrentCut === true;
+
+  if (
+    !state
+    || state.runtimeEpoch !== session.runtimeEpoch
+    || outputSeq === null
+    || stateRevision === null
+    || currentOutputSeq === null
+    || currentStateRevision === null
+    || stateRevision < outputSeq
+    || outputSeq > currentOutputSeq
+    || stateRevision > currentStateRevision
+    || (requireCurrentCut && outputSeq !== currentOutputSeq)
+    || (requireCurrentCut && stateRevision !== currentStateRevision)
+    || cols === null
+    || rows === null
+    || typeof state.renderOutput !== 'string'
+  ) {
+    return null;
+  }
+
+  return {
+    runtimeEpoch: state.runtimeEpoch,
+    renderOutput: state.renderOutput,
+    outputSeq,
+    stateRevision,
+    cols,
+    rows,
+    previewText: typeof state.previewText === 'string' ? state.previewText : '',
+    previewSnapshot: state.previewSnapshot || null,
+    title: typeof state.title === 'string' ? state.title : '',
+  };
+}
+
+module.exports = {
+  DEFAULT_TERMINAL_ATTACH_CHECKPOINT_TIMEOUT_MS,
+  captureTerminalAttachCheckpoint,
+};

package/backend/terminal-exit-quiescence.js

@@ -0,0 +1,39 @@
+const DEFAULT_TERMINAL_EXIT_DATA_FLUSH_MS = 250;
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function acceptTerminalExitData(session) {
+  if (!session || session.exitDataClosed === true) return false;
+  if (session.exitFinalizing === true) {
+    session.exitDataGeneration = (session.exitDataGeneration || 0) + 1;
+  }
+  return true;
+}
+
+async function waitForTerminalExitDataQuiescence(session, options = {}) {
+  const isCurrent = typeof options.isCurrent === 'function' ? options.isCurrent : () => true;
+  const flushMs = Number.isFinite(options.flushMs)
+    ? Math.max(1, Math.floor(options.flushMs))
+    : DEFAULT_TERMINAL_EXIT_DATA_FLUSH_MS;
+  session.exitFinalizing = true;
+  session.exitDataGeneration = session.exitDataGeneration || 0;
+
+  for (;;) {
+    const observedGeneration = session.exitDataGeneration;
+    await delay(flushMs);
+    if (!isCurrent()) return false;
+    if (session.exitDataGeneration !== observedGeneration) continue;
+    // This synchronous cut closes late-data admission before the reducer is
+    // drained and its final checkpoint is captured.
+    session.exitDataClosed = true;
+    return true;
+  }
+}
+
+module.exports = {
+  DEFAULT_TERMINAL_EXIT_DATA_FLUSH_MS,
+  acceptTerminalExitData,
+  waitForTerminalExitDataQuiescence,
+};

package/backend/terminal-reducer-flow-control.js

@@ -0,0 +1,97 @@
+const DEFAULT_REDUCER_HIGH_WATERMARK_BYTES = 512 * 1024;
+const DEFAULT_REDUCER_LOW_WATERMARK_BYTES = 64 * 1024;
+
+function positiveInteger(value, fallback) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function createTerminalReducerFlowControl(options = {}) {
+  const highWatermarkBytes = positiveInteger(
+    options.highWatermarkBytes,
+    DEFAULT_REDUCER_HIGH_WATERMARK_BYTES,
+  );
+  const lowWatermarkBytes = Math.min(
+    highWatermarkBytes,
+    positiveInteger(options.lowWatermarkBytes, DEFAULT_REDUCER_LOW_WATERMARK_BYTES),
+  );
+  return {
+    pendingBytes: 0,
+    paused: false,
+    reducerBlocked: false,
+    externalBlocked: false,
+    highWatermarkBytes,
+    lowWatermarkBytes,
+  };
+}
+
+function ensureTerminalReducerFlowControl(session, options = {}) {
+  if (!session || typeof session !== 'object') {
+    return createTerminalReducerFlowControl(options);
+  }
+  if (!session.reducerFlowControl || typeof session.reducerFlowControl !== 'object') {
+    session.reducerFlowControl = createTerminalReducerFlowControl(options);
+  }
+  return session.reducerFlowControl;
+}
+
+function terminalReducerDataBytes(data) {
+  return Buffer.byteLength(String(data || ''), 'utf8');
+}
+
+function reconcileTerminalFlowControl(control, process) {
+  const shouldPause = control.reducerBlocked || control.externalBlocked;
+  if (shouldPause === control.paused) return null;
+  const method = shouldPause ? 'pause' : 'resume';
+  if (!process || typeof process[method] !== 'function') {
+    return new Error(`Native PTY does not support terminal flow-control ${method}`);
+  }
+  try {
+    process[method]();
+    control.paused = shouldPause;
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+
+function setTerminalExternalFlowControlBlocked(control, process, blocked) {
+  control.externalBlocked = blocked === true;
+  return reconcileTerminalFlowControl(control, process);
+}
+
+function enqueueTerminalReducerData(control, process, data) {
+  const bytes = terminalReducerDataBytes(data);
+  control.pendingBytes += bytes;
+  if (!control.reducerBlocked && control.pendingBytes > control.highWatermarkBytes) {
+    control.reducerBlocked = true;
+  }
+  return { bytes, error: reconcileTerminalFlowControl(control, process) };
+}
+
+function acknowledgeTerminalReducerData(control, process, bytes) {
+  const acknowledgedBytes = Math.max(0, Math.floor(Number(bytes) || 0));
+  control.pendingBytes = Math.max(0, control.pendingBytes - acknowledgedBytes);
+  if (control.reducerBlocked && control.pendingBytes < control.lowWatermarkBytes) {
+    control.reducerBlocked = false;
+  }
+  return reconcileTerminalFlowControl(control, process);
+}
+
+function resetTerminalReducerFlowControl(control, process) {
+  control.pendingBytes = 0;
+  control.reducerBlocked = false;
+  return reconcileTerminalFlowControl(control, process);
+}
+
+module.exports = {
+  DEFAULT_REDUCER_HIGH_WATERMARK_BYTES,
+  DEFAULT_REDUCER_LOW_WATERMARK_BYTES,
+  acknowledgeTerminalReducerData,
+  createTerminalReducerFlowControl,
+  ensureTerminalReducerFlowControl,
+  enqueueTerminalReducerData,
+  resetTerminalReducerFlowControl,
+  setTerminalExternalFlowControlBlocked,
+  terminalReducerDataBytes,
+};

package/backend/terminal-screen-state.js

@@ -141,6 +141,7 @@ class TerminalScreenState {
     this.renderOutput = '';
     this.previewText = '';
     this.previewSnapshot = null;
+    this.previewDirty = false;
     this.renderOutputDirty = true;
     this.pendingWrite = Promise.resolve();
 
@@ -156,6 +157,7 @@ class TerminalScreenState {
     this.previewSnapshot = this.includePreviewSnapshot
       ? collectViewportSnapshot(this.terminal)
       : null;
+    this.previewDirty = false;
     this.renderOutputDirty = true;
   }
 
@@ -185,8 +187,12 @@ class TerminalScreenState {
       () =>
         new Promise((resolve) => {
           this.terminal.write(data, () => {
-            this.refreshPreview();
-            resolve(this.getState({ includeRenderOutput: false }));
+            this.previewDirty = true;
+            this.renderOutputDirty = true;
+            resolve(this.getState({
+              includeRenderOutput: false,
+              refreshPreview: false,
+            }));
           });
         }),
     );
@@ -215,6 +221,9 @@ class TerminalScreenState {
 
   getState(options = {}) {
     const includeRenderOutput = options.includeRenderOutput !== false;
+    if (options.refreshPreview !== false && this.previewDirty) {
+      this.refreshPreview();
+    }
     if (includeRenderOutput && this.renderOutputDirty) {
       this.refreshRenderOutput();
     }