farming-code 2.2.19 → 2.2.22

package/backend/farming-app-cli.js

@@ -18,6 +18,9 @@ const DEFAULT_PORT = '6694';
 const DEFAULT_BASE_PATH = '/farming';
 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']);
@@ -42,14 +45,19 @@ function quoteShellArg(arg) {
 }
 
 function buildCleanEnvExecCommand(env, command, args = []) {
-  const parts = ['/usr/bin/env', '-i'];
+  const parts = ['/usr/bin/env', ...buildCleanEnvExecArgs(env, command, args)];
+  return parts.map(quoteShellArg).join(' ');
+}
+
+function buildCleanEnvExecArgs(env, command, args = []) {
+  const parts = ['-i'];
   Object.entries(env || {}).forEach(([key, value]) => {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return;
     if (value === undefined || value === null) return;
     parts.push(`${key}=${String(value)}`);
   });
   parts.push(command, ...args);
-  return parts.map(quoteShellArg).join(' ');
+  return parts;
 }
 
 function readMemoryLimitBytes() {
@@ -424,7 +432,13 @@ async function runServerBackedControlCli(argv) {
 
 function childInvocation(env = process.env) {
   if (process.pkg) {
-    return { command: '/bin/sh', args: ['-c', buildCleanEnvExecCommand(env, process.execPath, ['--'])] };
+    // Spawn env directly so it execs the packaged binary in-place. A shell
+    // wrapper may keep its own PID while the listener belongs to a child,
+    // making daemon ownership impossible to prove on Linux.
+    return {
+      command: '/usr/bin/env',
+      args: buildCleanEnvExecArgs(env, process.execPath, ['--']),
+    };
   }
   const nodePath = env.FARMING_NODE_BIN || process.execPath;
   if (env.FARMING_NODE_LD && env.FARMING_NODE_LIBRARY_PATH) {
@@ -460,17 +474,271 @@ function readServerState(configDir) {
   }
 }
 
-function writeServerState(configDir, env, pid) {
+function canonicalConfigDir(configDir) {
+  try {
+    return fs.realpathSync.native(configDir);
+  } catch {
+    return path.resolve(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) {
   const state = {
     pid,
     port: Number(env.PORT || DEFAULT_PORT),
     basePath: env.FARMING_BASE_PATH || DEFAULT_BASE_PATH,
-    configDir,
+    configDir: canonicalConfigDir(configDir),
+    processIdentity,
     updatedAt: new Date().toISOString(),
   };
   fs.writeFileSync(serverStateFile(configDir), `${JSON.stringify(state, null, 2)}\n`);
 }
 
+function processLooksLikeFarmingServer(pid) {
+  let environment = '';
+  try {
+    environment = fs.readFileSync(`/proc/${pid}/environ`, 'utf8').replace(/\0/g, ' ');
+  } catch {
+    try {
+      environment = execFileSync(
+        '/bin/ps',
+        ['eww', '-p', String(pid), '-o', 'command='],
+        { encoding: 'utf8', timeout: 1_000, maxBuffer: 1024 * 1024 },
+      );
+    } catch {
+      environment = '';
+    }
+  }
+  if (/(?:^|\s)FARMING_RUN_SERVER=1(?:\s|$)/.test(environment)) return true;
+  return /(?:^|\s)(?:\S+[/\\])?backend[/\\]server\.js(?:\s|$)/.test(environment);
+}
+
+function processHasExactEnvironment(pid, expected) {
+  try {
+    const entries = fs.readFileSync(`/proc/${pid}/environ`, 'utf8')
+      .split('\0')
+      .filter(Boolean)
+      .map(entry => {
+        const separator = entry.indexOf('=');
+        return separator < 0 ? [entry, ''] : [entry.slice(0, separator), entry.slice(separator + 1)];
+      });
+    const environment = new Map(entries);
+    return Object.entries(expected).every(([key, value]) => environment.get(key) === String(value));
+  } catch {
+    if (Object.values(expected).some(value => /\s/.test(String(value)))) return false;
+    try {
+      const environment = execFileSync(
+        '/bin/ps',
+        ['eww', '-p', String(pid), '-o', 'command='],
+        { encoding: 'utf8', timeout: 1_000, maxBuffer: 1024 * 1024 },
+      );
+      return Object.entries(expected).every(([key, value]) => {
+        const escaped = `${key}=${value}`.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`(?:^|\\s)${escaped}(?:\\s|$)`).test(environment);
+      });
+    } catch {
+      return false;
+    }
+  }
+}
+
+function readLegacyServerSettings(configDir, state, pid) {
+  const authDisabled = processHasExactEnvironment(pid, { FARMING_DISABLE_AUTH: '1' });
+  const token = authDisabled ? '' : readTokenForEnv({ FARMING_CONFIG_DIR: configDir });
+  if (!authDisabled && !token) {
+    return Promise.reject(new Error('legacy Farming server identity probe requires this config directory token'));
+  }
+  const requestPath = routePath(state.basePath || DEFAULT_BASE_PATH, '/api/settings');
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      host: '127.0.0.1',
+      port: Number(state.port),
+      path: requestPath,
+      method: 'GET',
+      timeout: 1_000,
+      headers: token ? { Cookie: `farming_token=${encodeURIComponent(token)}` } : {},
+    }, res => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => {
+        if (body.length <= 64 * 1024) body += chunk;
+      });
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`legacy Farming server identity probe returned HTTP ${res.statusCode || 0}`));
+          return;
+        }
+        try {
+          const payload = JSON.parse(body);
+          if (!payload?.settings || typeof payload.settings !== 'object') {
+            reject(new Error('legacy Farming server identity probe did not return Farming settings'));
+            return;
+          }
+          resolve(payload.settings);
+        } catch (error) {
+          reject(new Error(`legacy Farming server identity probe was invalid: ${error.message || error}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('legacy Farming server identity probe timed out')));
+    req.end();
+  });
+}
+
+function processOwnsListeningPort(pid, port) {
+  const processId = Number(pid);
+  const portNumber = Number(port);
+  if (!Number.isSafeInteger(processId) || processId <= 0 || !Number.isInteger(portNumber) || portNumber <= 0) {
+    return false;
+  }
+  if (process.platform === 'linux') {
+    try {
+      const socketInodes = new Set(fs.readdirSync(`/proc/${processId}/fd`).flatMap(entry => {
+        try {
+          const target = fs.readlinkSync(`/proc/${processId}/fd/${entry}`);
+          const match = target.match(/^socket:\[(\d+)\]$/);
+          return match ? [match[1]] : [];
+        } catch {
+          return [];
+        }
+      }));
+      const portHex = portNumber.toString(16).toUpperCase().padStart(4, '0');
+      for (const table of ['/proc/net/tcp', '/proc/net/tcp6']) {
+        let rows = [];
+        try {
+          rows = fs.readFileSync(table, 'utf8').trim().split(/\r?\n/).slice(1);
+        } catch {
+          continue;
+        }
+        if (rows.some(row => {
+          const fields = row.trim().split(/\s+/);
+          const localPort = String(fields[1] || '').split(':').at(-1);
+          return localPort === portHex && fields[3] === '0A' && socketInodes.has(fields[9]);
+        })) return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const lsof = fs.existsSync('/usr/sbin/lsof') ? '/usr/sbin/lsof' : 'lsof';
+    const stdout = execFileSync(
+      lsof,
+      ['-nP', '-a', '-p', String(processId), `-iTCP:${portNumber}`, '-sTCP:LISTEN', '-Fpfn'],
+      { encoding: 'utf8', timeout: 1_000, maxBuffer: 64 * 1024 },
+    );
+    return String(stdout || '').split(/\r?\n/).some(line => line.startsWith('n') && line.endsWith(`:${portNumber}`));
+  } catch {
+    return false;
+  }
+}
+
+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 (
+    Number(state?.pid) !== pid
+    || canonicalConfigDir(state?.configDir || '') !== canonicalConfigDir(configDir)
+    || !expected
+    || Number(expected.pid) !== pid
+    || !Number.isSafeInteger(Number(expected.processGroupId))
+    || Number(expected.processGroupId) <= 0
+    || !String(expected.startedAt || '').trim()
+  ) {
+    throw new Error(
+      `Refusing to stop Farming PID ${pid}: server control metadata does not contain a matching process identity`,
+    );
+  }
+  const current = await readServerProcessIdentity(pid);
+  if (!matchingProcessIdentity(expected, current)) {
+    throw new Error(
+      `Refusing to stop Farming PID ${pid}: the live process identity does not match the server control metadata`,
+    );
+  }
+  if (!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;
+}
+
+async function migrateLegacyServerIdentity(configDir, pid, state) {
+  if (
+    Number(state?.pid) !== pid
+    || canonicalConfigDir(state?.configDir || '') !== canonicalConfigDir(configDir)
+    || !Number.isInteger(Number(state?.port))
+    || Number(state.port) <= 0
+    || Number(state.port) > 65535
+    || !processLooksLikeFarmingServer(pid)
+    || !processHasExactEnvironment(pid, {
+      FARMING_CONFIG_DIR: configDir,
+      PORT: String(state.port),
+    })
+  ) {
+    throw new Error(
+      `Refusing to stop Farming PID ${pid}: legacy server control metadata could not prove this process belongs to the config directory`,
+    );
+  }
+  const firstIdentity = await readServerProcessIdentity(pid);
+  if (!firstIdentity) {
+    throw new Error(`Refusing to stop Farming PID ${pid}: the legacy server process identity could not be read`);
+  }
+  if (!processOwnsListeningPort(pid, Number(state.port))) {
+    throw new Error(`Refusing to stop Farming PID ${pid}: the legacy process does not own listening port ${state.port}`);
+  }
+  await readLegacyServerSettings(configDir, state, pid);
+  const stableIdentity = await readServerProcessIdentity(pid);
+  if (!matchingProcessIdentity(firstIdentity, stableIdentity) || readPid(configDir) !== pid) {
+    throw new Error(`Refusing to stop Farming PID ${pid}: the legacy server process identity changed during verification`);
+  }
+  fs.writeFileSync(serverStateFile(configDir), `${JSON.stringify({
+    ...state,
+    pid,
+    configDir: canonicalConfigDir(configDir),
+    processIdentity: stableIdentity,
+    identityMigratedAt: new Date().toISOString(),
+  }, null, 2)}\n`);
+  return stableIdentity;
+}
+
 function readPid(configDir) {
   try {
     return Number(fs.readFileSync(pidFile(configDir), 'utf8').trim());
@@ -523,6 +791,36 @@ function serverStartStabilityMs(env) {
   return DEFAULT_SERVER_START_STABILITY_MS;
 }
 
+function serverStopTimeoutMs(env) {
+  const parsed = Number(env.FARMING_STOP_TIMEOUT_MS || env.FARMING_SERVER_STOP_TIMEOUT_MS);
+  if (Number.isFinite(parsed) && parsed > 0) return Math.min(parsed, 120_000);
+  return DEFAULT_SERVER_STOP_TIMEOUT_MS;
+}
+
+async function waitForDaemonStop(pid, port, options = {}) {
+  const timeoutMs = options.timeoutMs || DEFAULT_SERVER_STOP_TIMEOUT_MS;
+  const processRunning = options.isRunning || isRunning;
+  const portAvailable = options.canListenOnPort || canListenOnPort;
+  const now = options.now || Date.now;
+  const wait = options.wait || (durationMs => new Promise(resolve => setTimeout(resolve, durationMs)));
+  const startedAt = now();
+  let running = true;
+  let released = false;
+
+  while (true) {
+    running = processRunning(pid);
+    released = await portAvailable(port);
+    if (!running && released) return;
+    if (now() - startedAt >= timeoutMs) {
+      throw new Error(
+        `Farming server PID ${pid} did not stop and release port ${port} within ${timeoutMs}ms`
+        + ` (process ${running ? 'still running' : 'exited'}, port ${released ? 'released' : 'still in use'})`,
+      );
+    }
+    await wait(SERVER_STOP_POLL_MS);
+  }
+}
+
 function waitForProcessStability(pid, durationMs = DEFAULT_SERVER_START_STABILITY_MS) {
   const startedAt = Date.now();
   return new Promise((resolve, reject) => {
@@ -682,9 +980,20 @@ async function startDaemon(parsed) {
   fs.writeFileSync(pidFile(configDir), String(child.pid));
 
   try {
+    const processIdentity = await readServerProcessIdentity(child.pid);
+    if (!processIdentity) throw new Error('server process identity could not be verified after launch');
     await waitForServer(env, serverStartTimeoutMs(env), child.pid);
     await waitForProcessStability(child.pid, serverStartStabilityMs(env));
     await waitForServer(env, Math.min(serverStartTimeoutMs(env), 5_000), child.pid);
+    const stableIdentity = await readServerProcessIdentity(child.pid);
+    if (
+      !stableIdentity
+      || stableIdentity.processGroupId !== processIdentity.processGroupId
+      || stableIdentity.startedAt !== processIdentity.startedAt
+    ) {
+      throw new Error('server process identity changed during startup');
+    }
+    writeServerState(configDir, env, child.pid, stableIdentity);
   } catch (error) {
     cleanupFailedDaemonStart(configDir, child.pid);
     console.error(error.message);
@@ -694,7 +1003,6 @@ async function startDaemon(parsed) {
   }
 
   console.log(`Farming started (PID ${child.pid})`);
-  writeServerState(configDir, env, child.pid);
   const logs = tailFile(logFile(configDir), 40);
   const urlLines = logs.split(/\r?\n/).filter(line => /Local:|Network:|Token:|Token style:|Token auth:/.test(line));
   if (urlLines.length > 0) {
@@ -705,7 +1013,7 @@ async function startDaemon(parsed) {
   return 0;
 }
 
-function stopDaemon(parsed) {
+async function stopDaemon(parsed) {
   const env = buildServerEnv(parsed.env);
   const configDir = env.FARMING_CONFIG_DIR;
   const pid = readPid(configDir);
@@ -715,9 +1023,21 @@ function stopDaemon(parsed) {
     console.log('Farming is not running.');
     return 0;
   }
-  process.kill(pid, 'SIGTERM');
-  fs.rmSync(pidFile(configDir), { force: true });
-  fs.rmSync(serverStateFile(configDir), { force: true });
+  const state = readServerState(configDir);
+  const port = Number(state.port || env.PORT || DEFAULT_PORT);
+  if (state.processIdentity?.format === SERVER_PROCESS_IDENTITY_FORMAT) {
+    await assertServerProcessIdentity(configDir, pid, state);
+  } else {
+    await migrateLegacyServerIdentity(configDir, pid, state);
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (error) {
+    if (error?.code !== 'ESRCH') throw error;
+  }
+  await waitForDaemonStop(pid, port, { timeoutMs: serverStopTimeoutMs(env) });
+  if (readPid(configDir) === pid) fs.rmSync(pidFile(configDir), { force: true });
+  if (Number(readServerState(configDir).pid) === pid) fs.rmSync(serverStateFile(configDir), { force: true });
   console.log(`Stopped Farming (PID ${pid})`);
   return 0;
 }
@@ -841,6 +1161,7 @@ if (require.main === module) {
 module.exports = {
   SERVER_MODE_ARG,
   NATIVE_PTY_HOST_ARG,
+  buildCleanEnvExecArgs,
   buildCleanEnvExecCommand,
   childInvocation,
   cleanupFailedDaemonStart,
@@ -854,9 +1175,13 @@ module.exports = {
   resolveReviewTarget,
   reviewUrl,
   readServerState,
+  readServerProcessIdentity,
   serverStartTimeoutMs,
   serverStartStabilityMs,
+  serverStopTimeoutMs,
   splitControlArgs,
+  stopDaemon,
   run,
   serverStateFile,
+  waitForDaemonStop,
 };