farming-code 2.2.29 → 2.2.32

package/backend/usage-history-smoke.js

@@ -1,64 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { UsageHistoryClient } = require('./usage-history-client');
-
-async function runUsageHistorySmoke() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'farming-usage-smoke-'));
-  try {
-    const sessions = path.join(root, 'sessions');
-    fs.mkdirSync(sessions, { recursive: true });
-    fs.writeFileSync(path.join(sessions, 'rollout.jsonl'), [
-      JSON.stringify({
-        timestamp: '2026-01-01T00:00:00.000Z',
-        type: 'session_meta',
-        payload: {
-          id: 'farming-usage-smoke',
-          timestamp: '2026-01-01T00:00:00.000Z',
-          cwd: root,
-        },
-      }),
-      JSON.stringify({
-        timestamp: '2026-01-01T00:00:01.000Z',
-        type: 'event_msg',
-        payload: {
-          type: 'token_count',
-          info: {
-            total_token_usage: { input_tokens: 5, output_tokens: 2 },
-            last_token_usage: { input_tokens: 5, output_tokens: 2 },
-          },
-        },
-      }),
-      '',
-    ].join('\n'));
-    const result = await new UsageHistoryClient({
-      configDir: path.join(root, 'config'),
-    }).collect({
-      now: Date.parse('2026-01-01T01:00:00.000Z'),
-      codexRoots: [sessions],
-      claudeRoots: [],
-      scanBudgetMs: 30_000,
-      fresh: true,
-    });
-    const total = result.providers.codex.events.reduce(
-      (sum, event) => sum + event.totalTokens,
-      0,
-    );
-    if (
-      result.cache.scan_complete !== true
-      || result.cache.discovery_ready !== true
-      || total !== 7
-    ) {
-      throw new Error(`Usage history smoke returned an invalid result: ${JSON.stringify({
-        scanComplete: result.cache.scan_complete,
-        discoveryReady: result.cache.discovery_ready,
-        total,
-      })}`);
-    }
-    return { schemaVersion: result.schemaVersion, total };
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-}
-
-module.exports = { runUsageHistorySmoke };

package/backend/usage-history-worker.js

@@ -1,34 +0,0 @@
-const { parentPort, workerData } = require('worker_threads');
-
-async function collect(request) {
-  const { collectUsage } = require('./usage-history-scanner.generated');
-  return collectUsage(request);
-}
-
-let queue = Promise.resolve();
-
-function enqueue(message) {
-  queue = queue.then(async () => {
-    try {
-      const result = await collect(message.request);
-      parentPort.postMessage({ requestId: message.requestId, result });
-    } catch (error) {
-      parentPort.postMessage({
-        requestId: message.requestId,
-        error: {
-          message: error instanceof Error ? error.message : String(error),
-          code: error && typeof error === 'object' ? error.code : undefined,
-          stack: error instanceof Error ? error.stack : undefined,
-        },
-      });
-    }
-  });
-}
-
-parentPort.on('message', enqueue);
-
-// Keep accepting the former one-shot shape for already-built artifacts during
-// a controlled application update.
-if (workerData?.request) {
-  enqueue({ requestId: workerData.requestId || 'initial', request: workerData.request });
-}

package/backend/workspace-directory.js

@@ -1,232 +0,0 @@
-const express = require('express');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const CREATE_FORBIDDEN_CODES = new Set(['EACCES', 'EPERM', 'EROFS']);
-const INVALID_PATH_CODES = new Set(['EINVAL', 'ENAMETOOLONG']);
-const DEFAULT_BROWSE_LIMIT = 500;
-
-function resolveWorkspaceDirectory(value, homeDir = process.env.HOME || os.homedir()) {
-  const input = typeof value === 'string' ? value.trim() : '';
-  if (!input) return '';
-  const expanded = input === '~'
-    ? homeDir
-    : input.startsWith('~/')
-      ? path.join(homeDir, input.slice(2))
-      : input;
-  return path.resolve(expanded);
-}
-
-function workspaceDirectoryError(error, workspace) {
-  const code = error?.code || '';
-  if (CREATE_FORBIDDEN_CODES.has(code)) {
-    return {
-      status: 403,
-      body: {
-        status: 'rejected',
-        code: 'workspace-create-forbidden',
-        workspace,
-        message: `Farming does not have permission to create this directory: ${workspace}`,
-      },
-    };
-  }
-  if (code === 'ENOTDIR') {
-    return {
-      status: 409,
-      body: {
-        status: 'rejected',
-        code: 'workspace-parent-not-directory',
-        workspace,
-        message: `A parent path is not a directory: ${workspace}`,
-      },
-    };
-  }
-  if (code === 'EEXIST') {
-    return {
-      status: 409,
-      body: {
-        status: 'rejected',
-        code: 'workspace-not-directory',
-        workspace,
-        message: `Workspace path is not a directory: ${workspace}`,
-      },
-    };
-  }
-  if (INVALID_PATH_CODES.has(code)) {
-    return {
-      status: 400,
-      body: {
-        status: 'rejected',
-        code: 'workspace-invalid-path',
-        workspace,
-        message: 'Workspace path is invalid',
-      },
-    };
-  }
-  return {
-    status: 500,
-    body: {
-      status: 'rejected',
-      code: 'workspace-create-failed',
-      workspace,
-      message: `Failed to create workspace directory: ${workspace}`,
-    },
-  };
-}
-
-async function prepareWorkspaceDirectory(value, options = {}) {
-  const workspace = resolveWorkspaceDirectory(value, options.homeDir);
-  if (!workspace) {
-    return {
-      status: 400,
-      body: {
-        status: 'rejected',
-        code: 'workspace-path-required',
-        workspace: '',
-        message: 'Workspace path is required',
-      },
-    };
-  }
-
-  const fileSystem = options.fileSystem || fs.promises;
-  try {
-    const stat = await fileSystem.stat(workspace);
-    if (!stat.isDirectory()) {
-      return {
-        status: 409,
-        body: {
-          status: 'rejected',
-          code: 'workspace-not-directory',
-          workspace,
-          message: `Workspace path is not a directory: ${workspace}`,
-        },
-      };
-    }
-    return { status: 200, body: { status: 'ready', workspace } };
-  } catch (error) {
-    if (error?.code !== 'ENOENT') return workspaceDirectoryError(error, workspace);
-  }
-
-  if (options.create !== true) {
-    return {
-      status: 409,
-      body: {
-        status: 'missing',
-        code: 'workspace-not-found',
-        workspace,
-        message: `Workspace directory does not exist: ${workspace}`,
-      },
-    };
-  }
-
-  try {
-    await fileSystem.mkdir(workspace, { recursive: true });
-    const stat = await fileSystem.stat(workspace);
-    if (!stat.isDirectory()) {
-      return workspaceDirectoryError({ code: 'EEXIST' }, workspace);
-    }
-    return { status: 201, body: { status: 'created', workspace } };
-  } catch (error) {
-    return workspaceDirectoryError(error, workspace);
-  }
-}
-
-async function browseWorkspaceDirectory(value, options = {}) {
-  const workspace = resolveWorkspaceDirectory(value || '~', options.homeDir);
-  const fileSystem = options.fileSystem || fs.promises;
-  let entries;
-  try {
-    const stat = await fileSystem.stat(workspace);
-    if (!stat.isDirectory()) {
-      return {
-        status: 409,
-        body: {
-          status: 'rejected',
-          code: 'workspace-not-directory',
-          workspace,
-          message: `Workspace path is not a directory: ${workspace}`,
-        },
-      };
-    }
-    entries = await fileSystem.readdir(workspace, { withFileTypes: true });
-  } catch (error) {
-    const forbidden = CREATE_FORBIDDEN_CODES.has(error?.code);
-    const missing = error?.code === 'ENOENT';
-    return {
-      status: forbidden ? 403 : missing ? 404 : 500,
-      body: {
-        status: 'rejected',
-        code: forbidden
-          ? 'workspace-browse-forbidden'
-          : missing
-            ? 'workspace-not-found'
-            : 'workspace-browse-failed',
-        workspace,
-        message: forbidden
-          ? `Farming does not have permission to read this directory: ${workspace}`
-          : missing
-            ? `Workspace directory does not exist: ${workspace}`
-            : `Failed to read workspace directory: ${workspace}`,
-      },
-    };
-  }
-
-  const directories = (await Promise.all(entries.map(async (entry) => {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) return null;
-    const childPath = path.join(workspace, entry.name);
-    if (entry.isSymbolicLink()) {
-      try {
-        const stat = await fileSystem.stat(childPath);
-        if (!stat.isDirectory()) return null;
-      } catch {
-        return null;
-      }
-    }
-    return { name: entry.name, path: childPath };
-  })))
-    .filter(Boolean)
-    .sort((left, right) => left.name.localeCompare(right.name));
-  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_BROWSE_LIMIT, DEFAULT_BROWSE_LIMIT));
-  const parentPath = path.dirname(workspace);
-
-  return {
-    status: 200,
-    body: {
-      status: 'ready',
-      workspace,
-      parent: parentPath === workspace ? null : parentPath,
-      directories: directories.slice(0, limit),
-      truncated: directories.length > limit,
-    },
-  };
-}
-
-function createWorkspaceDirectoryRouter(options = {}) {
-  const router = express.Router();
-  router.use(express.json({ limit: '8kb' }));
-  router.get('/browse', async (req, res) => {
-    const result = await browseWorkspaceDirectory(req.query?.path, {
-      fileSystem: options.fileSystem,
-      homeDir: options.homeDir,
-      limit: req.query?.limit,
-    });
-    res.status(result.status).json(result.body);
-  });
-  router.post('/prepare', async (req, res) => {
-    const result = await prepareWorkspaceDirectory(req.body?.workspace, {
-      create: req.body?.create === true,
-      fileSystem: options.fileSystem,
-      homeDir: options.homeDir,
-    });
-    res.status(result.status).json(result.body);
-  });
-  return router;
-}
-
-module.exports = {
-  browseWorkspaceDirectory,
-  createWorkspaceDirectoryRouter,
-  prepareWorkspaceDirectory,
-  resolveWorkspaceDirectory,
-};

package/backend/workspace-discovery.js

@@ -1,311 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const DEFAULT_LIMIT = 12;
-const MAX_PROJECT_DIRS_PER_AGENT = 80;
-const MAX_FILES_PER_PROJECT = 8;
-const MAX_JSONL_LINES = 40;
-const MAX_JSON_BYTES = 128 * 1024;
-const AGENT_CONFIG_DIRS = new Set(['.claude', '.qwen', '.codex']);
-const DISCOVERABLE_AGENT_NAMES = new Set(['claude', 'qwen', 'codex']);
-
-function normalizeWorkspacePath(workspace) {
-  if (typeof workspace !== 'string') return '';
-  const value = workspace.trim();
-  if (!value || value.startsWith('/var')) return '';
-
-  const expanded = value === '~'
-    ? os.homedir()
-    : value.startsWith('~/')
-      ? path.join(os.homedir(), value.slice(2))
-      : value;
-
-  try {
-    const resolved = fs.realpathSync(expanded);
-    const stat = fs.statSync(resolved);
-    if (!stat.isDirectory()) return '';
-    if (isTemporaryWorkspace(resolved)) return '';
-
-    const basename = path.basename(resolved);
-    if (AGENT_CONFIG_DIRS.has(basename)) {
-      const parent = path.dirname(resolved);
-      return fs.statSync(parent).isDirectory() ? parent : '';
-    }
-
-    return resolved;
-  } catch {
-    return '';
-  }
-}
-
-function isTemporaryWorkspace(workspace) {
-  return workspace === '/tmp'
-    || workspace.startsWith('/tmp/')
-    || workspace === '/private/tmp'
-    || workspace.startsWith('/private/tmp/')
-    || workspace === '/var/tmp'
-    || workspace.startsWith('/var/tmp/')
-    || workspace === '/private/var/tmp'
-    || workspace.startsWith('/private/var/tmp/')
-    || workspace === '/var/folders'
-    || workspace.startsWith('/var/folders/')
-    || workspace === '/private/var/folders'
-    || workspace.startsWith('/private/var/folders/');
-}
-
-function getMtimeMs(filePath) {
-  try {
-    return fs.statSync(filePath).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-
-function sortedDirectoryEntries(dirPath) {
-  try {
-    return fs.readdirSync(dirPath, { withFileTypes: true })
-      .map(entry => ({
-        entry,
-        path: path.join(dirPath, entry.name),
-        mtimeMs: getMtimeMs(path.join(dirPath, entry.name)),
-      }))
-      .sort((a, b) => b.mtimeMs - a.mtimeMs);
-  } catch {
-    return [];
-  }
-}
-
-function collectJsonLikeFiles(rootDir, limit = MAX_FILES_PER_PROJECT) {
-  const result = [];
-  const queue = sortedDirectoryEntries(rootDir).filter(item => item.entry.isDirectory() || item.entry.isFile());
-
-  while (queue.length && result.length < limit) {
-    const item = queue.shift();
-    if (!item) break;
-
-    if (item.entry.isDirectory()) {
-      queue.push(...sortedDirectoryEntries(item.path));
-      queue.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      continue;
-    }
-
-    if (item.entry.isFile() && /\.(jsonl|json)$/i.test(item.entry.name)) {
-      result.push(item.path);
-    }
-  }
-
-  return result;
-}
-
-function extractCwdFromObject(value) {
-  if (!value || typeof value !== 'object') return '';
-  const direct = value.cwd || value.workdir || value.workspace;
-  if (typeof direct === 'string') return direct;
-
-  const payload = value.payload || value.session || value.message || value.metadata || value.meta;
-  if (payload && typeof payload === 'object') {
-    return extractCwdFromObject(payload);
-  }
-
-  return '';
-}
-
-function readCwdFromJsonFile(filePath) {
-  try {
-    const stat = fs.statSync(filePath);
-    if (!stat.isFile()) return '';
-
-    if (filePath.endsWith('.json')) {
-      if (stat.size > MAX_JSON_BYTES) return '';
-      return extractCwdFromObject(JSON.parse(fs.readFileSync(filePath, 'utf8')));
-    }
-
-    const fd = fs.openSync(filePath, 'r');
-    try {
-      const buffer = Buffer.alloc(Math.min(stat.size, MAX_JSON_BYTES));
-      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
-      const content = buffer.subarray(0, bytesRead).toString('utf8');
-      const lines = content.split('\n').slice(0, MAX_JSONL_LINES);
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const cwd = extractCwdFromObject(JSON.parse(line));
-          if (cwd) return cwd;
-        } catch {
-          // Ignore malformed or partial JSONL rows.
-        }
-      }
-    } finally {
-      fs.closeSync(fd);
-    }
-  } catch {
-    return '';
-  }
-
-  return '';
-}
-
-function normalizeEncodedSegment(segment) {
-  return segment
-    .replace(/[^A-Za-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .toLowerCase();
-}
-
-function resolveEncodedProjectDirectory(projectName) {
-  const encoded = normalizeEncodedSegment(projectName);
-  if (!encoded) return '';
-
-  let currentDir = path.parse(process.cwd()).root;
-  let remaining = encoded;
-
-  while (remaining) {
-    const children = sortedDirectoryEntries(currentDir).filter(item => item.entry.isDirectory());
-    const match = children
-      .map(child => ({ child, childSlug: normalizeEncodedSegment(child.entry.name) }))
-      .filter(({ childSlug }) => childSlug && (remaining === childSlug || remaining.startsWith(`${childSlug}-`)))
-      .sort((a, b) => b.childSlug.length - a.childSlug.length)[0];
-
-    if (!match) return '';
-
-    currentDir = match.child.path;
-    const childSlug = match.childSlug;
-    remaining = remaining === childSlug ? '' : remaining.slice(childSlug.length + 1);
-  }
-
-  return normalizeWorkspacePath(currentDir);
-}
-
-function addWorkspace(resultByPath, workspace, details) {
-  const normalized = normalizeWorkspacePath(workspace);
-  if (!normalized) return;
-
-  const existing = resultByPath.get(normalized) || {
-    path: normalized,
-    agents: [],
-    sources: [],
-    confidence: details.confidence || 'medium',
-    lastSeen: 0,
-  };
-
-  if (!existing.agents.includes(details.agent)) existing.agents.push(details.agent);
-  if (!existing.sources.includes(details.source)) existing.sources.push(details.source);
-  existing.lastSeen = Math.max(existing.lastSeen || 0, details.lastSeen || 0);
-  if (details.confidence === 'high') existing.confidence = 'high';
-
-  resultByPath.set(normalized, existing);
-}
-
-function scanProjectHistory({ homeDir, agent, projectRoot, resultByPath }) {
-  const root = path.join(homeDir, projectRoot);
-  if (!fs.existsSync(root)) return;
-
-  const projects = sortedDirectoryEntries(root)
-    .filter(item => item.entry.isDirectory())
-    .slice(0, MAX_PROJECT_DIRS_PER_AGENT);
-
-  projects.forEach((project) => {
-    const files = collectJsonLikeFiles(project.path, MAX_FILES_PER_PROJECT);
-    let fileWithCwd = '';
-    let cwd = '';
-    for (const file of files) {
-      cwd = readCwdFromJsonFile(file);
-      if (cwd) {
-        fileWithCwd = file;
-        break;
-      }
-    }
-
-    if (cwd) {
-      addWorkspace(resultByPath, cwd, {
-        agent,
-        source: `${agent}-metadata`,
-        confidence: 'high',
-        lastSeen: getMtimeMs(fileWithCwd),
-      });
-      return;
-    }
-
-    const decoded = resolveEncodedProjectDirectory(project.entry.name);
-    if (decoded) {
-      addWorkspace(resultByPath, decoded, {
-        agent,
-        source: `${agent}-project-dir`,
-        confidence: 'medium',
-        lastSeen: project.mtimeMs,
-      });
-    }
-  });
-}
-
-function scanCodexSessions({ homeDir, resultByPath }) {
-  const root = path.join(homeDir, '.codex', 'sessions');
-  if (!fs.existsSync(root)) return;
-
-  const files = [];
-  const queue = [root];
-
-  while (queue.length && files.length < 120) {
-    const current = queue.shift();
-    if (!current) break;
-
-    sortedDirectoryEntries(current).forEach((item) => {
-      if (item.entry.isDirectory()) {
-        queue.push(item.path);
-      } else if (item.entry.isFile() && item.entry.name.endsWith('.jsonl')) {
-        files.push(item.path);
-      }
-    });
-    files.sort((a, b) => getMtimeMs(b) - getMtimeMs(a));
-  }
-
-  files.slice(0, 80).forEach((file) => {
-    const cwd = readCwdFromJsonFile(file);
-    if (!cwd) return;
-    addWorkspace(resultByPath, cwd, {
-      agent: 'codex',
-      source: 'codex-session-meta',
-      confidence: 'high',
-      lastSeen: getMtimeMs(file),
-    });
-  });
-}
-
-function discoverAgentWorkspaces(options = {}) {
-  const homeDir = options.homeDir || os.homedir();
-  const limit = Number.isFinite(options.limit) ? options.limit : DEFAULT_LIMIT;
-  const requestedAgent = typeof options.agent === 'string' ? options.agent.trim().toLowerCase() : '';
-  const agentFilter = DISCOVERABLE_AGENT_NAMES.has(requestedAgent) ? requestedAgent : '';
-  const resultByPath = new Map();
-
-  scanProjectHistory({
-    homeDir,
-    agent: 'claude',
-    projectRoot: path.join('.claude', 'projects'),
-    resultByPath,
-  });
-  scanProjectHistory({
-    homeDir,
-    agent: 'qwen',
-    projectRoot: path.join('.qwen', 'projects'),
-    resultByPath,
-  });
-  scanCodexSessions({ homeDir, resultByPath });
-
-  return [...resultByPath.values()]
-    .filter(item => !agentFilter || item.agents.includes(agentFilter))
-    .sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0))
-    .slice(0, Math.max(0, limit))
-    .map(item => ({
-      ...item,
-      exists: true,
-    }));
-}
-
-module.exports = {
-  discoverAgentWorkspaces,
-  isTemporaryWorkspace,
-  normalizeWorkspacePath,
-  resolveEncodedProjectDirectory,
-};