farming-code 2.2.6

package/backend/slash-command-discovery.js

@@ -0,0 +1,296 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SAFE_COMMAND_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MAX_SKILL_BYTES = 16 * 1024;
+const MAX_DISCOVERED_SKILLS = 200;
+const LABEL_ACRONYMS = new Map([
+  ['ai', 'AI'],
+  ['api', 'API'],
+  ['bff', 'BFF'],
+  ['ci', 'CI'],
+  ['cli', 'CLI'],
+  ['crt', 'CRT'],
+  ['css', 'CSS'],
+  ['csv', 'CSV'],
+  ['e2e', 'E2E'],
+  ['gh', 'GH'],
+  ['github', 'GitHub'],
+  ['html', 'HTML'],
+  ['json', 'JSON'],
+  ['mcp', 'MCP'],
+  ['pdf', 'PDF'],
+  ['pr', 'PR'],
+  ['sql', 'SQL'],
+  ['ui', 'UI'],
+  ['url', 'URL'],
+  ['ux', 'UX'],
+  ['xml', 'XML'],
+  ['yaml', 'YAML'],
+]);
+
+function normalizeProvider(provider) {
+  const value = String(provider || '').trim().toLowerCase();
+  if (value === 'codex' || value === 'claude') return value;
+  return '';
+}
+
+function normalizeWorkspace(workspace, homeDir = os.homedir()) {
+  if (typeof workspace !== 'string') return '';
+  const value = workspace.trim();
+  if (!value) return '';
+  return path.resolve(value.replace(/^~(?=$|[/\\])/, homeDir));
+}
+
+function commandLabel(name) {
+  return name
+    .split(/[-_.]+/)
+    .filter(Boolean)
+    .map(part => LABEL_ACRONYMS.get(part.toLowerCase()) || part.slice(0, 1).toUpperCase() + part.slice(1))
+    .join(' ') || name;
+}
+
+function readFilePrefix(filePath, limit = MAX_SKILL_BYTES) {
+  let fd = null;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(limit);
+    const bytesRead = fs.readSync(fd, buffer, 0, limit, 0);
+    return buffer.subarray(0, bytesRead).toString('utf8');
+  } catch {
+    return '';
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // Ignore close failures for best-effort discovery.
+      }
+    }
+  }
+}
+
+function parseSkillFrontMatter(skillFile) {
+  const prefix = readFilePrefix(skillFile);
+  const match = prefix.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+  if (!match) return {};
+
+  const metadata = {};
+  match[1].split(/\r?\n/).forEach(line => {
+    const field = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!field) return;
+    const fieldName = field[1];
+    const value = field[2]
+      .trim()
+      .replace(/^['"]|['"]$/g, '')
+      .trim();
+    if (fieldName === 'name' || fieldName === 'description') {
+      metadata[fieldName] = value;
+    }
+  });
+  return metadata;
+}
+
+function findGitRoot(startDir) {
+  let current = startDir;
+  while (current && current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, '.git'))) return current;
+    current = path.dirname(current);
+  }
+  return '';
+}
+
+function workspaceSkillRoots(workspace, homeDir) {
+  const normalizedWorkspace = normalizeWorkspace(workspace, homeDir);
+  if (!normalizedWorkspace) return [];
+
+  const gitRoot = findGitRoot(normalizedWorkspace) || normalizedWorkspace;
+  const roots = [];
+  let current = normalizedWorkspace;
+  while (current && current.startsWith(gitRoot)) {
+    roots.push(path.join(current, '.agents', 'skills'));
+    if (current === gitRoot) break;
+    current = path.dirname(current);
+  }
+  return roots;
+}
+
+function addCommand(commands, command) {
+  const commandId = command.command.toLowerCase();
+  if (commands.some(item => item.command.toLowerCase() === commandId)) return;
+  commands.push(command);
+}
+
+function addSkillMention(commands, skillFile, {
+  mentionPrefix = '',
+  fallbackName = '',
+  scope = 'Personal',
+  source = 'skill',
+} = {}) {
+  const metadata = parseSkillFrontMatter(skillFile);
+  const rawName = String(metadata.name || fallbackName || path.basename(path.dirname(skillFile))).trim();
+  if (!SAFE_COMMAND_NAME.test(rawName)) return;
+  if (mentionPrefix && !SAFE_COMMAND_NAME.test(mentionPrefix)) return;
+
+  const mentionName = mentionPrefix ? `${mentionPrefix}:${rawName}` : rawName;
+  addCommand(commands, {
+    command: `$${mentionName}`,
+    label: commandLabel(rawName),
+    description: metadata.description || `Codex skill from ${scope.toLowerCase()}`,
+    source,
+    scope,
+  });
+}
+
+function discoverClaudeSkillCommands(commands, skillsDir, sourceLabel) {
+  let entries;
+  try {
+    entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  entries.forEach(entry => {
+    if (!entry.isDirectory() || !SAFE_COMMAND_NAME.test(entry.name)) return;
+    if (!fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md'))) return;
+    addCommand(commands, {
+      command: `/${entry.name}`,
+      label: commandLabel(entry.name),
+      description: `Claude skill from ${sourceLabel}`,
+      source: 'skill',
+    });
+  });
+}
+
+function discoverClaudeCustomCommands(commands, commandsDir, sourceLabel) {
+  let entries;
+  try {
+    entries = fs.readdirSync(commandsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  entries.forEach(entry => {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) return;
+    const name = entry.name.slice(0, -3);
+    if (!SAFE_COMMAND_NAME.test(name)) return;
+    addCommand(commands, {
+      command: `/${name}`,
+      label: commandLabel(name),
+      description: `Claude custom command from ${sourceLabel}`,
+      source: 'custom',
+    });
+  });
+}
+
+function discoverClaudeSlashCommands({ homeDir = os.homedir(), workspace } = {}) {
+  const commands = [];
+  const normalizedWorkspace = normalizeWorkspace(workspace, homeDir);
+  const roots = [];
+
+  if (normalizedWorkspace) {
+    roots.push({ root: path.join(normalizedWorkspace, '.claude'), label: 'workspace' });
+  }
+  roots.push({ root: path.join(homeDir, '.claude'), label: 'home' });
+
+  roots.forEach(({ root, label }) => {
+    discoverClaudeSkillCommands(commands, path.join(root, 'skills'), label);
+    discoverClaudeCustomCommands(commands, path.join(root, 'commands'), label);
+  });
+
+  return commands;
+}
+
+function discoverSkillFiles(skillsDir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  return entries
+    .filter(entry => entry.isDirectory() && SAFE_COMMAND_NAME.test(entry.name))
+    .map(entry => path.join(skillsDir, entry.name, 'SKILL.md'))
+    .filter(skillFile => fs.existsSync(skillFile));
+}
+
+function discoverDirectCodexSkills(commands, skillsDir, scope) {
+  discoverSkillFiles(skillsDir).forEach(skillFile => {
+    addSkillMention(commands, skillFile, { scope, source: 'skill' });
+  });
+}
+
+function discoverPluginSkillFiles(root, depth = 0, skillFiles = []) {
+  if (depth > 8 || skillFiles.length >= MAX_DISCOVERED_SKILLS) return skillFiles;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return skillFiles;
+  }
+
+  entries.forEach(entry => {
+    if (skillFiles.length >= MAX_DISCOVERED_SKILLS) return;
+    const entryPath = path.join(root, entry.name);
+    if (entry.isFile() && entry.name === 'SKILL.md' && path.basename(path.dirname(entryPath)) !== 'skills') {
+      skillFiles.push(entryPath);
+      return;
+    }
+    if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+      discoverPluginSkillFiles(entryPath, depth + 1, skillFiles);
+    }
+  });
+
+  return skillFiles;
+}
+
+function pluginNameForSkillFile(skillFile, pluginsCacheDir) {
+  const parts = path.relative(pluginsCacheDir, skillFile).split(path.sep);
+  if (parts[0] === 'openai-curated' && parts[1]) return parts[1];
+  if ((parts[0] === 'openai-primary-runtime' || parts[0] === 'openai-bundled') && parts[1]) return parts[1];
+  return parts[0] || '';
+}
+
+function discoverCodexPluginSkills(commands, homeDir) {
+  const pluginsCacheDir = path.join(homeDir, '.codex', 'plugins', 'cache');
+  discoverPluginSkillFiles(pluginsCacheDir).forEach(skillFile => {
+    const pluginName = pluginNameForSkillFile(skillFile, pluginsCacheDir);
+    addSkillMention(commands, skillFile, {
+      mentionPrefix: pluginName,
+      fallbackName: path.basename(path.dirname(skillFile)),
+      scope: 'Plugin',
+      source: 'skill',
+    });
+  });
+}
+
+function discoverCodexSkillMentions({ homeDir = os.homedir(), workspace } = {}) {
+  const commands = [];
+  workspaceSkillRoots(workspace, homeDir).forEach(root => discoverDirectCodexSkills(commands, root, 'Repo'));
+  discoverDirectCodexSkills(commands, path.join(homeDir, '.agents', 'skills'), 'Personal');
+  discoverDirectCodexSkills(commands, path.join(homeDir, '.codex', 'skills'), 'Personal');
+  discoverDirectCodexSkills(commands, path.join(homeDir, '.codex', 'skills', '.system'), 'System');
+  discoverDirectCodexSkills(commands, path.join('/etc', 'codex', 'skills'), 'Admin');
+  discoverCodexPluginSkills(commands, homeDir);
+  return commands.slice(0, MAX_DISCOVERED_SKILLS);
+}
+
+function discoverSlashCommands({ provider, homeDir = os.homedir(), workspace } = {}) {
+  const normalizedProvider = normalizeProvider(provider);
+  if (normalizedProvider === 'codex') {
+    return discoverCodexSkillMentions({ homeDir, workspace });
+  }
+  if (normalizedProvider === 'claude') {
+    return discoverClaudeSlashCommands({ homeDir, workspace });
+  }
+  return [];
+}
+
+module.exports = {
+  discoverSlashCommands,
+  discoverClaudeSlashCommands,
+  discoverCodexSkillMentions,
+};

package/backend/storage-layout.js

@@ -0,0 +1,101 @@
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+function farmingConfigDir(env = process.env) {
+  return env.FARMING_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.farming');
+}
+
+function settingsFile(configDir) {
+  return path.join(configDir, 'settings.json');
+}
+
+function themeSettingsFile(configDir) {
+  return path.join(configDir, 'theme-settings.json');
+}
+
+function sessionTokenFile(configDir) {
+  return path.join(configDir, '.session-token');
+}
+
+function sessionsDir(configDir) {
+  return path.join(configDir, 'sessions');
+}
+
+function historyDir(configDir) {
+  return path.join(configDir, 'history');
+}
+
+function runHistoryFile(configDir) {
+  return path.join(historyDir(configDir), 'runs.json');
+}
+
+function reviewStateFile(configDir) {
+  return path.join(historyDir(configDir), 'review-state.json');
+}
+
+function reviewSessionsFile(configDir) {
+  return path.join(historyDir(configDir), 'review-sessions.json');
+}
+
+function sessionIndexFile(configDir) {
+  return path.join(sessionsDir(configDir), 'index.json');
+}
+
+function serverPidFile(configDir) {
+  return path.join(configDir, 'farming-server.pid');
+}
+
+function serverStateFile(configDir) {
+  return path.join(configDir, 'farming-server.json');
+}
+
+function serverLogFile(configDir) {
+  return path.join(configDir, 'farming-server.log');
+}
+
+function nativePtyHostLogFile(configDir) {
+  return path.join(configDir, 'native-pty-host.log');
+}
+
+function updateStateFile(configDir) {
+  return path.join(configDir, 'farming-update.json');
+}
+
+function updateLogFile(configDir) {
+  return path.join(configDir, 'farming-update.log');
+}
+
+function codexAppServerRuntimeDir(configDir) {
+  return path.join(configDir, 'c');
+}
+
+function codexAppServerAgentHome(configDir, agentId) {
+  const safeAgentId = String(agentId || '').trim();
+  if (!/^agent-[A-Za-z0-9_-]+$/.test(safeAgentId)) {
+    throw new Error('Invalid Codex App Server agent id');
+  }
+  const homeId = crypto.createHash('sha256').update(safeAgentId).digest('hex').slice(0, 16);
+  return path.join(codexAppServerRuntimeDir(configDir), homeId);
+}
+
+module.exports = {
+  codexAppServerAgentHome,
+  codexAppServerRuntimeDir,
+  farmingConfigDir,
+  historyDir,
+  nativePtyHostLogFile,
+  runHistoryFile,
+  reviewSessionsFile,
+  reviewStateFile,
+  serverLogFile,
+  serverPidFile,
+  serverStateFile,
+  sessionIndexFile,
+  sessionTokenFile,
+  sessionsDir,
+  settingsFile,
+  themeSettingsFile,
+  updateLogFile,
+  updateStateFile,
+};

package/backend/system-monitor.js

@@ -0,0 +1,77 @@
+const os = require('os');
+const path = require('path');
+const fsp = require('fs/promises');
+
+const DISK_STATS_TTL_MS = 30_000;
+
+class SystemMonitor {
+  constructor(options = {}) {
+    this.diskStatsTtlMs = Number.isFinite(options.diskStatsTtlMs) ? options.diskStatsTtlMs : DISK_STATS_TTL_MS;
+    this.now = typeof options.now === 'function' ? options.now : () => Date.now();
+    this.diskStatsCache = {
+      sampledAt: 0,
+      value: null,
+    };
+  }
+
+  async getSystemStats() {
+    const stats = this.getBasicStats();
+    stats.disk = await this.getCachedDiskStats().catch(() => this.diskStatsCache.value || null);
+    return stats;
+  }
+
+  getBasicStats() {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    const cpuCount = Math.max(1, os.cpus().length);
+    const oneMinuteLoad = os.loadavg()[0] || 0;
+
+    return {
+      cpu: Math.max(0, Math.min(100, Math.round((oneMinuteLoad / cpuCount) * 100))),
+      memory: {
+        used: Math.round(usedMem / 1024 / 1024),
+        total: Math.round(totalMem / 1024 / 1024),
+        percentage: Math.round((usedMem / totalMem) * 100)
+      },
+      disk: null,
+      network: null,
+      timestamp: Date.now()
+    };
+  }
+
+  async getCachedDiskStats() {
+    const now = this.now();
+    if (this.diskStatsCache.value && now - this.diskStatsCache.sampledAt < this.diskStatsTtlMs) {
+      return this.diskStatsCache.value;
+    }
+
+    const value = await this.getDiskStats();
+    this.diskStatsCache = {
+      sampledAt: now,
+      value,
+    };
+    return value;
+  }
+
+  async getDiskStats() {
+    if (typeof fsp.statfs !== 'function') return null;
+
+    const root = path.parse(process.cwd()).root || '/';
+    const stat = await fsp.statfs(root);
+    const totalBytes = Number(stat.blocks) * Number(stat.bsize);
+    const freeBytes = Number(stat.bfree) * Number(stat.bsize);
+    const usedBytes = Math.max(0, totalBytes - freeBytes);
+
+    if (!Number.isFinite(totalBytes) || totalBytes <= 0) return null;
+
+    return {
+      used: Math.round(usedBytes / 1024 / 1024 / 1024),
+      total: Math.round(totalBytes / 1024 / 1024 / 1024),
+      percentage: Math.round((usedBytes / totalBytes) * 100)
+    };
+  }
+}
+
+module.exports = SystemMonitor;
+module.exports.DISK_STATS_TTL_MS = DISK_STATS_TTL_MS;

package/backend/terminal-runtime-cleanup.js

@@ -0,0 +1,80 @@
+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,
+};