farming-code 2.2.6

package/backend/terminal-screen-worker.js

@@ -0,0 +1,255 @@
+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 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.pendingAppendData = '';
+    this.appendFlushTimer = null;
+    this.requestTimeoutMs = Number.isFinite(options.requestTimeoutMs)
+      ? Math.max(1, Math.floor(options.requestTimeoutMs))
+      : DEFAULT_REQUEST_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;
+    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.emit('error', error);
+    });
+
+    this.worker.on('exit', (code) => {
+      if (this.disposed) {
+        return;
+      }
+
+      const error = new Error(`Terminal screen worker exited unexpectedly with code ${code}`);
+      this.failed = true;
+      this.pendingRequests.forEach(({ reject, timer }) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      this.pendingRequests.clear();
+      this.emit('error', error);
+    });
+  }
+
+  handlePostMessageFailure(error) {
+    if (this.disposed) return;
+    this.failed = true;
+    if (this.appendFlushTimer) {
+      clearTimeout(this.appendFlushTimer);
+      this.appendFlushTimer = null;
+    }
+    this.pendingAppendData = '';
+    this.emit('error', error instanceof Error ? error : new Error(String(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.pendingAppendData) {
+      this.pendingAppendData = '';
+      return;
+    }
+
+    const data = this.pendingAppendData;
+    this.pendingAppendData = '';
+    this.postWorkerMessage({
+      type: 'append',
+      data,
+    });
+  }
+
+  request(type, payload = {}) {
+    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'));
+    }
+
+    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 timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        const error = new Error(`Terminal screen worker request timed out: ${type}`);
+        error.code = 'ETIMEDOUT';
+        reject(error);
+      }, this.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.failed = true;
+        reject(error);
+      }
+    });
+  }
+
+  append(data) {
+    if (this.disposed || this.failed) {
+      return;
+    }
+
+    const text = String(data || '');
+    if (!text) return;
+
+    if (
+      this.pendingAppendData &&
+      byteLength(this.pendingAppendData) + byteLength(text) > MAX_PENDING_APPEND_BYTES
+    ) {
+      this.flushAppend();
+    }
+
+    if (byteLength(text) > MAX_PENDING_APPEND_BYTES) {
+      this.postWorkerMessage({
+        type: 'append',
+        data: text,
+      });
+      return;
+    }
+
+    this.pendingAppendData += text;
+    if (this.appendFlushTimer) {
+      return;
+    }
+
+    this.appendFlushTimer = setTimeout(() => {
+      this.flushAppend();
+    }, APPEND_FLUSH_INTERVAL_MS);
+  }
+
+  resize(cols, rows) {
+    return this.request('resize', { cols, rows });
+  }
+
+  clear() {
+    return this.request('clear');
+  }
+
+  getState(options = {}) {
+    return this.request('get-state', {
+      includeRenderOutput: options.includeRenderOutput !== false,
+    });
+  }
+
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+
+    try {
+      await this.request('dispose');
+    } catch {
+      // best effort
+    }
+    if (this.appendFlushTimer) {
+      clearTimeout(this.appendFlushTimer);
+      this.appendFlushTimer = null;
+    }
+    this.pendingAppendData = '';
+    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;

package/backend/terminal-status.js

@@ -0,0 +1,356 @@
+const SHELL_COMMANDS = new Set(['bash', 'zsh', 'sh', 'fish']);
+const DIRECT_PROCESS_AGENTS = new Set([
+  'opencode',
+  'qoder',
+  'qodercli',
+  'qwen',
+  'aider',
+  'github-copilot-cli',
+  'amazon-q',
+]);
+
+function executableName(command) {
+  const executable = String(command || '')
+    .trim()
+    .split(/\s+/)
+    .find(token => token && token !== 'env' && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(token));
+  return (executable || '').split(/[\\/]/).pop() || '';
+}
+
+function normalizedText(value) {
+  return stripTerminalControlSequences(value).replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+function terminalLines(value) {
+  return stripTerminalControlSequences(value)
+    .replace(/\r/g, '')
+    .split('\n')
+    .map((line) => line.replace(/\s+/g, ' ').trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function stripTerminalControlSequences(value) {
+  return String(value || '')
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+}
+
+function terminalStatusCommand(value) {
+  return stripTerminalControlSequences(value)
+    .replace(/[\x00-\x1f\x7f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function finiteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function lastMatchIndex(text, pattern) {
+  const matches = Array.from(text.matchAll(pattern));
+  const lastMatch = matches.length > 0 ? matches[matches.length - 1] : undefined;
+  return lastMatch && typeof lastMatch.index === 'number' ? lastMatch.index : -1;
+}
+
+function lastIndexOfAny(text, needles) {
+  return needles.reduce((last, needle) => Math.max(last, text.lastIndexOf(needle)), -1);
+}
+
+function lastLineIndexMatching(text, predicate) {
+  let offset = 0;
+  let lastIndex = -1;
+  for (const line of text.split('\n')) {
+    if (predicate(line)) lastIndex = offset;
+    offset += line.length + 1;
+  }
+  return lastIndex;
+}
+
+function lastCodexIdleFooterIndex(text) {
+  return lastMatchIndex(text, /(?:^|\n)\s*(?:gpt|codex)[^\n]*(?:·|•)\s*(?:~|\/)[^\n]*$/gim);
+}
+
+function codexActiveIndex(text) {
+  const activeTextIndex = lastIndexOfAny(text, [
+    'pursuing goal',
+    'reconnecting',
+    '/stop to close',
+    'background terminal running',
+    'messages to be submitted after next tool call',
+    'stream disconnected before completion',
+  ]);
+  const workingIndex = lastMatchIndex(
+    text,
+    /(?:^|\n)[^\n]*\bworking\b[^\n]*(?:(?:esc|escape|ctrl\+c|ctrl-c)\s+to\s+interrupt|step\s+\d+\s*\/\s*\d+)/gim
+  );
+  return Math.max(activeTextIndex, workingIndex);
+}
+
+function codexBlockedIndex(text) {
+  return lastIndexOfAny(text, [
+    'goal blocked',
+    'input exceeds the context window',
+    'please adjust your input and try again',
+  ]);
+}
+
+function lineShowsInterrupt(line) {
+  return /\b(?:press\s+)?(?:esc|escape|ctrl\+c|ctrl-c)\s+to\s+interrupt\b/i.test(line);
+}
+
+function lineShowsClaudeStatusRow(line, excludeBareWorking = false) {
+  const normalized = line.trim().toLowerCase();
+  const match = normalized.match(
+    /^([＊✳✱✲✶✻✽✢])?\s*([\p{L}\p{M}][\p{L}\p{M}'’-]*)(?:\.{3}|…)?\s*\(([^)]*)\)\s*$/u
+  );
+  if (!match || !lineShowsInterrupt(match[3])) return false;
+  if (excludeBareWorking && !match[1] && match[2] === 'working') return false;
+
+  const interruptOnly = /^(?:press\s+)?(?:esc|escape|ctrl\+c|ctrl-c)\s+to\s+interrupt$/i.test(match[3].trim());
+  const hasElapsedTime = /\b\d+(?:\.\d+)?\s*(?:ms|s|m|h)\b/i.test(match[3]);
+  return interruptOnly || hasElapsedTime;
+}
+
+function lineShowsClaudeActivity(line) {
+  const normalized = line.trim().toLowerCase();
+  if (/^(?:press\s+)?(?:esc|escape|ctrl\+c|ctrl-c)\s+to\s+interrupt$/.test(normalized)) return true;
+  return lineShowsClaudeStatusRow(normalized);
+}
+
+function lineShowsClaudeKindEvidence(line) {
+  const normalized = line.trim().toLowerCase();
+  if (/^(?:press\s+)?(?:esc|escape|ctrl\+c|ctrl-c)\s+to\s+interrupt$/.test(normalized)) return true;
+  return lineShowsClaudeStatusRow(normalized, true);
+}
+
+function terminalLineLooksLikeIdleShellPrompt(line) {
+  return /^(?:\s*[│┃]\s*(?:[^$%#\n]+?\s+)?[$%#]|\s*(?:\([^)]+\)\s+)?(?:[\w.-]+@[\w.-]+:)?[~/][\w./~:+-]*\s*[$%#]|\s*[$%#])\s*$/u.test(line);
+}
+
+function latestTerminalKindFromText(title, previewText) {
+  const text = stripTerminalControlSequences(previewText).replace(/\r/g, '').toLowerCase();
+  const candidates = [];
+  const codexIndex = Math.max(lastCodexIdleFooterIndex(text), codexActiveIndex(text));
+  if (codexIndex >= 0) candidates.push({ kind: 'codex', index: codexIndex });
+
+  const claudeIndex = lastLineIndexMatching(text, lineShowsClaudeKindEvidence);
+  if (claudeIndex >= 0) candidates.push({ kind: 'claude', index: claudeIndex });
+
+  const shellIndex = lastLineIndexMatching(text, terminalLineLooksLikeIdleShellPrompt);
+  if (shellIndex >= 0) candidates.push({ kind: 'shell', index: shellIndex });
+
+  const latest = candidates.sort((left, right) => right.index - left.index)[0];
+  if (latest) return latest.kind;
+
+  const normalizedTitle = normalizedText(title);
+  if (/\bclaude\s+code\b/.test(normalizedTitle)) return 'claude';
+  if (/\bcodex\b/.test(normalizedTitle)) return 'codex';
+  return null;
+}
+
+function inferKindFromText(title, previewText, command) {
+  const commandName = executableName(command).toLowerCase();
+  if (commandName === 'claude') return 'claude';
+  if (commandName === 'codex') return 'codex';
+  if (DIRECT_PROCESS_AGENTS.has(commandName)) return 'process';
+  if (commandName && !SHELL_COMMANDS.has(commandName)) return 'process';
+
+  const terminalKind = latestTerminalKindFromText(title, previewText);
+  if (terminalKind) return terminalKind;
+  if (SHELL_COMMANDS.has(commandName)) return 'shell';
+  return commandName ? 'process' : 'unknown';
+}
+
+function terminalTextLooksIdleShellPrompt(previewText) {
+  const lines = stripTerminalControlSequences(previewText)
+    .replace(/\r/g, '')
+    .split('\n')
+    .map(line => line.trimEnd())
+    .filter(Boolean);
+  if (lines.length === 0) return false;
+
+  return terminalLineLooksLikeIdleShellPrompt(lines[lines.length - 1]);
+}
+
+function terminalTitleShowsCodexActivity(title) {
+  return /^[\s]*[\u2800-\u28ff]/u.test(String(title || ''));
+}
+
+function inferCodexActivity(title, previewText) {
+  if (terminalTitleShowsCodexActivity(title)) return 'busy';
+
+  const text = stripTerminalControlSequences(previewText).replace(/\r/g, '').toLowerCase();
+  if (!text.trim()) return 'unknown';
+
+  const idleIndex = lastCodexIdleFooterIndex(text);
+  const blockedIndex = codexBlockedIndex(text);
+  const activeIndex = codexActiveIndex(text);
+  const inactiveIndex = Math.max(idleIndex, blockedIndex);
+  if (activeIndex >= 0) return inactiveIndex > activeIndex ? 'idle' : 'busy';
+  if (inactiveIndex >= 0) return 'idle';
+  return 'unknown';
+}
+
+function inferClaudeActivity(previewText) {
+  const lines = terminalLines(previewText);
+  if (lines.length === 0) return 'unknown';
+  return lines.some(lineShowsClaudeActivity) ? 'busy' : 'idle';
+}
+
+function inferOpenCodeActivity(previewText) {
+  const lines = terminalLines(previewText);
+  if (lines.length === 0) return 'unknown';
+  const tail = lines.slice(-8);
+  let footerIndex = -1;
+  for (let index = 0; index < tail.length; index += 1) {
+    if (/(?:•|·)\s*opencode\s+\d+(?:\.\d+){1,2}\b/.test(tail[index])) footerIndex = index;
+  }
+  if (footerIndex < 0) return 'idle';
+
+  const activeProgress = (line) => (
+    /^(?:[│┃]\s*)?[■⬝⭝]{3,}/u.test(line)
+    && /\b(?:esc|escape|ctrl\+c|ctrl-c)(?:\s+(?:again\s+)?to)?\s+interrupt\b/.test(line)
+  );
+  const activeFooter = activeProgress(tail[footerIndex])
+    || (footerIndex > 0 && activeProgress(tail[footerIndex - 1]));
+  return activeFooter ? 'busy' : 'idle';
+}
+
+function inferQoderLikeActivity(title, previewText, commandName) {
+  const normalizedTitle = stripTerminalControlSequences(title).trim();
+  if (commandName === 'qoder' || commandName === 'qodercli') {
+    if (/^✋/u.test(normalizedTitle)) return 'idle';
+  }
+
+  const lines = terminalLines(previewText);
+  const tail = lines.slice(-8);
+  const active = tail.some((line, index) => {
+    if (!/^[\u2800-\u28ff]/u.test(line)) return false;
+    const loadingWindow = tail.slice(index, index + 3).join(' ');
+    return /\besc\b/.test(loadingWindow)
+      && /\b\d+(?:\.\d+)?\s*(?:ms|s|m|h)\b/.test(loadingWindow);
+  });
+  if (active) return 'busy';
+
+  if (commandName === 'qoder' || commandName === 'qodercli') {
+    if (/^[✦⏲]/u.test(normalizedTitle)) return 'busy';
+    if (/^◇/u.test(normalizedTitle)) return 'idle';
+  }
+  return lines.length > 0 || normalizedTitle ? 'idle' : 'unknown';
+}
+
+function inferGenericActivity(previewText, terminalBusy) {
+  if (terminalBusy === true) return 'busy';
+  if (terminalBusy === false) return 'idle';
+
+  if (terminalTextLooksIdleShellPrompt(previewText)) return 'idle';
+  return 'unknown';
+}
+
+function nestedProcessCommandFromTitle(title) {
+  const normalizedTitle = stripTerminalControlSequences(title).trim();
+  if (/^oc\s*\|/i.test(normalizedTitle)) return 'opencode';
+  if (/^[◇✋✦⏲]/u.test(normalizedTitle)) return 'qodercli';
+  if (/^qwen\b/i.test(normalizedTitle)) return 'qwen';
+  return '';
+}
+
+function deriveTerminalStatus(options = {}) {
+  const title = typeof options.title === 'string' ? options.title : '';
+  const previewText = typeof options.previewText === 'string' ? options.previewText : '';
+  const terminalBusy = typeof options.terminalBusy === 'boolean' ? options.terminalBusy : null;
+  const hasShellStatus = options.shellLastEvent === 'start'
+    || options.shellLastEvent === 'finish'
+    || typeof options.shellLastExitCode === 'number';
+  const commandName = executableName(options.command).toLowerCase();
+  const runningCommandName = executableName(options.shellCommand).toLowerCase();
+  const launchedFromShell = SHELL_COMMANDS.has(commandName);
+  let activityCommandName = commandName;
+  let kind;
+  if (launchedFromShell && runningCommandName) {
+    activityCommandName = runningCommandName;
+    if (runningCommandName === 'codex') kind = 'codex';
+    else if (runningCommandName === 'claude') kind = 'claude';
+    else if (DIRECT_PROCESS_AGENTS.has(runningCommandName)) kind = 'process';
+    else kind = 'shell';
+  } else {
+    const nestedProcessCommand = launchedFromShell && !terminalTextLooksIdleShellPrompt(previewText)
+      ? nestedProcessCommandFromTitle(title)
+      : '';
+    if (nestedProcessCommand) {
+      activityCommandName = nestedProcessCommand;
+      kind = 'process';
+    } else {
+      kind = inferKindFromText(title, previewText, options.command);
+    }
+  }
+  const shellActivity = kind === 'shell';
+  const hasPromptIdleFallback = options.status !== 'exited'
+    && shellActivity
+    && terminalBusy === true
+    && terminalTextLooksIdleShellPrompt(previewText);
+  let activity = 'unknown';
+  if (options.status === 'exited') {
+    activity = 'exited';
+  } else if (hasPromptIdleFallback) {
+    activity = 'idle';
+  } else if (!SHELL_COMMANDS.has(commandName) && terminalBusy !== null) {
+    activity = terminalBusy ? 'busy' : 'idle';
+  } else if (kind === 'codex') {
+    activity = inferCodexActivity(title, previewText);
+  } else if (kind === 'claude') {
+    activity = inferClaudeActivity(previewText);
+  } else if (activityCommandName === 'opencode') {
+    activity = inferOpenCodeActivity(previewText);
+  } else if (activityCommandName === 'qoder'
+    || activityCommandName === 'qodercli'
+    || activityCommandName === 'qwen') {
+    activity = inferQoderLikeActivity(title, previewText, activityCommandName);
+  } else {
+    activity = inferGenericActivity(previewText, terminalBusy);
+  }
+
+  const status = {
+    kind,
+    activity,
+    busy: activity === 'busy',
+    cwd: typeof options.cwd === 'string' ? options.cwd : '',
+    title,
+    lastExitCode: typeof options.shellLastExitCode === 'number' ? options.shellLastExitCode : null,
+    source: hasPromptIdleFallback
+      ? 'shell-prompt-fallback'
+      : (shellActivity && hasShellStatus
+        ? 'shell-status-marker'
+        : (shellActivity && terminalBusy !== null ? 'shell-busy-marker' : 'terminal-text')),
+  };
+  const runningCommand = terminalStatusCommand(options.shellCommand);
+  const lastCommand = terminalStatusCommand(options.shellLastCommand);
+  const runningCommandStartedAt = finiteNumber(options.shellCommandStartedAt);
+  const lastCommandStartedAt = finiteNumber(options.shellLastCommandStartedAt);
+  const lastCommandFinishedAt = finiteNumber(options.shellLastCommandFinishedAt);
+  const lastCommandDurationMs = finiteNumber(options.shellLastCommandDurationMs);
+  if (runningCommand) {
+    status.runningCommand = runningCommand;
+  }
+  if (runningCommandStartedAt !== null) {
+    status.runningCommandStartedAt = runningCommandStartedAt;
+  }
+  if (lastCommand) {
+    status.lastCommand = lastCommand;
+  }
+  if (lastCommandStartedAt !== null) {
+    status.lastCommandStartedAt = lastCommandStartedAt;
+  }
+  if (lastCommandFinishedAt !== null) {
+    status.lastCommandFinishedAt = lastCommandFinishedAt;
+  }
+  if (lastCommandDurationMs !== null) {
+    status.lastCommandDurationMs = lastCommandDurationMs;
+  }
+  return status;
+}
+
+module.exports = {
+  deriveTerminalStatus,
+  terminalTextLooksIdleShellPrompt,
+};