farming-code 2.2.27 → 2.2.29

package/backend/farming-app-cli.js

@@ -8,6 +8,12 @@ const { URLSearchParams } = require('url');
 const { execFileSync, spawn } = require('child_process');
 const { run: runControlCli } = require('./farming-cli');
 const { PACKAGED_CODEX_ACP_ARG, runPackagedCodexAcp } = require('./acp/packaged-codex-acp');
+const { PACKAGED_CLAUDE_ACP_ARG, runPackagedClaudeAcp } = require('./acp/packaged-claude-acp');
+const {
+  SERVER_PROCESS_IDENTITY_FORMAT,
+  matchingProcessIdentity,
+  readServerProcessIdentity,
+} = require('./server-process-identity');
 const storageLayout = require('./storage-layout');
 
 const SERVER_MODE_ARG = '--farming-server';
@@ -20,10 +26,9 @@ const DEFAULT_SERVER_START_TIMEOUT_MS = 30_000;
 const DEFAULT_SERVER_START_STABILITY_MS = 1_500;
 const DEFAULT_SERVER_STOP_TIMEOUT_MS = 30_000;
 const SERVER_STOP_POLL_MS = 100;
-const SERVER_PROCESS_IDENTITY_FORMAT = 'ps-lstart-c-utc-v1';
 const SERVER_COMMANDS = new Set(['start', 'serve', 'daemon', 'stop', 'status', 'logs', 'url', 'help']);
-const CONTROL_COMMANDS = new Set(['skills', 'memory', 'report', 'list', 'spawn', 'output', 'send', 'kill']);
-const SERVER_BACKED_CONTROL_COMMANDS = new Set(['list', 'spawn', 'output', 'send', 'kill']);
+const CONTROL_COMMANDS = new Set(['skills', 'capabilities', 'memory', 'report', 'list', 'spawn', 'output', 'send', 'kill']);
+const SERVER_BACKED_CONTROL_COMMANDS = new Set(['capabilities', 'list', 'spawn', 'output', 'send', 'kill']);
 
 function defaultConfigDir(env = process.env) {
   return storageLayout.farmingConfigDir(env);
@@ -437,7 +442,9 @@ function childInvocation(env = process.env) {
     // making daemon ownership impossible to prove on Linux.
     return {
       command: '/usr/bin/env',
-      args: buildCleanEnvExecArgs(env, process.execPath, ['--']),
+      // FARMING_RUN_SERVER selects the embedded server entry. Do not append a
+      // sentinel argument: pkg may interpret it as an external script path.
+      args: buildCleanEnvExecArgs(env, process.execPath),
     };
   }
   const nodePath = env.FARMING_NODE_BIN || process.execPath;
@@ -482,45 +489,20 @@ function canonicalConfigDir(configDir) {
   }
 }
 
-async function readServerProcessIdentity(pid) {
-  const processId = Number(pid);
-  if (!Number.isSafeInteger(processId) || processId <= 0 || process.platform === 'win32') return null;
-  let stdout;
-  try {
-    stdout = execFileSync(
-      '/bin/ps',
-      ['-p', String(processId), '-o', 'pid=', '-o', 'pgid=', '-o', 'lstart='],
-      {
-        encoding: 'utf8',
-        timeout: 1_000,
-        maxBuffer: 16_384,
-        env: { ...process.env, LANG: 'C', LC_ALL: 'C', TZ: 'UTC' },
-      },
-    );
-  } catch (error) {
-    if (error?.status === 1 || error?.code === 'ESRCH') return null;
-    throw error;
-  }
-  const match = String(stdout || '').trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
-  if (!match || Number(match[1]) !== processId) return null;
-  return {
-    pid: processId,
-    processGroupId: Number(match[2]),
-    startedAt: match[3].trim(),
-    format: SERVER_PROCESS_IDENTITY_FORMAT,
-  };
-}
-
-function writeServerState(configDir, env, pid, processIdentity) {
+function writeServerState(configDir, env, pid, processIdentity, phase = 'running') {
   const state = {
     pid,
     port: Number(env.PORT || DEFAULT_PORT),
     basePath: env.FARMING_BASE_PATH || DEFAULT_BASE_PATH,
     configDir: canonicalConfigDir(configDir),
     processIdentity,
+    phase,
     updatedAt: new Date().toISOString(),
   };
-  fs.writeFileSync(serverStateFile(configDir), `${JSON.stringify(state, null, 2)}\n`);
+  const target = serverStateFile(configDir);
+  const temporary = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, target);
 }
 
 function processLooksLikeFarmingServer(pid) {
@@ -664,15 +646,6 @@ function processOwnsListeningPort(pid, port) {
   }
 }
 
-function matchingProcessIdentity(expected, current) {
-  return Boolean(
-    current
-    && current.pid === Number(expected?.pid)
-    && current.processGroupId === Number(expected?.processGroupId)
-    && current.startedAt === String(expected?.startedAt || '')
-  );
-}
-
 async function assertServerProcessIdentity(configDir, pid, state) {
   const expected = state?.processIdentity;
   if (
@@ -694,7 +667,7 @@ async function assertServerProcessIdentity(configDir, pid, state) {
       `Refusing to stop Farming PID ${pid}: the live process identity does not match the server control metadata`,
     );
   }
-  if (!processOwnsListeningPort(pid, Number(state.port))) {
+  if (state.phase !== 'starting' && !processOwnsListeningPort(pid, Number(state.port))) {
     throw new Error(`Refusing to stop Farming PID ${pid}: the process does not own listening port ${state.port}`);
   }
   return current;
@@ -752,7 +725,8 @@ function isRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') return true;
     return false;
   }
 }
@@ -840,12 +814,31 @@ function waitForProcessStability(pid, durationMs = DEFAULT_SERVER_START_STABILIT
   });
 }
 
-function cleanupFailedDaemonStart(configDir, childPid) {
+async function cleanupFailedDaemonStart(configDir, childPid, expectedIdentity = null) {
   if (isRunning(childPid)) {
+    const expected = expectedIdentity || readServerState(configDir).processIdentity;
+    const current = readServerProcessIdentity(childPid);
+    if (!matchingProcessIdentity(expected, current)) {
+      throw new Error(`Failed Farming startup left live PID ${childPid} with an unproved identity; refusing to signal it`);
+    }
     try {
-      process.kill(childPid, 'SIGTERM');
-    } catch {
-      // The child may exit between the liveness check and the signal.
+      process.kill(childPid, 'SIGKILL');
+    } catch (error) {
+      if (error?.code === 'EPERM' || error?.code === 'EACCES') {
+        throw new Error(
+          `Failed Farming startup left Server PID ${childPid} running because cleanup lacks permission. `
+          + 'Stop it as the operating-system user that owns the process, then retry.',
+          { cause: error },
+        );
+      }
+      if (error?.code !== 'ESRCH') throw error;
+    }
+    const startedAt = Date.now();
+    while (matchingProcessIdentity(expected, readServerProcessIdentity(childPid))) {
+      if (Date.now() - startedAt >= 5_000) {
+        throw new Error(`Failed Farming startup left Server PID ${childPid} running after SIGKILL`);
+      }
+      await new Promise(resolve => setTimeout(resolve, SERVER_STOP_POLL_MS));
     }
   }
   if (readPid(configDir) !== childPid) return;
@@ -910,10 +903,31 @@ function waitForServer(env, timeoutMs = serverStartTimeoutMs(env), childPid = 0)
   });
 }
 
-function runServerInCurrentProcess() {
+async function runServerInCurrentProcess() {
   process.env = buildServerEnv();
+  ensureConfigDir(process.env.FARMING_CONFIG_DIR);
+  fs.writeFileSync(pidFile(process.env.FARMING_CONFIG_DIR), String(process.pid), { mode: 0o600 });
+  const processIdentity = await readServerProcessIdentity(process.pid);
+  if (!processIdentity) throw new Error('server process identity could not be committed before startup');
+  writeServerState(process.env.FARMING_CONFIG_DIR, process.env, process.pid, processIdentity, 'starting');
   const { startServer } = require('./server');
-  startServer();
+  const server = startServer();
+  server.once('listening', () => {
+    writeServerState(
+      process.env.FARMING_CONFIG_DIR,
+      process.env,
+      process.pid,
+      processIdentity,
+      'running',
+    );
+    const { pruneRuntimeDependencies } = require('./runtime-dependency-manager');
+    void pruneRuntimeDependencies({
+      configDir: process.env.FARMING_CONFIG_DIR,
+      env: process.env,
+    }).catch(error => {
+      console.warn(`Startup dependency cache cleanup failed: ${error?.message || error}`);
+    });
+  });
 }
 
 function runNativePtyHostInCurrentProcess() {
@@ -921,8 +935,24 @@ function runNativePtyHostInCurrentProcess() {
   startNativePtyHostProcess();
 }
 
+async function prepareStartupDependencies(env, options = {}) {
+  if (
+    options.force !== true
+    && (env.FARMING_SKIP_RUNTIME_PREPARE === '1' || env.NODE_ENV === 'test')
+  ) {
+    return { skipped: true };
+  }
+  const { prepareRuntimeDependencies } = require('./runtime-dependency-manager');
+  return prepareRuntimeDependencies({
+    configDir: env.FARMING_CONFIG_DIR,
+    env,
+  });
+}
+
 async function startForeground(parsed) {
-  const env = await adaptServerPort(buildServerEnv(parsed.env), parsed);
+  const env = buildServerEnv(parsed.env);
+  await prepareStartupDependencies(env);
+  await adaptServerPort(env, parsed);
   env[SERVER_MODE_ENV] = '1';
   ensureConfigDir(env.FARMING_CONFIG_DIR);
   const invocation = childInvocation(env);
@@ -952,13 +982,33 @@ async function startDaemon(parsed) {
   const existingPid = readPid(configDir);
   if (isRunning(existingPid)) {
     const state = readServerState(configDir);
-    if (state.port) env.PORT = String(state.port);
-    if (state.basePath) env.FARMING_BASE_PATH = state.basePath;
-    console.log(`Farming is already running (PID ${existingPid})`);
-    console.log(entryUrl(env));
-    return 0;
+    try {
+      if (state.processIdentity?.format === SERVER_PROCESS_IDENTITY_FORMAT) {
+        await assertServerProcessIdentity(configDir, existingPid, state);
+      } else {
+        await migrateLegacyServerIdentity(configDir, existingPid, state);
+      }
+    } catch (error) {
+      console.error(
+        `Farming PID ${existingPid} is live, but this config directory does not prove that it owns the Server: `
+        + `${error.message || error}`,
+      );
+      return 1;
+    }
+    if (state.phase === 'starting') {
+      console.warn(`Previous Farming startup (PID ${existingPid}) did not complete; replacing it.`);
+      const stopCode = await stopDaemon({ env });
+      if (stopCode !== 0) return stopCode;
+    } else {
+      if (state.port) env.PORT = String(state.port);
+      if (state.basePath) env.FARMING_BASE_PATH = state.basePath;
+      console.log(`Farming is already running (PID ${existingPid})`);
+      console.log(entryUrl(env));
+      return 0;
+    }
   }
 
+  await prepareStartupDependencies(env);
   const out = fs.openSync(logFile(configDir), 'a');
   const invocation = childInvocation(env);
   if (env.FARMING_DEBUG_CLI === '1') {
@@ -979,9 +1029,11 @@ async function startDaemon(parsed) {
   child.unref();
   fs.writeFileSync(pidFile(configDir), String(child.pid));
 
+  let processIdentity = null;
   try {
-    const processIdentity = await readServerProcessIdentity(child.pid);
+    processIdentity = await readServerProcessIdentity(child.pid);
     if (!processIdentity) throw new Error('server process identity could not be verified after launch');
+    writeServerState(configDir, env, child.pid, processIdentity, 'starting');
     await waitForServer(env, serverStartTimeoutMs(env), child.pid);
     await waitForProcessStability(child.pid, serverStartStabilityMs(env));
     await waitForServer(env, Math.min(serverStartTimeoutMs(env), 5_000), child.pid);
@@ -993,9 +1045,14 @@ async function startDaemon(parsed) {
     ) {
       throw new Error('server process identity changed during startup');
     }
-    writeServerState(configDir, env, child.pid, stableIdentity);
+    writeServerState(configDir, env, child.pid, stableIdentity, 'running');
   } catch (error) {
-    cleanupFailedDaemonStart(configDir, child.pid);
+    try {
+      await cleanupFailedDaemonStart(configDir, child.pid, processIdentity);
+    } catch (cleanupError) {
+      console.error(`${error.message}; cleanup failed: ${cleanupError.message || cleanupError}`);
+      return 1;
+    }
     console.error(error.message);
     const logs = tailFile(logFile(configDir), 80);
     if (logs) console.error(logs);
@@ -1031,8 +1088,15 @@ async function stopDaemon(parsed) {
     await migrateLegacyServerIdentity(configDir, pid, state);
   }
   try {
-    process.kill(pid, 'SIGTERM');
+    process.kill(pid, 'SIGKILL');
   } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') {
+      throw new Error(
+        `Farming cannot stop server ${pid} because this command lacks permission. `
+        + 'Run it as the operating-system user that owns the process (or as an administrator), then start Farming again.',
+        { cause: error },
+      );
+    }
     if (error?.code !== 'ESRCH') throw error;
   }
   await waitForDaemonStop(pid, port, { timeoutMs: serverStopTimeoutMs(env) });
@@ -1042,7 +1106,7 @@ async function stopDaemon(parsed) {
   return 0;
 }
 
-function statusDaemon(parsed) {
+async function statusDaemon(parsed) {
   const env = buildServerEnv(parsed.env);
   const configDir = env.FARMING_CONFIG_DIR;
   const pid = readPid(configDir);
@@ -1050,6 +1114,24 @@ function statusDaemon(parsed) {
     console.log('Farming is not running.');
     return 0;
   }
+  const state = readServerState(configDir);
+  try {
+    if (state.processIdentity?.format === SERVER_PROCESS_IDENTITY_FORMAT) {
+      await assertServerProcessIdentity(configDir, pid, state);
+    } else {
+      await migrateLegacyServerIdentity(configDir, pid, state);
+    }
+  } catch (error) {
+    console.error(
+      `Farming PID ${pid} is live, but this config directory does not prove that it owns the Server: `
+      + `${error.message || error}`,
+    );
+    return 1;
+  }
+  if (state.phase === 'starting') {
+    console.log(`Farming is starting (PID ${pid}). Run 'farming start' to replace an interrupted startup.`);
+    return 1;
+  }
   console.log(`Farming is running (PID ${pid})`);
   const logs = tailFile(logFile(configDir), 30);
   if (logs) console.log(logs);
@@ -1082,10 +1164,13 @@ function usage() {
   farming stop
   farming logs
   farming url
+  farming runtime prepare [--config-dir ~/.farming]
   farming review <git-dir> <old-revision> <new-revision|now> [--branch <branch>] [--no-open]
 
 Agent control commands are also available:
   farming skills
+  farming capabilities [--json]
+  farming browser ...
   farming list [--json] [--parent <agentId>]
   farming spawn --workspace <repo> -- <command...>
   farming output <agentId> [--tail <chars>]
@@ -1104,7 +1189,12 @@ async function run(argv = process.argv.slice(2)) {
   }
 
   if (argv[0] === PACKAGED_CODEX_ACP_ARG) {
-    runPackagedCodexAcp();
+    await runPackagedCodexAcp();
+    return 0;
+  }
+
+  if (argv[0] === PACKAGED_CLAUDE_ACP_ARG) {
+    await runPackagedClaudeAcp();
     return 0;
   }
 
@@ -1121,7 +1211,20 @@ async function run(argv = process.argv.slice(2)) {
   }
 
   if (process.env[SERVER_MODE_ENV] === '1' || argv[0] === SERVER_MODE_ARG) {
-    runServerInCurrentProcess();
+    await runServerInCurrentProcess();
+    return 0;
+  }
+
+  if (argv[0] === 'browser') {
+    const { run: runBrowserCli } = require('../extensions/browser/bin/farming-browser');
+    return runBrowserCli(argv.slice(1));
+  }
+
+  if (argv[0] === 'runtime' && argv[1] === 'prepare') {
+    const parsed = parseServerArgs(['start', ...argv.slice(2)]);
+    const env = buildServerEnv(parsed.env);
+    const result = await prepareStartupDependencies(env, { force: true });
+    console.log(JSON.stringify(result, null, 2));
     return 0;
   }
 

package/backend/farming-cli.js

@@ -8,6 +8,7 @@ const storageLayout = require('./storage-layout');
 function usage() {
   return `Usage:
   farming skills
+  farming capabilities [--json]
   farming memory report [--period today|yesterday|week] [--since <time>] [--until <time>] [--home <path>] [--json]
   farming list [--json] [--parent <agentId>]
   farming spawn [--workspace <path>] [--task <text>] [--parent <agentId>] [--json] -- <command...>
@@ -20,6 +21,7 @@ Examples:
   farming memory report --period today
   farming memory report --period week --json
   farming skills
+  farming capabilities
   farming list --parent "$FARMING_AGENT_ID"
   farming output agent-123 --tail 2000
   farming send agent-123 "Please run the focused tests"`;
@@ -76,6 +78,13 @@ function parseArgs(argv) {
     return { command };
   }
 
+  if (command === 'capabilities') {
+    if (rest.some(arg => arg !== '--json')) {
+      throw new Error('capabilities accepts only --json');
+    }
+    return { command, options: { json: rest.includes('--json') } };
+  }
+
   if (command === 'memory' || command === 'report') {
     const subcommand = command === 'memory' ? rest.shift() : 'report';
     if (subcommand !== 'report') {
@@ -293,6 +302,44 @@ function formatAgent(agent) {
   return `${marker} ${agent.id} | ${agent.command} | ${agent.status} | ${agent.cwd}${parent}${task}`;
 }
 
+function farmingCapabilities(browser) {
+  const state = browser?.available === true
+    ? 'available'
+    : (browser?.enabled === true ? 'unavailable' : 'disabled');
+  return {
+    runtime: 'farming',
+    agentId: process.env.FARMING_AGENT_ID || '',
+    projectWorkspace: process.env.FARMING_PROJECT_WORKSPACE || '',
+    capabilities: [{
+      id: 'browser',
+      state,
+      summary: state === 'available'
+        ? (browser?.browser?.kind === 'external-cdp'
+            ? 'Default browser path for web tasks. An externally managed CDP Browser can be created or attached as a shared, user-visible Farming Resource.'
+            : 'Default browser path for web tasks. An installed system Chromium Browser can be created or attached as a shared, user-visible Farming Resource.')
+        : (browser?.message || 'Browser integration is unavailable in Farming.'),
+      commands: state === 'available'
+        ? {
+            list: 'farming browser list',
+            create: 'farming browser create',
+            workflow: 'farming browser help workflow',
+          }
+        : {},
+    }],
+  };
+}
+
+function formatCapabilities(report) {
+  const lines = ['Farming runtime capabilities:'];
+  for (const capability of report.capabilities) {
+    lines.push(`- ${capability.id}: ${capability.state} — ${capability.summary}`);
+    for (const [label, command] of Object.entries(capability.commands || {})) {
+      lines.push(`  ${label}: ${command}`);
+    }
+  }
+  return lines.join('\n');
+}
+
 async function run(argv = process.argv.slice(2), io = process) {
   const parsed = parseArgs(argv);
 
@@ -306,6 +353,14 @@ async function run(argv = process.argv.slice(2), io = process) {
     return 0;
   }
 
+  if (parsed.command === 'capabilities') {
+    const report = farmingCapabilities(await request('/api/browsers/capability'));
+    io.stdout.write(parsed.options.json
+      ? `${JSON.stringify(report, null, 2)}\n`
+      : `${formatCapabilities(report)}\n`);
+    return 0;
+  }
+
   if (parsed.command === 'memory-report') {
     const report = buildMemoryReport({
       period: parsed.options.period,
@@ -382,6 +437,8 @@ async function run(argv = process.argv.slice(2), io = process) {
 
 module.exports = {
   formatAgent,
+  farmingCapabilities,
+  formatCapabilities,
   getToken,
   httpRequest,
   isAuthDisabled,