farming-code 2.2.8 → 2.2.11

package/backend/farming-net-server.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const http = require('http');
+const os = require('os');
+const path = require('path');
+const TokenAuth = require('./auth');
+const {
+  createFarmingNetPass,
+  loadOrCreateFarmingNetSigningIdentity,
+  PASS_QUERY_PARAM,
+} = require('./farming-net-pass');
+const { loadFarmingNetRegistry } = require('./farming-net-registry');
+const storageLayout = require('./storage-layout');
+
+const DEFAULT_PORT = 6693;
+const DEFAULT_BASE_PATH = '/farming-net';
+
+function normalizeBasePath(basePath) {
+  const value = String(basePath || '').trim();
+  if (!value || value === '/') return '';
+  const normalized = value.startsWith('/') ? value : `/${value}`;
+  return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+}
+
+function isTruthy(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').toLowerCase());
+}
+
+function safePort(value, fallback = DEFAULT_PORT) {
+  const port = Number(value);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+function loadPackageVersion(projectRoot) {
+  try {
+    return String(JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8')).version || 'dev');
+  } catch {
+    return 'dev';
+  }
+}
+
+function setSecurityHeaders(res) {
+  res.setHeader('Content-Security-Policy', [
+    "default-src 'self'",
+    "connect-src 'self' http: https:",
+    "img-src 'self' data:",
+    "style-src 'self'",
+    "script-src 'self'",
+    "base-uri 'none'",
+    "frame-ancestors 'none'",
+    "form-action 'self'",
+  ].join('; '));
+  res.setHeader('Cross-Origin-Opener-Policy', 'same-origin-allow-popups');
+  res.setHeader('Referrer-Policy', 'no-referrer');
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+}
+
+function sendBuffer(req, res, statusCode, body, contentType, cacheControl = 'no-store') {
+  const buffer = Buffer.isBuffer(body) ? body : Buffer.from(String(body));
+  res.writeHead(statusCode, {
+    'Cache-Control': cacheControl,
+    'Content-Length': buffer.length,
+    'Content-Type': contentType,
+  });
+  if (req.method === 'HEAD') res.end();
+  else res.end(buffer);
+}
+
+function sendJson(req, res, statusCode, payload) {
+  sendBuffer(req, res, statusCode, `${JSON.stringify(payload)}\n`, 'application/json; charset=utf-8');
+}
+
+function readAsset(filePath) {
+  try {
+    return fs.readFileSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function browserRegistry(registry, basePath) {
+  return {
+    ...registry,
+    instances: registry.instances.map(instance => ({
+      ...instance,
+      endpoints: instance.endpoints.map((endpoint, index) => ({
+        ...endpoint,
+        launchUrl: instance.federated
+          ? `${basePath}/open/${encodeURIComponent(instance.id)}/${index}`
+          : endpoint.url,
+      })),
+    })),
+  };
+}
+
+function createFarmingNetServer(options = {}) {
+  const env = options.env || process.env;
+  const projectRoot = options.projectRoot || path.resolve(__dirname, '..');
+  const basePath = normalizeBasePath(options.basePath ?? env.FARMING_NET_BASE_PATH ?? DEFAULT_BASE_PATH);
+  const configDir = options.configDir
+    || env.FARMING_NET_CONFIG_DIR
+    || path.join(env.HOME || os.homedir(), '.farming-net');
+  const assetDir = options.assetDir || path.join(projectRoot, 'frontend', 'farming-net');
+  const registryFile = options.registryFile || storageLayout.farmingNetInstancesFile(configDir);
+  const stateFile = options.stateFile || storageLayout.farmingNetServerStateFile(configDir);
+  const packageVersion = options.packageVersion || loadPackageVersion(projectRoot);
+  const iconCandidates = [
+    options.iconFile,
+    path.join(projectRoot, 'public', 'farming-2', 'app-icon-v2-180.png'),
+    path.join(projectRoot, 'dist', 'farming-2', 'app-icon-v2-180.png'),
+  ].filter(Boolean);
+  const iconFile = iconCandidates.find(candidate => fs.existsSync(candidate)) || '';
+  fs.mkdirSync(configDir, { recursive: true });
+  loadFarmingNetRegistry(registryFile);
+  const signingIdentity = options.signingIdentity || loadOrCreateFarmingNetSigningIdentity({
+    privateKeyFile: storageLayout.farmingNetSigningPrivateKeyFile(configDir),
+    publicKeyFile: storageLayout.farmingNetSigningPublicKeyFile(configDir),
+  });
+
+  const authEnv = {
+    ...env,
+    FARMING_DISABLE_AUTH: env.FARMING_NET_DISABLE_AUTH || '',
+    FARMING_TOKEN: env.FARMING_NET_TOKEN || '',
+  };
+  const tokenAuth = options.tokenAuth || new TokenAuth({
+    basePath: basePath || '/',
+    cookieName: 'farming_net_token',
+    cookiePath: basePath || '/',
+    disabled: options.authDisabled === true || isTruthy(env.FARMING_NET_DISABLE_AUTH),
+    env: authEnv,
+    farmingDir: configDir,
+    farmingNetPassVerifier: false,
+    redirectQueryToken: true,
+    token: env.FARMING_NET_TOKEN || '',
+  });
+
+  const routePath = suffix => `${basePath}${suffix}` || '/';
+  const staticAssets = new Map([
+    [routePath('/app.css'), { file: path.join(assetDir, 'app.css'), type: 'text/css; charset=utf-8' }],
+    [routePath('/app.js'), { file: path.join(assetDir, 'app.js'), type: 'text/javascript; charset=utf-8' }],
+    [routePath('/icon.png'), { file: iconFile, type: 'image/png' }],
+  ]);
+
+  const server = http.createServer((req, res) => {
+    setSecurityHeaders(res);
+    tokenAuth.middleware()(req, res, () => {
+      try {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const pathname = url.pathname;
+        if (!['GET', 'HEAD'].includes(String(req.method || 'GET').toUpperCase())) {
+          sendJson(req, res, 405, { error: 'Method not allowed' });
+          return;
+        }
+
+        if (pathname === routePath('/api/auth/status')) {
+          sendJson(req, res, 200, { authRequired: tokenAuth.isEnabled() });
+          return;
+        }
+        if (pathname === routePath('/api/status')) {
+          sendJson(req, res, 200, {
+            name: 'Farming Net',
+            version: packageVersion,
+            basePath: basePath || '/',
+          });
+          return;
+        }
+        if (pathname === routePath('/api/instances')) {
+          sendJson(req, res, 200, browserRegistry(loadFarmingNetRegistry(registryFile), basePath));
+          return;
+        }
+        const openPrefix = routePath('/open/');
+        if (pathname.startsWith(openPrefix)) {
+          const parts = pathname.slice(openPrefix.length).split('/');
+          const instanceId = parts[0] || '';
+          const endpointIndex = Number(parts[1]);
+          const registry = loadFarmingNetRegistry(registryFile);
+          const instance = registry.instances.find(item => item.id === instanceId);
+          const endpoint = Number.isInteger(endpointIndex) && endpointIndex >= 0
+            ? instance && instance.endpoints[endpointIndex]
+            : null;
+          if (!instance || !endpoint || parts.length !== 2) {
+            sendJson(req, res, 404, { error: 'Farming instance endpoint not found' });
+            return;
+          }
+          const target = new URL(endpoint.url);
+          if (instance.federated) {
+            target.searchParams.set(PASS_QUERY_PARAM, createFarmingNetPass(signingIdentity, {
+              audience: instance.id,
+              subject: 'owner',
+              ttlSeconds: env.FARMING_NET_PASS_TTL_SECONDS,
+            }));
+          }
+          res.writeHead(302, {
+            'Cache-Control': 'no-store',
+            Location: target.toString(),
+          });
+          res.end();
+          return;
+        }
+        if (basePath && pathname === basePath) {
+          res.writeHead(302, { Location: `${basePath || ''}/` });
+          res.end();
+          return;
+        }
+        if (pathname === (basePath ? `${basePath}/` : '/')) {
+          const index = readAsset(path.join(assetDir, 'index.html'));
+          if (!index) {
+            sendJson(req, res, 500, { error: 'Farming Net frontend assets are missing' });
+            return;
+          }
+          sendBuffer(req, res, 200, index, 'text/html; charset=utf-8');
+          return;
+        }
+
+        const asset = staticAssets.get(pathname);
+        if (asset && asset.file) {
+          const body = readAsset(asset.file);
+          if (body) {
+            sendBuffer(req, res, 200, body, asset.type, 'public, max-age=3600');
+            return;
+          }
+        }
+        sendJson(req, res, 404, { error: 'Not found' });
+      } catch (error) {
+        console.error('Farming Net request failed:', error);
+        if (!res.headersSent) sendJson(req, res, 500, { error: 'Farming Net request failed' });
+        else res.end();
+      }
+    });
+  });
+
+  server.on('listening', () => {
+    const address = server.address();
+    const listeningPort = address && typeof address === 'object' ? address.port : null;
+    fs.writeFileSync(stateFile, `${JSON.stringify({
+      pid: process.pid,
+      port: listeningPort,
+      basePath: basePath || '/',
+      configDir,
+      registryFile,
+      signingIssuer: signingIdentity.issuer,
+      updatedAt: new Date().toISOString(),
+    }, null, 2)}\n`, { mode: 0o600 });
+  });
+  server.on('close', () => {
+    try {
+      const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      if (state.pid === process.pid) fs.unlinkSync(stateFile);
+    } catch {
+      // Ignore missing or stale state files.
+    }
+  });
+
+  return {
+    basePath,
+    configDir,
+    packageVersion,
+    registryFile,
+    server,
+    stateFile,
+    signingIdentity,
+    tokenAuth,
+  };
+}
+
+function startFromCommandLine() {
+  const service = createFarmingNetServer();
+  const port = safePort(process.env.FARMING_NET_PORT || process.env.PORT, DEFAULT_PORT);
+  const host = process.env.FARMING_NET_HOST || '0.0.0.0';
+  service.server.listen(port, host, () => {
+    const entryPath = `${service.basePath || ''}/`;
+    const token = service.tokenAuth.getToken();
+    const query = token ? `?token=${encodeURIComponent(token)}` : '';
+    console.log(`Farming Net ${service.packageVersion}`);
+    console.log(`URL: http://127.0.0.1:${port}${entryPath}${query}`);
+    console.log(`Registry: ${service.registryFile}`);
+  });
+
+  const shutdown = signal => {
+    console.log(`Farming Net received ${signal}; shutting down.`);
+    service.server.close(() => process.exit(0));
+    setTimeout(() => process.exit(1), 5000).unref();
+  };
+  process.once('SIGINT', () => shutdown('SIGINT'));
+  process.once('SIGTERM', () => shutdown('SIGTERM'));
+}
+
+if (require.main === module) startFromCommandLine();
+
+module.exports = {
+  DEFAULT_BASE_PATH,
+  DEFAULT_PORT,
+  createFarmingNetServer,
+  normalizeBasePath,
+  safePort,
+};

package/backend/farming-session-store.js

@@ -1,6 +1,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { legacyRuntimeMetadata } = require('./agent-runtime-binding');
 const storageLayout = require('./storage-layout');
 
 const SESSION_ID_PREFIX = 'fsess';
@@ -166,24 +167,14 @@ class FarmingSessionStore {
       providerSessionSource: typeof agent.providerSessionSource === 'string' ? agent.providerSessionSource : '',
       providerSessionResolvedAt: typeof agent.providerSessionResolvedAt === 'number' ? agent.providerSessionResolvedAt : null,
       providerSessionTitle: typeof agent.providerSessionTitle === 'string' ? agent.providerSessionTitle : '',
+      providerSessionWorkspace: typeof agent.providerSessionWorkspace === 'string' ? agent.providerSessionWorkspace : '',
       terminalInputReceived: agent.terminalInputReceived === true,
-      codexRuntimeMode: typeof agent.codexRuntimeMode === 'string' ? agent.codexRuntimeMode : '',
-      agentRuntimeMode: typeof agent.agentRuntimeMode === 'string' ? agent.agentRuntimeMode : 'terminal',
-      acpState: typeof agent.acpState === 'string' ? agent.acpState : '',
-      acpError: typeof agent.acpError === 'string' ? agent.acpError : '',
-      acpStopReason: typeof agent.acpStopReason === 'string' ? agent.acpStopReason : '',
-      acpSessionUpdatedAt: typeof agent.acpSessionUpdatedAt === 'string' ? agent.acpSessionUpdatedAt : '',
-      codexAppServerHomePath: typeof agent.codexAppServerHomePath === 'string' ? agent.codexAppServerHomePath : '',
-      codexAppServerState: typeof agent.codexAppServerState === 'string' ? agent.codexAppServerState : '',
-      codexAppServerEndpoint: typeof agent.codexAppServerEndpoint === 'string' ? agent.codexAppServerEndpoint : '',
-      codexAppServerThreadId: typeof agent.codexAppServerThreadId === 'string' ? agent.codexAppServerThreadId : '',
-      codexAppServerTurnId: typeof agent.codexAppServerTurnId === 'string' ? agent.codexAppServerTurnId : '',
-      codexAppServerError: typeof agent.codexAppServerError === 'string' ? agent.codexAppServerError : '',
-      codexCliObserverDeferred: agent.codexCliObserverDeferred === true,
+      ...legacyRuntimeMetadata(agent),
       engine: typeof agent.engineName === 'string' ? agent.engineName : '',
       category: typeof agent.category === 'string' ? agent.category : '',
       task: typeof agent.task === 'string' ? agent.task : '',
       workflowTemplate: typeof agent.workflowTemplate === 'string' ? agent.workflowTemplate : '',
+      wantsMain: agent.wantsMain === true,
       pinned: agent.pinned === true,
       projectOrder: typeof agent.projectOrder === 'number' && Number.isFinite(agent.projectOrder) ? agent.projectOrder : null,
       pinnedOrder: typeof agent.pinnedOrder === 'number' && Number.isFinite(agent.pinnedOrder) ? agent.pinnedOrder : null,
@@ -195,6 +186,7 @@ class FarmingSessionStore {
       attentionOutputSeq: typeof agent.attentionOutputSeq === 'number' ? agent.attentionOutputSeq : null,
       archived: agent.archived === true,
       archivedAt: typeof agent.archivedAt === 'number' ? agent.archivedAt : null,
+      customTitle: typeof agent.customTitle === 'string' ? agent.customTitle : '',
       title: typeof agent.customTitle === 'string' && agent.customTitle
         ? agent.customTitle
         : (typeof agent.providerSessionTitle === 'string' && agent.providerSessionTitle

package/backend/git-worktree-info.js

@@ -0,0 +1,181 @@
+const { execFile } = require('child_process');
+const path = require('path');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 5000;
+const DEFAULT_CACHE_MS = 3000;
+const cache = new Map();
+
+function normalizePathValue(value) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+  return path.resolve(trimmed);
+}
+
+function isSameOrDescendantPath(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+function normalizeBranchRef(value) {
+  const branch = String(value || '').trim();
+  return branch.startsWith('refs/heads/') ? branch.slice('refs/heads/'.length) : branch;
+}
+
+function parseGitWorktreeList(output) {
+  const records = [];
+  let current = null;
+
+  for (const token of String(output || '').split('\0')) {
+    if (!token) {
+      if (current) records.push(current);
+      current = null;
+      continue;
+    }
+
+    const separator = token.indexOf(' ');
+    const key = separator === -1 ? token : token.slice(0, separator);
+    const value = separator === -1 ? '' : token.slice(separator + 1);
+    if (key === 'worktree') {
+      if (current) records.push(current);
+      current = { path: normalizePathValue(value) };
+      continue;
+    }
+    if (!current) continue;
+
+    if (key === 'HEAD') current.head = value;
+    if (key === 'branch') current.branch = normalizeBranchRef(value);
+    if (key === 'bare') current.bare = true;
+    if (key === 'detached') current.detached = true;
+    if (key === 'locked') {
+      current.locked = true;
+      current.lockReason = value || '';
+    }
+    if (key === 'prunable') {
+      current.prunable = true;
+      current.pruneReason = value || '';
+    }
+  }
+
+  if (current) records.push(current);
+  return records.filter(record => record.path);
+}
+
+function matchingWorktree(records, target) {
+  return records
+    .filter(record => isSameOrDescendantPath(record.path, target))
+    .sort((a, b) => b.path.length - a.path.length)[0] || null;
+}
+
+async function inspectGitWorktreeUncached(workspace, options = {}) {
+  const candidate = normalizePathValue(workspace);
+  if (!candidate) return null;
+  const timeout = Number.isFinite(options.timeoutMs)
+    ? Math.max(250, options.timeoutMs)
+    : DEFAULT_TIMEOUT_MS;
+  const exec = options.execFileAsync || execFileAsync;
+
+  try {
+    const commonDirPromise = exec('git', ['-C', candidate, 'rev-parse', '--path-format=absolute', '--git-common-dir'], {
+      timeout,
+      maxBuffer: 1024 * 1024,
+    }).catch(async () => {
+      const { stdout } = await exec('git', ['-C', candidate, 'rev-parse', '--git-common-dir'], {
+        timeout,
+        maxBuffer: 1024 * 1024,
+      });
+      const value = String(stdout || '').trim();
+      return { stdout: path.isAbsolute(value) ? value : path.resolve(candidate, value) };
+    });
+    const [{ stdout: topLevelOutput }, { stdout: commonDirOutput }, { stdout: listOutput }] = await Promise.all([
+      exec('git', ['-C', candidate, 'rev-parse', '--show-toplevel'], {
+        timeout,
+        maxBuffer: 1024 * 1024,
+      }),
+      commonDirPromise,
+      exec('git', ['-C', candidate, 'worktree', 'list', '--porcelain', '-z'], {
+        timeout,
+        maxBuffer: 4 * 1024 * 1024,
+      }),
+    ]);
+
+    const topLevel = normalizePathValue(topLevelOutput);
+    const commonDir = normalizePathValue(commonDirOutput);
+    const worktrees = parseGitWorktreeList(listOutput);
+    const worktree = matchingWorktree(worktrees, topLevel || candidate);
+    if (!topLevel || !commonDir || !worktree) return null;
+    const mainWorktree = worktrees.find(record => !record.bare) || null;
+    const linked = Boolean(mainWorktree && mainWorktree.path !== worktree.path);
+    const mainWorkspace = mainWorktree ? mainWorktree.path : worktree.path;
+    const worktreeItems = worktrees.map(record => ({
+      workspace: record.path,
+      head: record.head || '',
+      branch: record.branch || '',
+      bare: record.bare === true,
+      detached: record.detached === true,
+      locked: record.locked === true,
+      lockReason: record.lockReason || '',
+      prunable: record.prunable === true,
+      pruneReason: record.pruneReason || '',
+      current: record.path === worktree.path,
+      main: record.path === mainWorkspace,
+    }));
+
+    return {
+      workspace: worktree.path,
+      commonDir,
+      mainWorkspace,
+      linked,
+      branch: worktree.branch || '',
+      head: worktree.head || '',
+      detached: worktree.detached === true,
+      locked: worktree.locked === true,
+      lockReason: worktree.lockReason || '',
+      prunable: worktree.prunable === true,
+      pruneReason: worktree.pruneReason || '',
+      worktrees: worktreeItems,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function inspectGitWorktree(workspace, options = {}) {
+  if (options.execFileAsync) return inspectGitWorktreeUncached(workspace, options);
+  const candidate = normalizePathValue(workspace);
+  if (!candidate) return null;
+  const now = Date.now();
+  const maxAgeMs = Number.isFinite(options.cacheMs)
+    ? Math.max(0, options.cacheMs)
+    : DEFAULT_CACHE_MS;
+  const cached = cache.get(candidate);
+  if (cached && now - cached.createdAt <= maxAgeMs) return cached.promise;
+
+  const promise = inspectGitWorktreeUncached(candidate, options);
+  cache.set(candidate, { createdAt: now, promise });
+  promise.catch(() => {
+    if (cache.get(candidate)?.promise === promise) cache.delete(candidate);
+  });
+  return promise;
+}
+
+async function isLinkedWorktreeOf(workspace, candidate, options = {}) {
+  const [sourceInfo, candidateInfo] = await Promise.all([
+    inspectGitWorktree(workspace, options),
+    inspectGitWorktree(candidate, options),
+  ]);
+  return Boolean(
+    sourceInfo
+    && candidateInfo
+    && sourceInfo.commonDir === candidateInfo.commonDir
+    && candidateInfo.linked
+  );
+}
+
+module.exports = {
+  inspectGitWorktree,
+  isLinkedWorktreeOf,
+  parseGitWorktreeList,
+};