farming-code 2.2.14 → 2.2.17

package/backend/update-service.js

@@ -681,6 +681,45 @@ function npmPackageMetadataUrl(registryUrl, packageName) {
   return `${registry}/${encodeURIComponent(packageName).replace(/^%40/, '@')}`;
 }
 
+function normalizePathForCompare(filePath) {
+  try {
+    return fs.realpathSync(filePath);
+  } catch {
+    return path.resolve(filePath);
+  }
+}
+
+function npmPackageRoot(npmRoot, packageName) {
+  return path.join(npmRoot, ...String(packageName || '').split('/').filter(Boolean));
+}
+
+function npmPrefixForPackageRoot(packageRoot, packageName) {
+  const segments = String(packageName || '').split('/').filter(Boolean);
+  if (!path.isAbsolute(packageRoot) || segments.length === 0) return '';
+  let npmRoot = packageRoot;
+  for (let index = 0; index < segments.length; index += 1) npmRoot = path.dirname(npmRoot);
+  return path.dirname(path.dirname(npmRoot));
+}
+
+function readNpmGlobalRoot(npmCommand, npmPrefix, execFile = childProcess.execFile) {
+  const args = ['root', '--global'];
+  if (npmPrefix) args.push('--prefix', npmPrefix);
+  return new Promise((resolve, reject) => {
+    execFile(npmCommand, args, (error, stdout) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      const root = String(stdout || '').split(/\r?\n/).map(value => value.trim()).find(Boolean);
+      if (!root) {
+        reject(new Error('npm root --global returned no path'));
+        return;
+      }
+      resolve(root);
+    });
+  });
+}
+
 function npmVersionsFromMetadata(metadata, currentVersion) {
   const versions = metadata && metadata.versions && typeof metadata.versions === 'object'
     ? Object.keys(metadata.versions)
@@ -711,6 +750,8 @@ class FarmingUpdateService {
     });
     this.npmPackageName = options.npmPackageName || NPM_PACKAGE_NAME;
     this.npmRegistryUrl = options.npmRegistryUrl || process.env.FARMING_NPM_REGISTRY || DEFAULT_NPM_REGISTRY;
+    this.npmPackageRoot = options.npmPackageRoot || process.env.FARMING_MANAGED_PACKAGE_ROOT || '';
+    this.npmPrefix = options.npmPrefix || process.env.FARMING_NPM_PREFIX || '';
     this.runtime = options.platform || options.arch
       ? {
         platform: normalizePlatform(options.platform || process.platform),
@@ -724,6 +765,8 @@ class FarmingUpdateService {
     this.downloadFile = options.downloadFile || downloadFile;
     this.listArchiveEntries = options.listArchiveEntries || listTarArchiveEntries;
     this.execFile = options.execFile || childProcess.execFile;
+    this.getNpmGlobalRoot = options.getNpmGlobalRoot
+      || ((npmCommand, npmPrefix) => readNpmGlobalRoot(npmCommand, npmPrefix, this.execFile));
     this.spawn = options.spawn || childProcess.spawn;
     this.latestCache = null;
     this.npmCache = null;
@@ -782,6 +825,7 @@ class FarmingUpdateService {
     const current = this.currentVersion();
     const currentVersion = normalizeVersion(current.releaseVersion || current.packageVersion);
     const metadata = await this.npmMetadata(options);
+    const target = await this.npmUpdateTarget();
     const versions = npmVersionsFromMetadata(metadata, currentVersion);
     const latestVersion = normalizeVersion(metadata && metadata['dist-tags'] && metadata['dist-tags'].latest)
       || versions[0]?.version
@@ -791,7 +835,8 @@ class FarmingUpdateService {
       || versions.find(version => version.version === latestVersion)
       || versions[0]
       || null;
-    const available = Boolean(selected && selected.available);
+    const blockedReason = target.proven ? '' : target.error;
+    const available = Boolean(selected && selected.available && target.proven);
     return {
       method: 'npm',
       current,
@@ -802,24 +847,63 @@ class FarmingUpdateService {
         publishedAt: '',
         assetName: latestVersion,
         assetSize: 0,
-        blockedReason: '',
+        blockedReason,
         source: npmPackageMetadataUrl(this.npmRegistryUrl, this.npmPackageName),
       },
       selected: {
         version: selected?.version || '',
         assetName: selected?.assetName || '',
         assetSize: selected?.assetSize || 0,
-        blockedReason: selected?.blockedReason || '',
+        blockedReason: selected?.blockedReason || blockedReason,
       },
       versions,
       runtime: this.runtime,
+      target,
       available,
-      installable: Boolean(selected),
+      installable: Boolean(selected && target.proven),
       checkedAt: new Date(this.now()).toISOString(),
       state: this.currentInstallState(),
     };
   }
 
+  async npmUpdateTarget() {
+    const runningPackageRoot = String(this.npmPackageRoot || '').trim();
+    if (!path.isAbsolute(runningPackageRoot)) {
+      return {
+        proven: false,
+        error: 'npm update target could not be proven: the running package has no managed package-root provenance',
+      };
+    }
+    const npmCommand = process.env.FARMING_NPM_COMMAND || 'npm';
+    const npmPrefix = this.npmPrefix || npmPrefixForPackageRoot(runningPackageRoot, this.npmPackageName);
+    if (!npmPrefix) {
+      return {
+        proven: false,
+        error: 'npm update target could not be proven: the running package has no npm prefix',
+      };
+    }
+    try {
+      const root = await this.getNpmGlobalRoot(npmCommand, npmPrefix);
+      const targetPackageRoot = npmPackageRoot(root, this.npmPackageName);
+      if (normalizePathForCompare(runningPackageRoot) !== normalizePathForCompare(targetPackageRoot)) {
+        return {
+          proven: false,
+          error: `npm update would target a different installation: running ${runningPackageRoot}; npm ${targetPackageRoot}`,
+        };
+      }
+      return {
+        proven: true,
+        npmPrefix,
+        packageRoot: targetPackageRoot,
+      };
+    } catch (error) {
+      return {
+        proven: false,
+        error: `npm update target could not be inspected: ${error.message || String(error)}`,
+      };
+    }
+  }
+
   unsupportedStatus() {
     const current = this.currentVersion();
     const reason = installMethodBlockedReason(this.installMethod);
@@ -1081,9 +1165,11 @@ class FarmingUpdateService {
       stateFile: this.updateStateFile,
       logPath: this.updateLogFile,
       cliPath: path.join(this.rootDir, 'bin', 'farming'),
+      packageRoot: status.target.packageRoot,
       nodePath,
       npmCommand: process.env.FARMING_NPM_COMMAND || 'npm',
-      npmPrefix: process.env.FARMING_NPM_PREFIX || '',
+      npmPrefix: status.target.npmPrefix,
+      npmFallbackRegistryUrl: this.npmRegistryUrl,
       serverPid: process.pid,
       configDir: this.configDir,
       port: process.env.FARMING_PORT || process.env.PORT || '6694',
@@ -1181,7 +1267,10 @@ module.exports = {
   installMethodAllowsBundleUpdate,
   normalizeVersion,
   npmPackageMetadataUrl,
+  npmPrefixForPackageRoot,
+  npmPackageRoot,
   npmVersionsFromMetadata,
+  readNpmGlobalRoot,
   releaseInstallDir,
   manifestAssetSafety,
   normalizeSha256,

package/backend/usage-history-client.js

@@ -0,0 +1,305 @@
+const path = require('path');
+const fs = require('fs');
+const { Worker } = require('worker_threads');
+const { usageHistoryCacheFile } = require('./storage-layout');
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_RETENTION_DAYS = 52 * 7;
+const DEFAULT_RECENT_RAW_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_SCAN_BUDGET_MS = 5_000;
+const BACKGROUND_SCAN_DELAY_MS = 100;
+const RESULT_REUSE_MS = 2_000;
+const SOURCE_WORKER_FILE = 'usage-history-worker.js';
+const PACKAGED_WORKER_FILE = 'usage-history-worker.pkg.js';
+let sharedWorkerSession = null;
+let nextWorkerRequestId = 1;
+
+function resolveWorkerFile() {
+  if (!process.pkg && process.env.FARMING_PACKAGED_RUNTIME !== '1') {
+    return SOURCE_WORKER_FILE;
+  }
+  const packaged = path.join(__dirname, PACKAGED_WORKER_FILE);
+  return fs.existsSync(packaged) ? PACKAGED_WORKER_FILE : SOURCE_WORKER_FILE;
+}
+
+function runUsageWorker(request, options = {}) {
+  if (options.WorkerClass) {
+    return runOneShotUsageWorker(request, options);
+  }
+  const workerFile = path.join(__dirname, resolveWorkerFile());
+  if (!sharedWorkerSession || sharedWorkerSession.workerFile !== workerFile) {
+    sharedWorkerSession?.terminate();
+    sharedWorkerSession = createSharedWorkerSession(workerFile, options.WorkerClass || Worker);
+  }
+  return sharedWorkerSession.run(request, options.timeoutMs || DEFAULT_TIMEOUT_MS);
+}
+
+function runOneShotUsageWorker(request, options = {}) {
+  return new Promise((resolve, reject) => {
+    const worker = new (options.WorkerClass || Worker)(
+      path.join(__dirname, resolveWorkerFile()),
+      { workerData: { request } },
+    );
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      worker.terminate().catch(() => {});
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const timeout = setTimeout(() => {
+      const error = new Error(
+        `TypeScript usage scanner exceeded ${options.timeoutMs || DEFAULT_TIMEOUT_MS}ms`,
+      );
+      error.code = 'ETIMEDOUT';
+      finish(error);
+    }, options.timeoutMs || DEFAULT_TIMEOUT_MS);
+    timeout.unref?.();
+    worker.once('error', finish);
+    worker.once('exit', (code) => {
+      if (!settled) {
+        const error = new Error(
+          code === 0
+            ? 'TypeScript usage scanner exited without returning a result'
+            : `TypeScript usage scanner exited with code ${code}`,
+        );
+        error.code = 'EUSAGEWORKER';
+        finish(error);
+      }
+    });
+    worker.once('message', (message) => {
+      if (message?.error) {
+        const error = new Error(message.error.message || 'Usage scanner failed');
+        error.code = message.error.code || 'EUSAGE';
+        error.stack = message.error.stack || error.stack;
+        finish(error);
+        return;
+      }
+      finish(null, message?.result);
+    });
+  });
+}
+
+function createSharedWorkerSession(workerFile, WorkerClass) {
+  const worker = new WorkerClass(workerFile);
+  const pending = new Map();
+  const failAll = (error) => {
+    for (const request of pending.values()) {
+      clearTimeout(request.timeout);
+      request.reject(error);
+    }
+    pending.clear();
+    if (sharedWorkerSession?.worker === worker) sharedWorkerSession = null;
+  };
+  worker.on('message', (message) => {
+    const request = pending.get(message?.requestId);
+    if (!request) return;
+    pending.delete(message.requestId);
+    clearTimeout(request.timeout);
+    if (message?.error) {
+      const error = new Error(message.error.message || 'Usage scanner failed');
+      error.code = message.error.code || 'EUSAGE';
+      error.stack = message.error.stack || error.stack;
+      request.reject(error);
+    } else {
+      request.resolve(message?.result);
+    }
+    if (pending.size === 0) worker.unref?.();
+  });
+  worker.once('error', failAll);
+  worker.once('exit', (code) => {
+    if (pending.size > 0) {
+      const error = new Error(
+        code === 0
+          ? 'TypeScript usage scanner exited before returning all results'
+          : `TypeScript usage scanner exited with code ${code}`,
+      );
+      error.code = 'EUSAGEWORKER';
+      failAll(error);
+    } else if (sharedWorkerSession?.worker === worker) {
+      sharedWorkerSession = null;
+    }
+  });
+  worker.unref?.();
+  return {
+    worker,
+    workerFile,
+    run(request, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        const requestId = nextWorkerRequestId++;
+        const timeout = setTimeout(() => {
+          if (!pending.delete(requestId)) return;
+          const error = new Error(`TypeScript usage scanner exceeded ${timeoutMs}ms`);
+          error.code = 'ETIMEDOUT';
+          reject(error);
+          worker.terminate().catch(() => {});
+          if (sharedWorkerSession?.worker === worker) sharedWorkerSession = null;
+        }, timeoutMs);
+        timeout.unref?.();
+        pending.set(requestId, { resolve, reject, timeout });
+        worker.ref?.();
+        worker.postMessage({ requestId, request });
+      });
+    },
+    terminate() {
+      const error = new Error('Usage scanner worker was replaced');
+      error.code = 'EUSAGEWORKER';
+      failAll(error);
+      worker.terminate().catch(() => {});
+    },
+  };
+}
+
+class UsageHistoryClient {
+  constructor(options = {}) {
+    this.configDir = options.configDir;
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    this.runner = options.runner || runUsageWorker;
+    this.pending = null;
+    this.pendingKey = '';
+    this.cached = null;
+    this.cachedAt = 0;
+    this.cacheKey = '';
+    this.backgroundTimer = null;
+    this.backgroundGeneration = 0;
+    this.backgroundDelayMs = options.backgroundDelayMs || BACKGROUND_SCAN_DELAY_MS;
+    this.backgroundErrorDelayMs = options.backgroundErrorDelayMs || 5_000;
+    this.backgroundErrorRetries = 0;
+    this.backgroundStalls = 0;
+    this.backgroundProgressSignature = '';
+  }
+
+  invoke(request) {
+    return this.runner(request, { timeoutMs: this.timeoutMs });
+  }
+
+  storeResult(result, cacheKey) {
+    if (cacheKey !== this.cacheKey) return;
+    this.cached = result;
+    this.cachedAt = Number.isFinite(result?.sampledAt)
+      ? result.sampledAt
+      : Date.now();
+  }
+
+  scheduleBackgroundScan(request, cacheKey, result) {
+    if (result?.cache?.scan_complete !== false || cacheKey !== this.cacheKey) {
+      this.backgroundErrorRetries = 0;
+      this.backgroundStalls = 0;
+      this.backgroundProgressSignature = '';
+      return;
+    }
+    if (this.backgroundTimer) return;
+    const hasErrors = Number(result?.cache?.errors) > 0;
+    this.backgroundErrorRetries = hasErrors ? this.backgroundErrorRetries + 1 : 0;
+    const progressSignature = [
+      result?.cache?.pending_directories,
+      result?.cache?.pending_files,
+      result?.cache?.discovered_files,
+      result?.cache?.committed_bytes,
+    ].join(':');
+    if (Number(result?.cache?.enumerated_entries) > 0) {
+      this.backgroundProgressSignature = progressSignature;
+      this.backgroundStalls = 0;
+    } else if (progressSignature === this.backgroundProgressSignature) {
+      this.backgroundStalls += 1;
+    } else {
+      this.backgroundProgressSignature = progressSignature;
+      this.backgroundStalls = 0;
+    }
+    if (this.backgroundErrorRetries >= 3 || this.backgroundStalls >= 3) return;
+    const generation = this.backgroundGeneration;
+    const retryDelayMs = hasErrors
+      ? this.backgroundErrorDelayMs
+      : this.backgroundDelayMs;
+    this.backgroundTimer = setTimeout(() => {
+      this.backgroundTimer = null;
+      if (generation !== this.backgroundGeneration || cacheKey !== this.cacheKey) return;
+      const backgroundRequest = { ...request, nowMs: Date.now() };
+      const pending = this.invoke(backgroundRequest).then((nextResult) => {
+        this.storeResult(nextResult, cacheKey);
+        this.scheduleBackgroundScan(backgroundRequest, cacheKey, nextResult);
+        return nextResult;
+      }).catch(() => {
+        // Keep the last usable snapshot. A later normal request retries.
+      }).finally(() => {
+        if (this.pending === pending) {
+          this.pending = null;
+          this.pendingKey = '';
+        }
+      });
+      this.pending = pending;
+      this.pendingKey = cacheKey;
+    }, retryDelayMs);
+    this.backgroundTimer.unref?.();
+  }
+
+  collect(options = {}) {
+    const now = options.now ?? Date.now();
+    const retentionDays = options.retentionDays ?? DEFAULT_RETENTION_DAYS;
+    const roots = {
+      codex: Array.from(new Set(options.codexRoots || [])).sort(),
+      claude: Array.from(new Set(options.claudeRoots || [])).sort(),
+    };
+    const recentRawMs = options.recentRawMs ?? DEFAULT_RECENT_RAW_MS;
+    const cacheKey = JSON.stringify({ roots, retentionDays, recentRawMs });
+    if (this.cacheKey && this.cacheKey !== cacheKey) {
+      this.backgroundGeneration += 1;
+      if (this.backgroundTimer) clearTimeout(this.backgroundTimer);
+      this.backgroundTimer = null;
+      this.backgroundErrorRetries = 0;
+      this.backgroundStalls = 0;
+      this.backgroundProgressSignature = '';
+    }
+    if (
+      options.fresh !== true
+      && this.cached
+      && this.cacheKey === cacheKey
+      && (
+        now - this.cachedAt <= RESULT_REUSE_MS
+        || this.backgroundTimer
+        || (this.pending && this.pendingKey === cacheKey)
+      )
+    ) {
+      return Promise.resolve(this.cached);
+    }
+    if (this.pending && this.pendingKey === cacheKey) return this.pending;
+    if (this.pending) return this.pending.then(() => this.collect(options));
+    this.cacheKey = cacheKey;
+    this.backgroundErrorRetries = 0;
+    this.backgroundStalls = 0;
+    this.backgroundProgressSignature = '';
+    const request = {
+      cacheFile: usageHistoryCacheFile(this.configDir),
+      legacyCacheFile: options.legacyCacheFile,
+      nowMs: now,
+      retentionDays,
+      recentRawMs,
+      scanBudgetMs: options.scanBudgetMs ?? DEFAULT_SCAN_BUDGET_MS,
+      roots,
+    };
+    const pending = this.invoke(request).then((result) => {
+      this.storeResult(result, cacheKey);
+      this.scheduleBackgroundScan(request, cacheKey, result);
+      return result;
+    }).finally(() => {
+      if (this.pending === pending) {
+        this.pending = null;
+        this.pendingKey = '';
+      }
+    });
+    this.pending = pending;
+    this.pendingKey = cacheKey;
+    return pending;
+  }
+}
+
+module.exports = {
+  UsageHistoryClient,
+  DEFAULT_RECENT_RAW_MS,
+  DEFAULT_RETENTION_DAYS,
+  DEFAULT_SCAN_BUDGET_MS,
+  resolveWorkerFile,
+  runUsageWorker,
+};