farming-code 2.2.6

package/backend/terminal-screen-state.js

@@ -0,0 +1,240 @@
+const { Terminal } = require('@xterm/headless');
+const { SerializeAddon } = require('@xterm/addon-serialize');
+
+const ATTR_BOLD = 0x01;
+const ATTR_ITALIC = 0x02;
+const ATTR_UNDERLINE = 0x04;
+const ATTR_DIM = 0x08;
+const ATTR_INVERSE = 0x10;
+const ATTR_INVISIBLE = 0x20;
+const ATTR_STRIKETHROUGH = 0x40;
+
+function collectViewportText(terminal) {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+
+  for (let y = buffer.viewportY; y < buffer.viewportY + terminal.rows; y += 1) {
+    const line = buffer.getLine(y);
+    lines.push(line ? line.translateToString(true) : '');
+  }
+
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+
+  return lines.join('\n');
+}
+
+function collectViewportSnapshot(terminal) {
+  const buffer = terminal.buffer.active;
+  const fallbackCell = buffer.getNullCell();
+  const cells = [];
+
+  for (let row = 0; row < terminal.rows; row += 1) {
+    const line = buffer.getLine(buffer.viewportY + row);
+    const rowCells = [];
+
+    for (let col = 0; col < terminal.cols; col += 1) {
+      const cell = line ? line.getCell(col, fallbackCell) : fallbackCell;
+      if (!cell) continue;
+
+      const width = cell.getWidth ? cell.getWidth() : 1;
+      if (width === 0) continue;
+
+      let attributes = 0;
+      if (cell.isBold && cell.isBold()) attributes |= ATTR_BOLD;
+      if (cell.isItalic && cell.isItalic()) attributes |= ATTR_ITALIC;
+      if (cell.isUnderline && cell.isUnderline()) attributes |= ATTR_UNDERLINE;
+      if (cell.isDim && cell.isDim()) attributes |= ATTR_DIM;
+      if (cell.isInverse && cell.isInverse()) attributes |= ATTR_INVERSE;
+      if (cell.isInvisible && cell.isInvisible()) attributes |= ATTR_INVISIBLE;
+      if (cell.isStrikethrough && cell.isStrikethrough()) attributes |= ATTR_STRIKETHROUGH;
+
+      const bufferCell = {
+        char: cell.getChars ? (cell.getChars() || ' ') : ' ',
+        width,
+      };
+
+      const fg = cell.getFgColor ? cell.getFgColor() : -1;
+      const bg = cell.getBgColor ? cell.getBgColor() : -1;
+
+      if (Number.isFinite(fg) && fg >= 0) {
+        bufferCell.fg = fg;
+      }
+
+      if (Number.isFinite(bg) && bg >= 0) {
+        bufferCell.bg = bg;
+      }
+
+      if (attributes !== 0) {
+        bufferCell.attributes = attributes;
+      }
+
+      rowCells.push(bufferCell);
+    }
+
+    let lastNonBlankCell = rowCells.length - 1;
+    while (lastNonBlankCell >= 0) {
+      const cell = rowCells[lastNonBlankCell];
+      if (
+        cell.char !== ' ' ||
+        cell.fg !== undefined ||
+        cell.bg !== undefined ||
+        cell.attributes !== undefined
+      ) {
+        break;
+      }
+      lastNonBlankCell -= 1;
+    }
+
+    if (lastNonBlankCell < rowCells.length - 1) {
+      rowCells.splice(Math.max(1, lastNonBlankCell + 1));
+    }
+
+    if (rowCells.length === 0) {
+      rowCells.push({ char: ' ', width: 1 });
+    }
+
+    cells.push(rowCells);
+  }
+
+  return {
+    cols: terminal.cols,
+    rows: terminal.rows,
+    viewportY: buffer.viewportY,
+    cursorX: buffer.cursorX,
+    cursorY: buffer.cursorY,
+    cursorVisible: getTerminalCursorVisible(terminal),
+    cells,
+  };
+}
+
+function getTerminalCursorVisible(terminal) {
+  // xterm does not currently expose DECTCEM through its public buffer API.
+  // The headless core still tracks it, and replay must preserve it to avoid
+  // showing xterm's cursor on top of a TUI-rendered cursor.
+  const isCursorHidden = terminal && terminal._core && terminal._core.coreService
+    ? terminal._core.coreService.isCursorHidden
+    : false;
+  return isCursorHidden !== true;
+}
+
+class TerminalScreenState {
+  constructor(options = {}) {
+    const cols = options.cols || 80;
+    const rows = options.rows || 30;
+    const scrollback = options.scrollback || rows * 8;
+    this.scrollback = scrollback;
+    this.includePreviewSnapshot = options.previewSnapshot !== false;
+
+    this.terminal = new Terminal({
+      cols,
+      rows,
+      scrollback,
+      allowProposedApi: true,
+      convertEol: true,
+    });
+    this.serializeAddon = new SerializeAddon();
+    this.terminal.loadAddon(this.serializeAddon);
+
+    this.title = '';
+    this.renderOutput = '';
+    this.previewText = '';
+    this.previewSnapshot = null;
+    this.renderOutputDirty = true;
+    this.pendingWrite = Promise.resolve();
+
+    this.terminal.onTitleChange((title) => {
+      this.title = title || '';
+    });
+
+    this.refreshPreview();
+  }
+
+  refreshPreview() {
+    this.previewText = collectViewportText(this.terminal);
+    this.previewSnapshot = this.includePreviewSnapshot
+      ? collectViewportSnapshot(this.terminal)
+      : null;
+    this.renderOutputDirty = true;
+  }
+
+  refreshRenderOutput() {
+    const serialized = this.serializeAddon.serialize({
+      scrollback: this.scrollback,
+    });
+    // SerializeAddon preserves screen contents and most terminal modes, but it
+    // omits DECTCEM (CSI ? 25 h/l). Make the cursor state explicit so a fresh
+    // browser terminal does not fall back to its visible-cursor default.
+    this.renderOutput = `${serialized}\x1b[?25${getTerminalCursorVisible(this.terminal) ? 'h' : 'l'}`;
+    this.renderOutputDirty = false;
+  }
+
+  refresh(options = {}) {
+    const includeRenderOutput = options.includeRenderOutput !== false;
+    this.refreshPreview();
+    if (includeRenderOutput) {
+      this.refreshRenderOutput();
+    }
+
+    return this.getState(options);
+  }
+
+  async write(data) {
+    this.pendingWrite = this.pendingWrite.then(
+      () =>
+        new Promise((resolve) => {
+          this.terminal.write(data, () => {
+            this.refreshPreview();
+            resolve(this.getState({ includeRenderOutput: false }));
+          });
+        }),
+    );
+
+    return this.pendingWrite;
+  }
+
+  resize(cols, rows) {
+    this.terminal.resize(cols, rows);
+    return this.refresh({ includeRenderOutput: false });
+  }
+
+  async clearBuffer() {
+    this.pendingWrite = this.pendingWrite.then(
+      () =>
+        new Promise((resolve) => {
+          this.terminal.write('\x1b[2J\x1b[3J\x1b[H', () => {
+            this.refreshPreview();
+            resolve(this.getState({ includeRenderOutput: true }));
+          });
+        }),
+    );
+
+    return this.pendingWrite;
+  }
+
+  getState(options = {}) {
+    const includeRenderOutput = options.includeRenderOutput !== false;
+    if (includeRenderOutput && this.renderOutputDirty) {
+      this.refreshRenderOutput();
+    }
+
+    return {
+      cols: this.terminal.cols,
+      rows: this.terminal.rows,
+      renderOutput: includeRenderOutput ? this.renderOutput : '',
+      previewText: this.previewText,
+      previewSnapshot: this.previewSnapshot,
+      title: this.title,
+    };
+  }
+
+  dispose() {
+    this.terminal.dispose();
+  }
+}
+
+module.exports = TerminalScreenState;
+module.exports.collectViewportText = collectViewportText;
+module.exports.collectViewportSnapshot = collectViewportSnapshot;
+module.exports.getTerminalCursorVisible = getTerminalCursorVisible;

package/backend/terminal-screen-worker-pool.js

@@ -0,0 +1,165 @@
+const TerminalScreenWorker = require('./terminal-screen-worker');
+
+const DEFAULT_POOL_SIZE = 3;
+
+function normalizePoolSize(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return DEFAULT_POOL_SIZE;
+  return Math.max(0, Math.min(12, Math.floor(parsed)));
+}
+
+class TerminalScreenWorkerPool {
+  constructor(options = {}) {
+    this.size = normalizePoolSize(
+      options.size !== undefined
+        ? options.size
+        : process.env.FARMING_TERMINAL_SCREEN_WORKER_POOL_SIZE
+    );
+    this.workerOptions = { ...(options.workerOptions || {}) };
+    this.WorkerClass = options.WorkerClass || TerminalScreenWorker;
+    this.idle = [];
+    this.waiters = [];
+    this.readyWaiters = [];
+    this.pendingStarts = 0;
+    this.disposed = false;
+
+    this.ensureCapacity();
+  }
+
+  getStats() {
+    return {
+      size: this.size,
+      idle: this.idle.length,
+      pendingStarts: this.pendingStarts,
+      waiters: this.waiters.length,
+    };
+  }
+
+  ready() {
+    if (this.disposed) {
+      return Promise.reject(new Error('Terminal screen worker pool is disposed'));
+    }
+    if (this.idle.length >= this.size) {
+      return Promise.resolve(this.getStats());
+    }
+
+    return new Promise((resolve, reject) => {
+      this.readyWaiters.push({ resolve, reject });
+      this.ensureCapacity();
+    });
+  }
+
+  acquire(options = {}) {
+    if (this.disposed) {
+      return Promise.reject(new Error('Terminal screen worker pool is disposed'));
+    }
+    if (this.size <= 0) {
+      return Promise.reject(new Error('Terminal screen worker pool has no workers configured'));
+    }
+
+    const worker = this.idle.shift();
+    if (worker) {
+      this.ensureCapacity();
+      return this.prepareWorker(worker, options);
+    }
+
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject, options });
+      this.ensureCapacity();
+    });
+  }
+
+  ensureCapacity() {
+    if (this.disposed || this.size <= 0) {
+      return;
+    }
+
+    const desiredStarts = this.size + this.waiters.length;
+    while (this.idle.length + this.pendingStarts < desiredStarts) {
+      this.startWorker();
+    }
+  }
+
+  startWorker() {
+    this.pendingStarts += 1;
+    this.createReadyWorker()
+      .then((worker) => {
+        this.pendingStarts -= 1;
+        if (this.disposed) {
+          worker.dispose().catch(() => {});
+          return;
+        }
+        this.deliverWorker(worker);
+      })
+      .catch((error) => {
+        this.pendingStarts -= 1;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+          waiter.reject(error);
+        }
+      })
+      .finally(() => {
+        this.notifyReadyWaiters();
+        this.ensureCapacity();
+      });
+  }
+
+  async createReadyWorker() {
+    const worker = new this.WorkerClass(this.workerOptions);
+    try {
+      await worker.getState({ includeRenderOutput: false });
+      return worker;
+    } catch (error) {
+      try {
+        await worker.dispose();
+      } catch {
+        // best effort
+      }
+      throw error;
+    }
+  }
+
+  async prepareWorker(worker, options = {}) {
+    const cols = Number(options.cols || this.workerOptions.cols || 80);
+    const rows = Number(options.rows || this.workerOptions.rows || 30);
+    if (Number.isFinite(cols) && cols > 0 && Number.isFinite(rows) && rows > 0) {
+      await worker.resize(cols, rows);
+    }
+    return worker;
+  }
+
+  deliverWorker(worker) {
+    const waiter = this.waiters.shift();
+    if (!waiter) {
+      this.idle.push(worker);
+      this.notifyReadyWaiters();
+      return;
+    }
+
+    this.prepareWorker(worker, waiter.options).then(waiter.resolve, waiter.reject);
+  }
+
+  notifyReadyWaiters() {
+    if (this.idle.length < this.size) {
+      return;
+    }
+    const waiters = this.readyWaiters.splice(0);
+    waiters.forEach(({ resolve }) => resolve(this.getStats()));
+  }
+
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+    const error = new Error('Terminal screen worker pool is disposed');
+    this.waiters.splice(0).forEach(({ reject }) => reject(error));
+    this.readyWaiters.splice(0).forEach(({ reject }) => reject(error));
+    const workers = this.idle.splice(0);
+    await Promise.allSettled(workers.map(worker => worker.dispose()));
+  }
+}
+
+module.exports = TerminalScreenWorkerPool;
+module.exports.DEFAULT_POOL_SIZE = DEFAULT_POOL_SIZE;

package/backend/terminal-screen-worker-thread.js

@@ -0,0 +1,161 @@
+const { parentPort, workerData } = require('worker_threads');
+const TerminalScreenState = require('./terminal-screen-state');
+
+const PREVIEW_FLUSH_INTERVAL_MS = 120;
+const MAX_PENDING_DATA_BYTES = 128 * 1024;
+
+const screenState = new TerminalScreenState(workerData || {});
+let pendingData = '';
+let previewFlushTimer = null;
+let lastPreviewText = '';
+let lastTitle = '';
+let lastSnapshotFingerprint = '';
+let messageQueue = Promise.resolve();
+
+function byteLength(value) {
+  return Buffer.byteLength(String(value || ''), 'utf8');
+}
+
+function postPreview(state) {
+  const previewText = state.previewText || '';
+  const title = state.title || '';
+  const previewSnapshot = state.previewSnapshot || null;
+  const snapshotFingerprint = previewSnapshot ? JSON.stringify(previewSnapshot) : '';
+
+  if (previewText === lastPreviewText && title === lastTitle && snapshotFingerprint === lastSnapshotFingerprint) {
+    return;
+  }
+
+  lastPreviewText = previewText;
+  lastTitle = title;
+  lastSnapshotFingerprint = snapshotFingerprint;
+  parentPort.postMessage({
+    type: 'preview',
+    previewText,
+    title,
+    cols: state.cols || 0,
+    rows: state.rows || 0,
+    previewSnapshot,
+  });
+}
+
+async function flushPending(options = {}) {
+  if (previewFlushTimer) {
+    clearTimeout(previewFlushTimer);
+    previewFlushTimer = null;
+  }
+
+  if (pendingData) {
+    const data = pendingData;
+    pendingData = '';
+    const state = await screenState.write(data);
+    if (options.emitPreview !== false) {
+      postPreview(state);
+    }
+    return screenState.getState({ includeRenderOutput: options.includeRenderOutput });
+  }
+
+  const state = screenState.getState({ includeRenderOutput: options.includeRenderOutput });
+  if (options.emitPreview) {
+    postPreview(state);
+  }
+  return state;
+}
+
+function scheduleFlush() {
+  if (previewFlushTimer) {
+    return;
+  }
+
+  previewFlushTimer = setTimeout(() => {
+    flushPending({ includeRenderOutput: false, emitPreview: true }).catch((error) => {
+      parentPort.postMessage({
+        type: 'error',
+        message: error.message,
+      });
+    });
+  }, PREVIEW_FLUSH_INTERVAL_MS);
+}
+
+async function appendData(data) {
+  const text = String(data || '');
+  if (!text) return;
+
+  if (pendingData && byteLength(pendingData) + byteLength(text) > MAX_PENDING_DATA_BYTES) {
+    await flushPending({ includeRenderOutput: false, emitPreview: false });
+  }
+
+  if (byteLength(text) > MAX_PENDING_DATA_BYTES) {
+    const state = await screenState.write(text);
+    postPreview(state);
+    return;
+  }
+
+  pendingData += text;
+  scheduleFlush();
+}
+
+async function handleRequest(message) {
+  switch (message.type) {
+    case 'append':
+      await appendData(message.data);
+      return null;
+    case 'resize': {
+      await flushPending({ includeRenderOutput: false, emitPreview: false });
+      const state = screenState.resize(message.cols, message.rows);
+      postPreview(state);
+      return state;
+    }
+    case 'clear': {
+      await flushPending({ includeRenderOutput: false, emitPreview: false });
+      const state = await screenState.clearBuffer();
+      postPreview(state);
+      return state;
+    }
+    case 'get-state':
+      return flushPending({
+        includeRenderOutput: message.includeRenderOutput !== false,
+        emitPreview: false,
+      });
+    case 'dispose':
+      await flushPending({ includeRenderOutput: false, emitPreview: false });
+      screenState.dispose();
+      return { disposed: true };
+    default:
+      throw new Error(`Unknown worker message type: ${message.type}`);
+  }
+}
+
+async function processMessage(message) {
+  try {
+    const payload = await handleRequest(message);
+    if (message.requestId) {
+      parentPort.postMessage({
+        type: 'response',
+        requestId: message.requestId,
+        payload,
+      });
+    }
+  } catch (error) {
+    if (message.requestId) {
+      parentPort.postMessage({
+        type: 'response',
+        requestId: message.requestId,
+        error: error.message,
+      });
+      return;
+    }
+
+    parentPort.postMessage({
+      type: 'error',
+      message: error.message,
+    });
+  }
+}
+
+parentPort.on('message', (message) => {
+  messageQueue = messageQueue.then(
+    () => processMessage(message),
+    () => processMessage(message),
+  );
+});