farming-code 2.2.6

package/backend/async-cache.js

@@ -0,0 +1,94 @@
+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/auth.js

@@ -0,0 +1,178 @@
+const crypto = require('crypto');
+const fs = require('fs');
+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 readExistingTokenFile(tokenFile) {
+  try {
+    const token = fs.readFileSync(tokenFile, 'utf8').trim();
+    return token || '';
+  } catch {
+    return '';
+  }
+}
+
+class TokenAuth {
+  constructor(options = {}) {
+    this.disabled = options.disabled === true || isTruthyEnv(process.env.FARMING_DISABLE_AUTH);
+    this.basePath = normalizeBasePath(options.basePath || '/');
+    this.authStatusPath = this.basePath ? `${this.basePath}/api/auth/status` : '/api/auth/status';
+    this.tokenFile = '';
+    this.token = '';
+    this.tokenInfo = 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);
+    const configuredToken = String(options.token || process.env.FARMING_TOKEN || '').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: options.env, 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;
+  }
+
+  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;
+
+    const cookies = req.headers.cookie || '';
+    const match = cookies.match(/(?:^|;\s*)farming_token=([^;]+)/);
+    if (match) return decodeCookieToken(match[1]);
+
+    return null;
+  }
+
+  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 token = this.extractToken(req);
+
+      // URL has token query param -> validate, set cookie, redirect
+      if (url.searchParams.has('token')) {
+        if (token && this.verify(token)) {
+          res.setHeader('Set-Cookie',
+            `farming_token=${encodeCookieToken(this.token)}; Path=/; HttpOnly; SameSite=Lax`);
+          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/claude-settings.js

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