farming-code 2.2.29 → 2.2.32

package/backend/terminal-attach-checkpoint.js

@@ -1,74 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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-runtime-cleanup.js

@@ -1,80 +0,0 @@
-const fs = require('fs');
-const net = require('net');
-const os = require('os');
-const path = require('path');
-const { nativePtyHostSocketPath } = require('./native-pty-host-path');
-
-function canUseUnixSocket(socketPath) {
-  return process.platform !== 'win32' && typeof socketPath === 'string' && socketPath.length > 0;
-}
-
-function socketExists(socketPath) {
-  try {
-    fs.accessSync(socketPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function probeUnixSocket(socketPath, timeoutMs = 120) {
-  if (!canUseUnixSocket(socketPath)) {
-    return Promise.resolve({ active: false, code: 'unsupported' });
-  }
-
-  return new Promise(resolve => {
-    const socket = net.createConnection(socketPath);
-    let settled = false;
-    const finish = result => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      socket.destroy();
-      resolve(result);
-    };
-    const timer = setTimeout(() => finish({ active: false, code: 'timeout' }), timeoutMs);
-    if (typeof timer.unref === 'function') timer.unref();
-    socket.once('connect', () => finish({ active: true }));
-    socket.once('error', error => finish({ active: false, code: error && error.code ? error.code : 'error' }));
-  });
-}
-
-async function cleanupStaleNativePtySocket(options = {}) {
-  const socketPath = options.socketPath || nativePtyHostSocketPath(options.configDir);
-  if (!canUseUnixSocket(socketPath) || !socketExists(socketPath)) {
-    return { socketPath, removed: false, active: false };
-  }
-
-  const probe = await probeUnixSocket(socketPath, options.timeoutMs);
-  if (probe.active) {
-    return { socketPath, removed: false, active: true };
-  }
-
-  try {
-    fs.unlinkSync(socketPath);
-    return { socketPath, removed: true, active: false, code: probe.code };
-  } catch (error) {
-    if (error && error.code === 'ENOENT') {
-      return { socketPath, removed: false, active: false, code: probe.code };
-    }
-    throw error;
-  }
-}
-
-async function cleanupTerminalRuntime(options = {}) {
-  if (process.env.FARMING_SKIP_TERMINAL_RUNTIME_CLEANUP === '1') {
-    return { skipped: true };
-  }
-
-  const configDir = options.configDir || process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), '.farming');
-
-  return {
-    nativeSocket: await cleanupStaleNativePtySocket({ ...options, configDir }),
-  };
-}
-
-module.exports = {
-  cleanupStaleNativePtySocket,
-  cleanupTerminalRuntime,
-  probeUnixSocket,
-};

package/backend/terminal-screen-worker.js

@@ -1,337 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const EventEmitter = require('events');
-const { Worker } = require('worker_threads');
-
-const APPEND_FLUSH_INTERVAL_MS = 16;
-const MAX_PENDING_APPEND_BYTES = 128 * 1024;
-const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-const DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS = 5000;
-const PACKAGED_WORKER_FILE = 'terminal-screen-worker-thread.pkg.js';
-const SOURCE_WORKER_FILE = 'terminal-screen-worker-thread.js';
-
-function byteLength(value) {
-  return Buffer.byteLength(String(value || ''), 'utf8');
-}
-
-function resolveWorkerFile() {
-  const wantsPackagedWorker = process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1';
-  if (!wantsPackagedWorker) return SOURCE_WORKER_FILE;
-
-  const packagedWorkerPath = path.join(__dirname, PACKAGED_WORKER_FILE);
-  return fs.existsSync(packagedWorkerPath)
-    ? PACKAGED_WORKER_FILE
-    : SOURCE_WORKER_FILE;
-}
-
-class TerminalScreenWorker extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.nextRequestId = 1;
-    this.pendingRequests = new Map();
-    this.pendingAppendEntries = [];
-    this.pendingAppendBytes = 0;
-    this.pendingAppendWaiters = [];
-    this.appendFlushTimer = null;
-    this.stateRequestInFlight = null;
-    this.requestTimeoutMs = Number.isFinite(options.requestTimeoutMs)
-      ? Math.max(1, Math.floor(options.requestTimeoutMs))
-      : DEFAULT_REQUEST_TIMEOUT_MS;
-    this.stateRequestHardTimeoutMs = Number.isFinite(options.stateRequestHardTimeoutMs)
-      ? Math.max(1, Math.floor(options.stateRequestHardTimeoutMs))
-      : Math.min(this.requestTimeoutMs, DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS);
-    this.failed = false;
-    this.disposed = false;
-    const workerFile = resolveWorkerFile();
-    const WorkerClass = options.WorkerClass || Worker;
-    const workerData = { ...options };
-    delete workerData.WorkerClass;
-    delete workerData.requestTimeoutMs;
-    delete workerData.stateRequestHardTimeoutMs;
-    this.worker = new WorkerClass(path.join(__dirname, workerFile), {
-      workerData,
-    });
-
-    this.worker.on('message', (message) => {
-      if (!message || typeof message !== 'object') {
-        return;
-      }
-
-      if (message.type === 'preview') {
-        this.emit('preview', {
-          previewText: message.previewText || '',
-          title: message.title || '',
-          cols: message.cols || 0,
-          rows: message.rows || 0,
-          previewSnapshot: message.previewSnapshot || null,
-        });
-        return;
-      }
-
-      if (message.type === 'response' && message.requestId) {
-        const pending = this.pendingRequests.get(message.requestId);
-        if (!pending) return;
-        this.pendingRequests.delete(message.requestId);
-        clearTimeout(pending.timer);
-        if (message.error) {
-          pending.reject(new Error(message.error));
-          return;
-        }
-        pending.resolve(message.payload);
-        return;
-      }
-
-      if (message.type === 'error') {
-        this.emit('error', new Error(message.message || 'Unknown worker error'));
-      }
-    });
-
-    this.worker.on('error', (error) => {
-      this.handleWorkerFailure(error);
-    });
-
-    this.worker.on('exit', (code) => {
-      if (this.disposed) {
-        return;
-      }
-
-      this.handleWorkerFailure(new Error(`Terminal screen worker exited unexpectedly with code ${code}`));
-    });
-  }
-
-  handleWorkerFailure(error) {
-    if (this.disposed) return;
-    const failure = error instanceof Error ? error : new Error(String(error));
-    const shouldEmit = !this.failed;
-    this.failed = true;
-    if (this.appendFlushTimer) {
-      clearTimeout(this.appendFlushTimer);
-      this.appendFlushTimer = null;
-    }
-    this.pendingAppendEntries = [];
-    this.pendingAppendBytes = 0;
-    this.pendingAppendWaiters.splice(0).forEach(({ reject }) => reject(failure));
-    this.pendingRequests.forEach(({ reject, timer }) => {
-      clearTimeout(timer);
-      reject(failure);
-    });
-    this.pendingRequests.clear();
-    if (shouldEmit && this.listenerCount('error') > 0) {
-      this.emit('error', failure);
-    }
-  }
-
-  handlePostMessageFailure(error) {
-    this.handleWorkerFailure(error);
-  }
-
-  postWorkerMessage(message, options = {}) {
-    try {
-      this.worker.postMessage(message);
-      return true;
-    } catch (error) {
-      if (options.throwOnError) throw error;
-      this.handlePostMessageFailure(error);
-      return false;
-    }
-  }
-
-  flushAppend() {
-    if (this.appendFlushTimer) {
-      clearTimeout(this.appendFlushTimer);
-      this.appendFlushTimer = null;
-    }
-    if (this.disposed || this.failed || this.pendingAppendEntries.length === 0) {
-      this.pendingAppendEntries = [];
-      this.pendingAppendBytes = 0;
-      return;
-    }
-
-    const entries = this.pendingAppendEntries;
-    const waiters = this.pendingAppendWaiters;
-    this.pendingAppendEntries = [];
-    this.pendingAppendBytes = 0;
-    this.pendingAppendWaiters = [];
-    this.request('append', { entries }, { flushAppend: false }).then(
-      state => waiters.forEach(({ resolve }) => resolve(state)),
-      error => waiters.forEach(({ reject }) => reject(error)),
-    );
-  }
-
-  request(type, payload = {}, options = {}) {
-    if (this.disposed) {
-      return Promise.reject(new Error('Terminal screen worker is disposed'));
-    }
-    if (this.failed) {
-      return Promise.reject(new Error('Terminal screen worker is not available'));
-    }
-
-    if (options.flushAppend !== false) {
-      this.flushAppend();
-    }
-    if (this.failed) {
-      return Promise.reject(new Error('Terminal screen worker is not available'));
-    }
-    const requestId = this.nextRequestId;
-    this.nextRequestId += 1;
-
-    return new Promise((resolve, reject) => {
-      const requestTimeoutMs = Number.isFinite(options.timeoutMs)
-        ? Math.max(1, Math.floor(options.timeoutMs))
-        : this.requestTimeoutMs;
-      const timer = setTimeout(() => {
-        this.pendingRequests.delete(requestId);
-        const error = new Error(`Terminal screen worker request timed out: ${type}`);
-        error.code = 'ETIMEDOUT';
-        reject(error);
-      }, requestTimeoutMs);
-      if (typeof timer.unref === 'function') timer.unref();
-
-      this.pendingRequests.set(requestId, { resolve, reject, timer });
-      try {
-        this.postWorkerMessage({
-          requestId,
-          type,
-          ...payload,
-        }, { throwOnError: true });
-      } catch (error) {
-        this.pendingRequests.delete(requestId);
-        clearTimeout(timer);
-        this.handlePostMessageFailure(error);
-        reject(error);
-      }
-    });
-  }
-
-  append(data, stateRevision, outputSeq = null) {
-    if (this.disposed || this.failed) {
-      return Promise.reject(new Error('Terminal screen worker is not available'));
-    }
-
-    const text = String(data || '');
-    if (!text) return;
-    if (!Number.isFinite(stateRevision)) {
-      this.handlePostMessageFailure(new Error('Terminal screen append requires a finite state revision'));
-      return Promise.reject(new Error('Terminal screen append requires a finite state revision'));
-    }
-
-    if (
-      this.pendingAppendEntries.length > 0 &&
-      this.pendingAppendBytes + byteLength(text) > MAX_PENDING_APPEND_BYTES
-    ) {
-      this.flushAppend();
-    }
-
-    return new Promise((resolve, reject) => {
-      this.pendingAppendEntries.push({ data: text, stateRevision, outputSeq });
-      this.pendingAppendBytes += byteLength(text);
-      this.pendingAppendWaiters.push({ resolve, reject });
-      if (byteLength(text) > MAX_PENDING_APPEND_BYTES) {
-        this.flushAppend();
-        return;
-      }
-      if (this.appendFlushTimer) return;
-      this.appendFlushTimer = setTimeout(() => {
-        this.flushAppend();
-      }, APPEND_FLUSH_INTERVAL_MS);
-    });
-  }
-
-  resize(cols, rows, stateRevision) {
-    return this.request('resize', { cols, rows, stateRevision });
-  }
-
-  setRuntimeEpoch(runtimeEpoch, cols, rows) {
-    return this.request('set-runtime-epoch', { runtimeEpoch, cols, rows });
-  }
-
-  clear(stateRevision, outputSeq = null) {
-    return this.request('clear', { stateRevision, outputSeq });
-  }
-
-  getState(options = {}) {
-    if (!this.stateRequestInFlight) {
-      const request = this.request('get-state', {
-        // A full checkpoint can satisfy callers that only need metadata too,
-        // while the reverse would make coalescing unsafe.
-        includeRenderOutput: true,
-      }, {
-        // Caller deadlines are deliberately softer than this shared deadline.
-        // A timed-out caller may stop waiting, but the single-flight itself
-        // must never poison every later checkpoint for the generic 30s worker
-        // request timeout. Crossing this hard deadline means the authoritative
-        // reducer can no longer prove progress, so fail it closed.
-        timeoutMs: this.stateRequestHardTimeoutMs,
-      });
-      const sharedRequest = request.catch((error) => {
-        if (error && error.code === 'ETIMEDOUT') {
-          this.handleWorkerFailure(error);
-        }
-        throw error;
-      }).finally(() => {
-        if (this.stateRequestInFlight === sharedRequest) {
-          this.stateRequestInFlight = null;
-        }
-      });
-      this.stateRequestInFlight = sharedRequest;
-    }
-
-    const sharedRequest = this.stateRequestInFlight;
-    const timeoutMs = Number.isFinite(options.timeoutMs)
-      ? Math.max(1, Math.floor(options.timeoutMs))
-      : null;
-    if (timeoutMs === null) return sharedRequest;
-
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        const error = new Error('Terminal screen worker request timed out: get-state');
-        error.code = 'ETIMEDOUT';
-        reject(error);
-      }, timeoutMs);
-      if (typeof timer.unref === 'function') timer.unref();
-      sharedRequest.then(
-        (state) => {
-          clearTimeout(timer);
-          resolve(state);
-        },
-        (error) => {
-          clearTimeout(timer);
-          reject(error);
-        },
-      );
-    });
-  }
-
-  async dispose() {
-    if (this.disposed) {
-      return;
-    }
-
-    try {
-      await this.request('dispose');
-    } catch {
-      // best effort
-    }
-    if (this.appendFlushTimer) {
-      clearTimeout(this.appendFlushTimer);
-      this.appendFlushTimer = null;
-    }
-    this.pendingAppendEntries = [];
-    this.pendingAppendBytes = 0;
-    this.pendingAppendWaiters.splice(0).forEach(({ reject }) => {
-      reject(new Error('Terminal screen worker is disposed'));
-    });
-    this.disposed = true;
-    this.pendingRequests.forEach(({ reject, timer }) => {
-      clearTimeout(timer);
-      reject(new Error('Terminal screen worker disposed'));
-    });
-    this.pendingRequests.clear();
-    await this.worker.terminate();
-  }
-}
-
-module.exports = TerminalScreenWorker;
-module.exports.resolveWorkerFile = resolveWorkerFile;
-module.exports.DEFAULT_REQUEST_TIMEOUT_MS = DEFAULT_REQUEST_TIMEOUT_MS;
-module.exports.DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS = DEFAULT_STATE_REQUEST_HARD_TIMEOUT_MS;

package/backend/terminal-state-serialization.js

@@ -1,127 +0,0 @@
-const TERMINAL_STATE_VERSION = 1;
-const MAX_SERIALIZED_TERMINAL_STATE_BYTES = 32 * 1024 * 1024;
-const MAX_REPLAY_EVENT_BYTES = 8 * 1024 * 1024;
-
-function finitePositiveInteger(value, fallback) {
-  const parsed = Math.floor(Number(value));
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-
-function normalizeReplayEvent(replayEvent) {
-  const events = Array.isArray(replayEvent?.events) ? replayEvent.events : [];
-  if (events.length !== 1) {
-    throw new Error('Serialized terminal state requires exactly one replay event');
-  }
-  const event = events[0] || {};
-  const data = typeof event.data === 'string' ? event.data : '';
-  if (Buffer.byteLength(data, 'utf8') > MAX_REPLAY_EVENT_BYTES) {
-    throw new Error('Serialized terminal replay event exceeds the size limit');
-  }
-  return {
-    events: [{
-      data,
-      cols: finitePositiveInteger(event.cols, 80),
-      rows: finitePositiveInteger(event.rows, 30),
-    }],
-  };
-}
-
-function normalizeTerminalStateEntry(entry) {
-  if (!entry || typeof entry !== 'object') {
-    throw new Error('Serialized terminal state entry must be an object');
-  }
-  const id = typeof entry.id === 'string' ? entry.id.trim() : '';
-  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(id)) {
-    throw new Error('Serialized terminal state has an invalid session id');
-  }
-  const metadata = entry.metadata && typeof entry.metadata === 'object' && !Array.isArray(entry.metadata)
-    ? { ...entry.metadata }
-    : {};
-  const processDetails = entry.processDetails && typeof entry.processDetails === 'object'
-    ? entry.processDetails
-    : {};
-  const processLaunchConfig = entry.processLaunchConfig && typeof entry.processLaunchConfig === 'object'
-    ? entry.processLaunchConfig
-    : {};
-  return {
-    id,
-    metadata: {
-      ...metadata,
-      agentId: id,
-    },
-    processDetails: {
-      cwd: typeof processDetails.cwd === 'string' ? processDetails.cwd : '',
-      title: typeof processDetails.title === 'string' ? processDetails.title : '',
-    },
-    processLaunchConfig: {
-      command: typeof processLaunchConfig.command === 'string' ? processLaunchConfig.command : '',
-      args: Array.isArray(processLaunchConfig.args)
-        ? processLaunchConfig.args.filter(arg => typeof arg === 'string')
-        : [],
-      category: typeof processLaunchConfig.category === 'string' ? processLaunchConfig.category : '',
-    },
-    replayEvent: normalizeReplayEvent(entry.replayEvent),
-    timestamp: Number.isFinite(Number(entry.timestamp))
-      ? Math.max(0, Math.floor(Number(entry.timestamp)))
-      : Date.now(),
-  };
-}
-
-function serializeTerminalState(entries) {
-  const state = (Array.isArray(entries) ? entries : []).map(normalizeTerminalStateEntry);
-  const ids = new Set();
-  for (const entry of state) {
-    if (ids.has(entry.id)) {
-      throw new Error(`Serialized terminal state contains duplicate session id ${entry.id}`);
-    }
-    ids.add(entry.id);
-  }
-  const serialized = JSON.stringify({
-    version: TERMINAL_STATE_VERSION,
-    state,
-  });
-  if (Buffer.byteLength(serialized, 'utf8') > MAX_SERIALIZED_TERMINAL_STATE_BYTES) {
-    throw new Error('Serialized terminal state exceeds the size limit');
-  }
-  return serialized;
-}
-
-function deserializeTerminalState(serialized) {
-  if (typeof serialized !== 'string' || !serialized) return [];
-  if (Buffer.byteLength(serialized, 'utf8') > MAX_SERIALIZED_TERMINAL_STATE_BYTES) {
-    throw new Error('Serialized terminal state exceeds the size limit');
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(serialized);
-  } catch {
-    throw new Error('Serialized terminal state is not valid JSON');
-  }
-  if (!parsed || typeof parsed !== 'object' || parsed.version !== TERMINAL_STATE_VERSION || !Array.isArray(parsed.state)) {
-    throw new Error('Serialized terminal state has an unsupported format or version');
-  }
-  const state = parsed.state.map(normalizeTerminalStateEntry);
-  const ids = new Set();
-  for (const entry of state) {
-    if (ids.has(entry.id)) {
-      throw new Error(`Serialized terminal state contains duplicate session id ${entry.id}`);
-    }
-    ids.add(entry.id);
-  }
-  return state;
-}
-
-function terminalReplayText(entry) {
-  const normalized = normalizeTerminalStateEntry(entry);
-  return normalized.replayEvent.events[0].data;
-}
-
-module.exports = {
-  MAX_REPLAY_EVENT_BYTES,
-  MAX_SERIALIZED_TERMINAL_STATE_BYTES,
-  TERMINAL_STATE_VERSION,
-  deserializeTerminalState,
-  normalizeTerminalStateEntry,
-  serializeTerminalState,
-  terminalReplayText,
-};