farming-code 2.2.29 → 2.2.32

package/backend/async-cache.js

@@ -1,94 +0,0 @@
-class AsyncCache {
-  constructor(loader, options = {}) {
-    if (typeof loader !== 'function') {
-      throw new TypeError('AsyncCache loader must be a function');
-    }
-
-    this.loader = loader;
-    this.ttlMs = Number.isFinite(options.ttlMs) ? Math.max(0, options.ttlMs) : 30_000;
-    this.staleMs = Number.isFinite(options.staleMs) ? Math.max(this.ttlMs, options.staleMs) : this.ttlMs;
-    this.now = typeof options.now === 'function' ? options.now : () => Date.now();
-    this.entries = new Map();
-  }
-
-  isFresh(entry, now) {
-    return entry.hasValue && now - entry.fetchedAt <= this.ttlMs;
-  }
-
-  isStaleUsable(entry, now) {
-    return entry.hasValue && now - entry.fetchedAt <= this.staleMs;
-  }
-
-  async refresh(entryId, entry) {
-    if (entry.pending) return entry.pending;
-
-    entry.pending = Promise.resolve()
-      .then(() => this.loader(entryId))
-      .then(value => {
-        entry.value = value;
-        entry.fetchedAt = this.now();
-        entry.hasValue = true;
-        entry.error = null;
-        return value;
-      })
-      .catch(error => {
-        entry.error = error;
-        throw error;
-      })
-      .finally(() => {
-        entry.pending = null;
-      });
-
-    return entry.pending;
-  }
-
-  get(entryId = 'default', options = {}) {
-    const cacheId = String(entryId);
-    const now = this.now();
-    const maxAgeMs = Number.isFinite(options.maxAgeMs)
-      ? Math.max(0, options.maxAgeMs)
-      : null;
-    let entry = this.entries.get(cacheId);
-    if (!entry) {
-      entry = {
-        value: null,
-        fetchedAt: 0,
-        hasValue: false,
-        pending: null,
-        error: null,
-      };
-      this.entries.set(cacheId, entry);
-    }
-
-    if (!options.force && maxAgeMs !== null) {
-      if (entry.hasValue && now - entry.fetchedAt <= maxAgeMs) {
-        return Promise.resolve(entry.value);
-      }
-      return this.refresh(cacheId, entry);
-    }
-
-    if (!options.force && this.isFresh(entry, now)) {
-      return Promise.resolve(entry.value);
-    }
-
-    if (!options.force && this.isStaleUsable(entry, now)) {
-      this.refresh(cacheId, entry).catch(() => {});
-      return Promise.resolve(entry.value);
-    }
-
-    return this.refresh(cacheId, entry);
-  }
-
-  invalidate(entryId = null) {
-    if (entryId === null || entryId === undefined) {
-      this.entries.clear();
-      return;
-    }
-
-    this.entries.delete(String(entryId));
-  }
-}
-
-module.exports = {
-  AsyncCache,
-};

package/backend/atomic-json-store.js

@@ -1,37 +0,0 @@
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-function atomicWriteJson(file, value, options = {}) {
-  const fileSystem = options.fileSystem || fs;
-  const temporaryFile = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  const suffix = options.trailingNewline ? '\n' : '';
-  let descriptor = null;
-
-  fileSystem.mkdirSync(path.dirname(file), { recursive: true });
-  try {
-    descriptor = fileSystem.openSync(temporaryFile, 'wx', options.mode);
-    fileSystem.writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}${suffix}`, 'utf8');
-    fileSystem.fdatasyncSync(descriptor);
-    fileSystem.closeSync(descriptor);
-    descriptor = null;
-    fileSystem.renameSync(temporaryFile, file);
-  } finally {
-    if (descriptor !== null) {
-      try {
-        fileSystem.closeSync(descriptor);
-      } catch {
-        // Preserve the original write failure.
-      }
-    }
-    try {
-      fileSystem.unlinkSync(temporaryFile);
-    } catch {
-      // A successful rename already removed the temporary path.
-    }
-  }
-}
-
-module.exports = {
-  atomicWriteJson,
-};

package/backend/auth.js

@@ -1,251 +0,0 @@
-const crypto = require('crypto');
-const fs = require('fs');
-const { FarmingNetPassVerifier, PASS_QUERY_PARAM } = require('./farming-net-pass');
-const { createPoeticToken, generatePoeticToken, getPoeticTokenEntropyBits } = require('./haiku-token');
-const storageLayout = require('./storage-layout');
-
-function normalizeBasePath(basePath) {
-  if (!basePath || basePath === '/') return '';
-  return basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
-}
-
-function isTruthyEnv(value) {
-  return ['1', 'true', 'yes', 'on'].includes(String(value || '').toLowerCase());
-}
-
-function encodeCookieToken(token) {
-  return encodeURIComponent(token);
-}
-
-function decodeCookieToken(token) {
-  try {
-    return decodeURIComponent(token);
-  } catch {
-    return token;
-  }
-}
-
-function normalizeCookieName(value) {
-  const cookieName = String(value || '').trim();
-  return /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(cookieName) ? cookieName : 'farming_token';
-}
-
-function normalizeCookiePath(value) {
-  const cookiePath = String(value || '/').trim();
-  if (!cookiePath.startsWith('/') || /[;\r\n]/.test(cookiePath)) return '/';
-  return cookiePath;
-}
-
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function readExistingTokenFile(tokenFile) {
-  try {
-    const token = fs.readFileSync(tokenFile, 'utf8').trim();
-    return token || '';
-  } catch {
-    return '';
-  }
-}
-
-class TokenAuth {
-  constructor(options = {}) {
-    const authEnv = options.env || process.env;
-    this.disabled = options.disabled === true || isTruthyEnv(authEnv.FARMING_DISABLE_AUTH);
-    this.basePath = normalizeBasePath(options.basePath || '/');
-    this.authStatusPath = this.basePath ? `${this.basePath}/api/auth/status` : '/api/auth/status';
-    this.cookieName = normalizeCookieName(options.cookieName);
-    this.cookiePath = normalizeCookiePath(options.cookiePath);
-    this.redirectQueryToken = options.redirectQueryToken === true;
-    this.tokenFile = '';
-    this.token = '';
-    this.tokenInfo = null;
-    this.farmingNetPassVerifier = null;
-
-    if (this.disabled) {
-      return;
-    }
-
-    const farmingDir = options.farmingDir || storageLayout.farmingConfigDir();
-    if (!fs.existsSync(farmingDir)) {
-      fs.mkdirSync(farmingDir, { recursive: true });
-    }
-    this.tokenFile = storageLayout.sessionTokenFile(farmingDir);
-    if (options.farmingNetPassVerifier !== false) {
-      this.farmingNetPassVerifier = options.farmingNetPassVerifier || new FarmingNetPassVerifier({
-        trustFile: options.farmingNetTrustFile || storageLayout.farmingNetTrustFile(farmingDir),
-      });
-    }
-    const configuredTokenSource = Object.prototype.hasOwnProperty.call(options, 'token')
-      ? options.token
-      : authEnv.FARMING_TOKEN;
-    const configuredToken = String(configuredTokenSource || '').trim();
-    const existingToken = configuredToken ? '' : readExistingTokenFile(this.tokenFile);
-    if (configuredToken) {
-      this.token = configuredToken;
-      this.tokenInfo = {
-        token: configuredToken,
-        style: 'configured',
-        source: 'FARMING_TOKEN',
-        entropyBits: 0,
-      };
-    } else if (existingToken) {
-      this.token = existingToken;
-      this.tokenInfo = {
-        token: this.token,
-        style: 'persisted',
-        source: this.tokenFile,
-        entropyBits: 0,
-      };
-    } else {
-      this.tokenInfo = createPoeticToken({ locale: options.tokenLocale, env: authEnv, timeZone: options.timeZone });
-      this.token = this.tokenInfo.token;
-    }
-    this.saveTokenFile();
-  }
-
-  saveTokenFile() {
-    if (this.disabled || !this.tokenFile) return;
-    fs.writeFileSync(this.tokenFile, this.token, { mode: 0o600 });
-  }
-
-  isEnabled() {
-    return !this.disabled;
-  }
-
-  getToken() {
-    return this.token;
-  }
-
-  getTokenFile() {
-    return this.tokenFile;
-  }
-
-  getTokenInfo() {
-    return this.tokenInfo;
-  }
-
-  getCookieName() {
-    return this.cookieName;
-  }
-
-  verify(token) {
-    if (this.disabled) return true;
-    if (!token || !this.token) return false;
-    try {
-      const a = Buffer.from(token);
-      const b = Buffer.from(this.token);
-      if (a.length !== b.length) return false;
-      return crypto.timingSafeEqual(a, b);
-    } catch {
-      return false;
-    }
-  }
-
-  extractToken(req) {
-    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-    const queryToken = url.searchParams.get('token');
-    if (queryToken) return queryToken;
-
-    return this.extractCookieToken(req);
-  }
-
-  extractCookieToken(req) {
-    const cookies = req.headers.cookie || '';
-    const match = cookies.match(new RegExp(`(?:^|;\\s*)${escapeRegExp(this.cookieName)}=([^;]+)`));
-    if (match) return decodeCookieToken(match[1]);
-
-    return null;
-  }
-
-  setAuthenticatedCookie(res) {
-    res.setHeader('Set-Cookie',
-      `${this.cookieName}=${encodeCookieToken(this.token)}; Path=${this.cookiePath}; HttpOnly; SameSite=Lax`);
-  }
-
-  redirectWithoutQueryParameter(res, url, parameter) {
-    url.searchParams.delete(parameter);
-    const search = url.searchParams.toString();
-    res.writeHead(302, {
-      'Cache-Control': 'no-store',
-      Location: `${url.pathname}${search ? `?${search}` : ''}`,
-    });
-    res.end();
-  }
-
-  middleware() {
-    return (req, res, next) => {
-      if (this.disabled) return next();
-
-      const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-
-      // Allow auth status endpoint without authentication
-      if (url.pathname === this.authStatusPath) {
-        return next();
-      }
-
-      const method = String(req.method || 'GET').toUpperCase();
-      if (['GET', 'HEAD'].includes(method) && url.searchParams.has(PASS_QUERY_PARAM)) {
-        const pass = url.searchParams.get(PASS_QUERY_PARAM);
-        const passResult = this.farmingNetPassVerifier
-          ? this.farmingNetPassVerifier.verify(pass)
-          : { valid: false };
-        if (passResult.valid) {
-          this.setAuthenticatedCookie(res);
-          this.redirectWithoutQueryParameter(res, url, PASS_QUERY_PARAM);
-          return;
-        }
-        const cookieToken = this.extractCookieToken(req);
-        if (cookieToken && this.verify(cookieToken)) {
-          this.redirectWithoutQueryParameter(res, url, PASS_QUERY_PARAM);
-          return;
-        }
-      }
-
-      const token = this.extractToken(req);
-
-      // URL has token query param -> validate, set cookie, redirect
-      if (url.searchParams.has('token')) {
-        if (token && this.verify(token)) {
-          this.setAuthenticatedCookie(res);
-          if (this.redirectQueryToken && ['GET', 'HEAD'].includes(method)) {
-            this.redirectWithoutQueryParameter(res, url, 'token');
-            return;
-          }
-          return next();
-        }
-      }
-
-      // Cookie-based verification
-      if (token && this.verify(token)) {
-        return next();
-      }
-
-      // Unauthorized
-      res.writeHead(401, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Token required. Use the URL printed in terminal.' }));
-    };
-  }
-
-  verifyWebSocket(req) {
-    if (this.disabled) return true;
-    const token = this.extractToken(req);
-    return token !== null && this.verify(token);
-  }
-
-  cleanup(options = {}) {
-    if (options.removeTokenFile !== true) return;
-    try {
-      fs.unlinkSync(this.tokenFile);
-    } catch {
-      // ignore
-    }
-  }
-}
-
-module.exports = TokenAuth;
-module.exports.generatePoeticToken = generatePoeticToken;
-module.exports.getPoeticTokenEntropyBits = getPoeticTokenEntropyBits;
-module.exports.encodeCookieToken = encodeCookieToken;
-module.exports.decodeCookieToken = decodeCookieToken;

package/backend/bundle-update-helper.js

@@ -1,113 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-function writeJsonAtomic(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const temporaryPath = `${filePath}.${process.pid}.tmp`;
-  fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-  fs.renameSync(temporaryPath, filePath);
-}
-
-function appendLog(logPath, message) {
-  fs.mkdirSync(path.dirname(logPath), { recursive: true });
-  fs.appendFileSync(logPath, `[${new Date().toISOString()}] ${message}\n`);
-}
-
-function validatePayload(payload) {
-  if (!payload || typeof payload !== 'object') throw new Error('Missing bundle update payload');
-  for (const key of ['stateFile', 'logPath', 'releaseDir', 'installer']) {
-    if (!path.isAbsolute(String(payload[key] || ''))) throw new Error(`Invalid bundle update ${key}`);
-  }
-  if (!/^[0-9A-Za-z.+-]+$/.test(String(payload.version || ''))) {
-    throw new Error('Invalid bundle update version');
-  }
-  return payload;
-}
-
-function stateFor(payload, phase, extra = {}) {
-  return {
-    method: payload.method,
-    targetMethod: payload.targetMethod,
-    phase,
-    version: payload.version,
-    previousVersion: payload.previousVersion,
-    startedAt: payload.startedAt,
-    logPath: payload.logPath,
-    ...extra,
-  };
-}
-
-function commandEnvironment() {
-  const env = { ...process.env };
-  delete env.FARMING_BUNDLE_UPDATE_PAYLOAD;
-  delete env.FARMING_RUN_SERVER;
-  delete env.FARMING_RUN_NATIVE_PTY_HOST;
-  return env;
-}
-
-function runInstaller(payload) {
-  return new Promise((resolve, reject) => {
-    const logFd = fs.openSync(payload.logPath, 'a');
-    const child = spawn('bash', [payload.installer, 'install'], {
-      cwd: payload.releaseDir,
-      env: commandEnvironment(),
-      stdio: ['ignore', logFd, logFd],
-    });
-    child.once('error', error => {
-      fs.closeSync(logFd);
-      reject(error);
-    });
-    child.once('exit', (code, signal) => {
-      fs.closeSync(logFd);
-      if (code === 0) {
-        resolve();
-        return;
-      }
-      reject(new Error(`bundle installer exited with ${signal || code}`));
-    });
-  });
-}
-
-async function runBundleUpdate(rawPayload) {
-  const payload = validatePayload(rawPayload);
-  writeJsonAtomic(payload.stateFile, stateFor(payload, 'restarting', {
-    preparedAt: payload.preparedAt,
-  }));
-  await new Promise(resolve => setTimeout(resolve, 1_000));
-  try {
-    await runInstaller(payload);
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'succeeded', {
-      preparedAt: payload.preparedAt,
-      completedAt: new Date().toISOString(),
-    }));
-    appendLog(payload.logPath, `Farming updated to ${payload.version}`);
-  } catch (error) {
-    const message = error && error.message ? error.message : String(error);
-    writeJsonAtomic(payload.stateFile, stateFor(payload, 'failed', {
-      preparedAt: payload.preparedAt,
-      error: message,
-      completedAt: new Date().toISOString(),
-    }));
-    appendLog(payload.logPath, `Update failed: ${message}`);
-  }
-}
-
-if (require.main === module) {
-  let payload;
-  try {
-    payload = JSON.parse(process.env.FARMING_BUNDLE_UPDATE_PAYLOAD || '');
-  } catch {
-    console.error('Invalid FARMING_BUNDLE_UPDATE_PAYLOAD');
-    process.exit(1);
-  }
-  runBundleUpdate(payload).catch(error => {
-    console.error(error.message || error);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  runBundleUpdate,
-  validatePayload,
-};

package/backend/chat-runtime.js

@@ -1,28 +0,0 @@
-// Chat is a product-level intent. ACP is the single structured Chat runtime for
-// every supported coding agent, including Codex.
-const CHAT_MODE = 'chat';
-
-function chatRuntimeForProvider() {
-  return 'acp';
-}
-
-function isChatMode(mode) {
-  return mode === CHAT_MODE;
-}
-
-function chatCapabilitiesForProvider(provider) {
-  const runtime = chatRuntimeForProvider(provider);
-  return {
-    chatRuntime: runtime,
-    supportsChat: true,
-    // ACP does not currently define a turn-versioned steer operation.
-    supportsSteer: false,
-  };
-}
-
-module.exports = {
-  CHAT_MODE,
-  chatRuntimeForProvider,
-  chatCapabilitiesForProvider,
-  isChatMode,
-};

package/backend/claude-settings.js

@@ -1,121 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const CLAUDE_MODEL_ENV_KEYS = [
-  'ANTHROPIC_MODEL',
-  'ANTHROPIC_DEFAULT_SONNET_MODEL',
-  'ANTHROPIC_DEFAULT_OPUS_MODEL',
-  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
-];
-
-const CLAUDE_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max'];
-
-const CLAUDE_EFFORT_OPTIONS = [
-  { value: 'low', effort: 'low', label: 'Low' },
-  { value: 'medium', effort: 'medium', label: 'Medium' },
-  { value: 'high', effort: 'high', label: 'High' },
-  { value: 'xhigh', effort: 'xhigh', label: 'Extra High' },
-  { value: 'max', effort: 'max', label: 'Max' },
-];
-
-function normalizeClaudeModelValue(model) {
-  if (typeof model !== 'string') return '';
-  const value = model.trim();
-  if (!value || value.length > 200) return '';
-  if (/[\s\x00-\x1f\x7f]/.test(value)) return '';
-  if (value.startsWith('-')) return '';
-  return value;
-}
-
-function normalizeClaudeEffortValue(effort) {
-  return CLAUDE_EFFORT_VALUES.includes(effort) ? effort : '';
-}
-
-function getClaudeSettingsFile(options = {}) {
-  if (options.settingsFile) return options.settingsFile;
-  if (process.env.FARMING_CLAUDE_SETTINGS_FILE) return process.env.FARMING_CLAUDE_SETTINGS_FILE;
-
-  const home = options.home || os.homedir();
-  return path.join(home, '.claude', 'settings.json');
-}
-
-function pushUnique(values, value) {
-  if (value && !values.includes(value)) values.push(value);
-}
-
-function emptyClaudeSettingsSummary(available = false) {
-  return {
-    available,
-    effectiveModel: '',
-    effectiveEffort: '',
-    modelOptions: [],
-    effortOptions: CLAUDE_EFFORT_OPTIONS,
-  };
-}
-
-function summarizeClaudeSettings(rawSettings) {
-  if (!rawSettings || typeof rawSettings !== 'object') {
-    return emptyClaudeSettingsSummary(false);
-  }
-
-  const env = rawSettings.env && typeof rawSettings.env === 'object'
-    ? rawSettings.env
-    : {};
-  const modelValues = [];
-  CLAUDE_MODEL_ENV_KEYS.forEach((key) => {
-    pushUnique(modelValues, normalizeClaudeModelValue(env[key]));
-  });
-
-  const effectiveModel = normalizeClaudeModelValue(env.ANTHROPIC_MODEL) || modelValues[0] || '';
-  const effectiveEffort = normalizeClaudeEffortValue(rawSettings.effortLevel);
-  const modelOptions = modelValues.map((model) => ({
-    value: model,
-    label: model,
-    displayName: model,
-    defaultEffort: effectiveEffort || 'medium',
-    reasoningLevels: CLAUDE_EFFORT_OPTIONS,
-    source: 'settings',
-  }));
-
-  if (effectiveModel && !modelOptions.some((option) => option.value === effectiveModel)) {
-    modelOptions.unshift({
-      value: effectiveModel,
-      label: effectiveModel,
-      displayName: effectiveModel,
-      defaultEffort: effectiveEffort || 'medium',
-      reasoningLevels: CLAUDE_EFFORT_OPTIONS,
-      source: 'settings',
-    });
-  }
-
-  return {
-    available: true,
-    effectiveModel,
-    effectiveEffort,
-    modelOptions,
-    effortOptions: CLAUDE_EFFORT_OPTIONS,
-  };
-}
-
-function readClaudeSettingsSummary(options = {}) {
-  const settingsFile = getClaudeSettingsFile(options);
-  if (!settingsFile || !fs.existsSync(settingsFile)) {
-    return emptyClaudeSettingsSummary(false);
-  }
-
-  try {
-    const rawSettings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
-    return summarizeClaudeSettings(rawSettings);
-  } catch {
-    return emptyClaudeSettingsSummary(false);
-  }
-}
-
-module.exports = {
-  CLAUDE_EFFORT_OPTIONS,
-  normalizeClaudeEffortValue,
-  normalizeClaudeModelValue,
-  readClaudeSettingsSummary,
-  summarizeClaudeSettings,
-};