farming-code 2.2.8 → 2.2.11

package/backend/workspace-file-service.js

@@ -14,10 +14,15 @@ const DEFAULT_SEARCH_LIMIT = 100;
 const DEFAULT_GIT_CHANGES_LIMIT = 500;
 const DEFAULT_GIT_STATUS_CACHE_TTL_MS = 30000;
 const DEFAULT_GIT_STATUS_INLINE_TIMEOUT_MS = 80;
+const DEFAULT_GIT_STATUS_TIMEOUT_MS = 15000;
 const DEFAULT_SEARCH_TIMEOUT_MS = 3000;
 const DEFAULT_BLAME_TIMEOUT_MS = 5000;
 const DEFAULT_DIFF_TIMEOUT_MS = 5000;
 const DEFAULT_DIFF_MAX_BUFFER = 1024 * 1024;
+const DEFAULT_GIT_HISTORY_LIMIT = 50;
+const MAX_GIT_HISTORY_LIMIT = 100;
+const DEFAULT_GIT_HISTORY_TIMEOUT_MS = 5000;
+const DEFAULT_GIT_HISTORY_MAX_BUFFER = 8 * 1024 * 1024;
 const DEFAULT_WATCH_DEPTH = 1;
 const SEARCH_FILE_LIST_MAX_BUFFER = 16 * 1024 * 1024;
 const BINARY_SNIFF_BYTES = 8192;
@@ -389,6 +394,7 @@ function sha1(buffer) {
 
 function previewForPath(filePath, options = {}) {
   const extension = path.extname(filePath).toLowerCase();
+  if (extension === '.pdf') return { kind: 'pdf', mediaType: 'application/pdf' };
   if (!options.includeTextImages && TEXT_IMAGE_PREVIEW_EXTENSIONS.has(extension)) return null;
   const mediaType = IMAGE_PREVIEW_MEDIA_TYPES.get(extension);
   return mediaType ? { kind: 'image', mediaType } : null;
@@ -509,6 +515,132 @@ function gitStatusReviewRank(kind) {
   return 6;
 }
 
+function normalizeGitHistoryLimit(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return DEFAULT_GIT_HISTORY_LIMIT;
+  return Math.min(parsed, MAX_GIT_HISTORY_LIMIT);
+}
+
+function normalizeGitHistorySkip(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) return 0;
+  return Math.min(parsed, 1_000_000);
+}
+
+function normalizeGitObjectId(value, fieldName = 'commit') {
+  const normalized = String(value || '').trim();
+  if (!/^[0-9a-f]{40,64}$/i.test(normalized)) {
+    throw new WorkspaceFileError(`${fieldName} must be a full git object id`, 400);
+  }
+  return normalized.toLowerCase();
+}
+
+function gitEmptyTreeObjectId(objectFormat) {
+  const algorithm = objectFormat === 'sha256' ? 'sha256' : 'sha1';
+  return crypto.createHash(algorithm).update(Buffer.from('tree 0\0')).digest('hex');
+}
+
+function gitHistoryReference(value) {
+  let id = String(value || '').trim();
+  if (!id) return null;
+  if (id.startsWith('tag: ')) id = id.slice(5);
+  if (id === 'HEAD') return { id, name: id, category: 'head' };
+  if (id.startsWith('refs/heads/')) {
+    return { id, name: id.slice('refs/heads/'.length), category: 'local-branch' };
+  }
+  if (id.startsWith('refs/remotes/')) {
+    if (/\/HEAD$/.test(id)) return null;
+    return { id, name: id.slice('refs/remotes/'.length), category: 'remote-branch' };
+  }
+  if (id.startsWith('refs/tags/')) {
+    return { id, name: id.slice('refs/tags/'.length), category: 'tag' };
+  }
+  return { id, name: id.replace(/^refs\//, ''), category: 'reference' };
+}
+
+function parseGitHistoryReferences(value) {
+  const references = [];
+  const seen = new Set();
+  const add = candidate => {
+    const reference = gitHistoryReference(candidate);
+    if (!reference || seen.has(reference.id)) return;
+    seen.add(reference.id);
+    references.push(reference);
+  };
+
+  String(value || '').split(', ').forEach(decoration => {
+    const arrowIndex = decoration.indexOf(' -> ');
+    if (arrowIndex === -1) {
+      add(decoration);
+      return;
+    }
+    add(decoration.slice(0, arrowIndex));
+    add(decoration.slice(arrowIndex + 4));
+  });
+  return references;
+}
+
+function parseGitHistoryLog(stdout) {
+  const fields = String(stdout || '').split('\0');
+  const items = [];
+  for (let index = 0; index + 7 < fields.length; index += 8) {
+    const id = fields[index];
+    if (!id) continue;
+    const timestamp = Date.parse(fields[index + 4]);
+    items.push({
+      id,
+      displayId: id.slice(0, 8),
+      parentIds: fields[index + 1].split(' ').filter(Boolean),
+      author: fields[index + 2],
+      authorEmail: fields[index + 3],
+      timestamp: Number.isFinite(timestamp) ? timestamp : undefined,
+      subject: fields[index + 5],
+      message: String(fields[index + 6] || '').trimEnd(),
+      references: parseGitHistoryReferences(fields[index + 7]),
+    });
+  }
+  return items;
+}
+
+function gitHistoryChangeKind(statusCode) {
+  if (statusCode.startsWith('A')) return 'added';
+  if (statusCode.startsWith('D')) return 'deleted';
+  if (statusCode.startsWith('R')) return 'renamed';
+  if (statusCode.startsWith('C')) return 'copied';
+  if (statusCode.startsWith('T')) return 'type-changed';
+  return 'modified';
+}
+
+function gitHistoryChangeLabel(kind) {
+  if (kind === 'added') return 'A';
+  if (kind === 'deleted') return 'D';
+  if (kind === 'renamed') return 'R';
+  if (kind === 'copied') return 'C';
+  if (kind === 'type-changed') return 'T';
+  return 'M';
+}
+
+function parseGitHistoryChanges(stdout) {
+  const fields = String(stdout || '').split('\0');
+  const items = [];
+  for (let index = 0; index < fields.length;) {
+    const statusCode = fields[index++];
+    if (!statusCode) continue;
+    const kind = gitHistoryChangeKind(statusCode);
+    if (kind === 'renamed' || kind === 'copied') {
+      const previousPath = fields[index++] || '';
+      const filePath = fields[index++] || '';
+      if (!filePath) continue;
+      items.push({ path: filePath, previousPath, status: kind, statusLabel: gitHistoryChangeLabel(kind) });
+      continue;
+    }
+    const filePath = fields[index++] || '';
+    if (!filePath) continue;
+    items.push({ path: filePath, status: kind, statusLabel: gitHistoryChangeLabel(kind) });
+  }
+  return items;
+}
+
 async function workspaceEntryTypeForGitChange(root, filePath) {
   try {
     const stat = await fsp.lstat(path.join(root, filePath.replace(/\/+$/, '')));
@@ -978,6 +1110,8 @@ class WorkspaceFileService {
     this.blameTimeoutMs = options.blameTimeoutMs ?? DEFAULT_BLAME_TIMEOUT_MS;
     this.diffTimeoutMs = options.diffTimeoutMs ?? DEFAULT_DIFF_TIMEOUT_MS;
     this.diffMaxBuffer = options.diffMaxBuffer ?? DEFAULT_DIFF_MAX_BUFFER;
+    this.gitHistoryTimeoutMs = options.gitHistoryTimeoutMs ?? DEFAULT_GIT_HISTORY_TIMEOUT_MS;
+    this.gitHistoryMaxBuffer = options.gitHistoryMaxBuffer ?? DEFAULT_GIT_HISTORY_MAX_BUFFER;
     const bundledRipgrepPath = resolveBundledRipgrepPath();
     this.rgPath = options.rgPath || process.env.FARMING_RG_BIN || bundledRipgrepPath || 'rg';
     this.rgFallbackPath = options.rgFallbackPath ?? (this.rgPath === 'rg' ? bundledRipgrepPath : 'rg');
@@ -986,6 +1120,7 @@ class WorkspaceFileService {
     this.gitPath = options.gitPath || 'git';
     this.gitStatusCacheTtlMs = options.gitStatusCacheTtlMs ?? DEFAULT_GIT_STATUS_CACHE_TTL_MS;
     this.gitStatusInlineTimeoutMs = options.gitStatusInlineTimeoutMs ?? DEFAULT_GIT_STATUS_INLINE_TIMEOUT_MS;
+    this.gitStatusTimeoutMs = options.gitStatusTimeoutMs ?? DEFAULT_GIT_STATUS_TIMEOUT_MS;
     this.gitStatusCache = new Map();
     this.watchers = new Map();
     this.watchOptions = options.watchOptions || {};
@@ -1588,11 +1723,31 @@ class WorkspaceFileService {
         `--untracked-files=${untrackedFiles}`,
         '--ignored=no',
         ...gitStatusExcludePathspecArgs(),
-      ], { cwd: root });
+      ], { cwd: root, timeout: options.timeoutMs ?? this.gitStatusTimeoutMs });
       return parseGitStatus(stdout);
     } catch (error) {
-      if (error.code === 'ENOENT') return new Map();
+      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' && options.allowPartial === true) {
+        const partialOutput = String(error.stdout || '');
+        const lastCompleteRecord = partialOutput.lastIndexOf('\0');
+        const statusByPath = parseGitStatus(lastCompleteRecord >= 0
+          ? partialOutput.slice(0, lastCompleteRecord + 1)
+          : '');
+        statusByPath.truncated = true;
+        return statusByPath;
+      }
+      if (error.code === 'ENOENT') {
+        if (options.throwOnError === true) {
+          throw new WorkspaceFileError('git is not installed', 501);
+        }
+        return new Map();
+      }
+      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
+        throw new WorkspaceFileError('git status timed out', 504);
+      }
       if (error.stderr && /not a git repository/i.test(error.stderr)) return new Map();
+      if (options.throwOnError === true) {
+        throw new WorkspaceFileError(error.stderr || 'git status failed', 500);
+      }
       return new Map();
     }
   }
@@ -1719,10 +1874,165 @@ class WorkspaceFileService {
     }
   }
 
+  async gitHistory(workspaceRoot, options = {}) {
+    const root = await this.resolveRoot(workspaceRoot);
+    const limit = normalizeGitHistoryLimit(options.limit);
+    const skip = normalizeGitHistorySkip(options.skip);
+    const scope = options.scope === 'all' ? 'all' : 'current';
+    let branch = '';
+    try {
+      branch = await this.gitBranch(root);
+      await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--is-inside-work-tree'], {
+        timeout: 1500,
+        maxBuffer: 64 * 1024,
+      });
+    } catch (error) {
+      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
+        return { isGitRepo: false, branch: '', head: '', scope, items: [], hasMore: false, nextSkip: null };
+      }
+      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+    }
+
+    let head = '';
+    try {
+      const result = await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--verify', 'HEAD'], {
+        timeout: 1500,
+        maxBuffer: 64 * 1024,
+      });
+      head = String(result.stdout || '').trim();
+    } catch (error) {
+      if (error.stderr && /(needed a single revision|unknown revision|bad revision|ambiguous argument)/i.test(String(error.stderr))) {
+        return { isGitRepo: true, branch, head: '', scope, items: [], hasMore: false, nextSkip: null };
+      }
+      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+    }
+
+    try {
+      const revisionArgs = scope === 'all'
+        ? ['HEAD', '--branches', '--tags', '--remotes']
+        : ['--first-parent', 'HEAD'];
+      const { stdout } = await this.execFile(this.gitPath, [
+        '-C', root,
+        'log',
+        '-z',
+        '--date-order',
+        '--decorate=full',
+        '--format=%H%x00%P%x00%an%x00%ae%x00%aI%x00%s%x00%B%x00%D',
+        `--max-count=${limit + 1}`,
+        `--skip=${skip}`,
+        ...revisionArgs,
+      ], {
+        timeout: this.gitHistoryTimeoutMs,
+        maxBuffer: this.gitHistoryMaxBuffer,
+      });
+      const parsed = parseGitHistoryLog(stdout);
+      const hasMore = parsed.length > limit;
+      const items = parsed.slice(0, limit);
+      return {
+        isGitRepo: true,
+        branch,
+        head,
+        scope,
+        items,
+        hasMore,
+        nextSkip: hasMore ? skip + items.length : null,
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
+      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
+        throw new WorkspaceFileError('git history timed out', 504);
+      }
+      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+        throw new WorkspaceFileError('git history output is too large', 413);
+      }
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
+        return { isGitRepo: false, branch: '', head: '', scope, items: [], hasMore: false, nextSkip: null };
+      }
+      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+    }
+  }
+
+  async gitHistoryChanges(workspaceRoot, commitValue, parentValue, options = {}) {
+    const root = await this.resolveRoot(workspaceRoot);
+    const commit = normalizeGitObjectId(commitValue);
+    const requestedParent = parentValue ? normalizeGitObjectId(parentValue, 'parent') : '';
+    const limit = Math.max(1, Math.min(2000, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
+
+    try {
+      const { stdout: parentOutput } = await this.execFile(this.gitPath, [
+        '-C', root, 'rev-list', '--parents', '-n', '1', commit,
+      ], {
+        timeout: this.gitHistoryTimeoutMs,
+        maxBuffer: 64 * 1024,
+      });
+      const revision = String(parentOutput || '').trim().split(/\s+/).filter(Boolean);
+      if (!revision.length || revision[0].toLowerCase() !== commit) {
+        throw new WorkspaceFileError('commit was not found', 404);
+      }
+      const parentIds = revision.slice(1).map(value => value.toLowerCase());
+      if (requestedParent && !parentIds.includes(requestedParent)) {
+        throw new WorkspaceFileError('parent is not a parent of commit', 400);
+      }
+      const parent = requestedParent || parentIds[0] || '';
+      let comparisonBase = parent;
+      if (!comparisonBase) {
+        let objectFormat = 'sha1';
+        try {
+          const result = await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--show-object-format'], {
+            timeout: 1500,
+            maxBuffer: 64 * 1024,
+          });
+          objectFormat = String(result.stdout || '').trim();
+        } catch {
+          // Git versions without --show-object-format use SHA-1 repositories.
+        }
+        comparisonBase = gitEmptyTreeObjectId(objectFormat);
+      }
+      const args = parent
+        ? ['-C', root, 'diff', '--name-status', '-z', '-M', parent, commit, '--']
+        : ['-C', root, 'diff-tree', '--root', '--no-commit-id', '--name-status', '-r', '-z', '-M', commit];
+      const { stdout } = await this.execFile(this.gitPath, args, {
+        timeout: this.gitHistoryTimeoutMs,
+        maxBuffer: this.gitHistoryMaxBuffer,
+      });
+      const allItems = parseGitHistoryChanges(stdout);
+      return {
+        commit,
+        comparisonBase,
+        parent: parent || null,
+        parentIds,
+        items: allItems.slice(0, limit),
+        truncated: allItems.length > limit,
+      };
+    } catch (error) {
+      if (error instanceof WorkspaceFileError) throw error;
+      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
+      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
+        throw new WorkspaceFileError('git commit changes timed out', 504);
+      }
+      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+        throw new WorkspaceFileError('git commit changes output is too large', 413);
+      }
+      if (error.stderr && /(bad object|unknown revision|ambiguous argument|not a valid object name)/i.test(String(error.stderr))) {
+        throw new WorkspaceFileError('commit was not found', 404);
+      }
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
+        throw new WorkspaceFileError('workspace is not a git repository', 409);
+      }
+      throw new WorkspaceFileError(error.stderr || 'git commit changes failed', 500);
+    }
+  }
+
   async changes(workspaceRoot, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const limit = Math.max(1, Math.min(2000, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
-    const gitStatusByPath = await this.loadGitStatusByPath(root, { untrackedFiles: 'all' });
+    const gitStatusByPath = await this.loadGitStatusByPath(root, {
+      allowPartial: true,
+      throwOnError: true,
+      untrackedFiles: 'all',
+    });
+    this.invalidateGitStatus(root);
     const allItems = await Promise.all(Array.from(gitStatusByPath.entries())
       .map(async ([filePath, status]) => ({
         path: filePath,
@@ -1740,7 +2050,7 @@ class WorkspaceFileService {
 
     return {
       items: allItems.slice(0, limit),
-      truncated: allItems.length > limit,
+      truncated: gitStatusByPath.truncated === true || allItems.length > limit,
     };
   }
 
@@ -2762,4 +3072,9 @@ module.exports = {
   parseUnifiedDiffHunks,
   selectUnifiedDiffHunk,
   resolveCommandRunnerNodePath,
+  normalizeGitHistoryLimit,
+  normalizeGitHistorySkip,
+  parseGitHistoryChanges,
+  parseGitHistoryLog,
+  parseGitHistoryReferences,
 };

package/backend/workspace-root-registry.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { WorkspaceFileError } = require('./workspace-file-service');
+
+const GLOBAL_WORKSPACE_FILES_AGENT_ID = '__farming_global_files__';
+const GLOBAL_WORKSPACE_ROOT_ID = 'wroot_global';
+const GLOBAL_WORKSPACE_FILES_ROOT = '/';
+const PROJECT_FILES_WORKSPACE_PREFIX = '__farming_project__:';
+
+function normalizeWorkspacePath(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  return path.resolve(raw.replace(/^~(?=$|[\\/])/, os.homedir()));
+}
+
+function canonicalWorkspacePath(value) {
+  const normalized = normalizeWorkspacePath(value);
+  if (!normalized) return '';
+  try {
+    return fs.realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+
+function rootIdForPath(value) {
+  const canonicalPath = canonicalWorkspacePath(value);
+  if (!canonicalPath) return '';
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of Buffer.from(canonicalPath, 'utf8')) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return `wroot_${hash.toString(16).padStart(16, '0')}`;
+}
+
+function projectWorkspaceFromLegacyRef(ref) {
+  const value = String(ref || '');
+  if (!value.startsWith(PROJECT_FILES_WORKSPACE_PREFIX)) return '';
+  try {
+    return normalizeWorkspacePath(decodeURIComponent(value.slice(PROJECT_FILES_WORKSPACE_PREFIX.length)));
+  } catch {
+    return '';
+  }
+}
+
+function workspaceRootSnapshot(root) {
+  return {
+    rootId: root.rootId,
+    kind: root.kind,
+    canonicalPath: root.canonicalPath,
+    repositoryId: root.repositoryId || '',
+    accessPolicy: { ...root.accessPolicy },
+  };
+}
+
+class WorkspaceRootRegistry {
+  constructor(agentManager) {
+    this.agentManager = agentManager;
+    this.roots = new Map();
+    this.register({
+      rootId: GLOBAL_WORKSPACE_ROOT_ID,
+      kind: 'global',
+      canonicalPath: GLOBAL_WORKSPACE_FILES_ROOT,
+      accessPolicy: { readOnly: true, watch: false, externalReads: false },
+    });
+  }
+
+  register(options = {}) {
+    const canonicalPath = options.rootId === GLOBAL_WORKSPACE_ROOT_ID
+      ? GLOBAL_WORKSPACE_FILES_ROOT
+      : canonicalWorkspacePath(options.canonicalPath);
+    if (!canonicalPath) throw new WorkspaceFileError('workspace root path is required', 400);
+    const rootId = options.rootId || rootIdForPath(canonicalPath);
+    const current = this.roots.get(rootId);
+    if (current && current.canonicalPath !== canonicalPath) {
+      throw new WorkspaceFileError('workspace root identity collision', 409);
+    }
+    const root = Object.freeze({
+      rootId,
+      kind: options.kind || current?.kind || 'directory',
+      canonicalPath,
+      repositoryId: options.repositoryId || current?.repositoryId || '',
+      accessPolicy: Object.freeze({
+        readOnly: options.accessPolicy?.readOnly === true,
+        watch: options.accessPolicy?.watch !== false,
+        externalReads: options.accessPolicy?.externalReads !== false,
+      }),
+    });
+    this.roots.set(rootId, root);
+    return root;
+  }
+
+  configuredProjectPaths() {
+    const settings = this.agentManager?.configManager?.getSettings?.() || {};
+    return (Array.isArray(settings.projectWorkspaces) ? settings.projectWorkspaces : [])
+      .map(normalizeWorkspacePath)
+      .filter(Boolean);
+  }
+
+  liveAgentPaths() {
+    const state = this.agentManager?.getState?.() || { agents: [] };
+    return (state.agents || []).filter(agent => agent && !agent.isMain).map(agent => ({
+      agentId: agent.id,
+      path: normalizeWorkspacePath(agent.projectWorkspace || agent.gitWorktree?.workspace || agent.cwd),
+    })).filter(entry => entry.path);
+  }
+
+  refresh() {
+    const activeRootIds = new Set([GLOBAL_WORKSPACE_ROOT_ID]);
+    for (const projectPath of this.configuredProjectPaths()) {
+      activeRootIds.add(this.register({ kind: 'directory', canonicalPath: projectPath }).rootId);
+    }
+    for (const entry of this.liveAgentPaths()) {
+      activeRootIds.add(this.register({ kind: 'directory', canonicalPath: entry.path }).rootId);
+    }
+    for (const rootId of this.roots.keys()) {
+      if (!activeRootIds.has(rootId)) this.roots.delete(rootId);
+    }
+  }
+
+  resolve(ref) {
+    const value = String(ref || '').trim();
+    if (!value) throw new WorkspaceFileError('rootId is required', 400);
+    if (value === GLOBAL_WORKSPACE_ROOT_ID || value === GLOBAL_WORKSPACE_FILES_AGENT_ID) {
+      return this.roots.get(GLOBAL_WORKSPACE_ROOT_ID);
+    }
+
+    this.refresh();
+    const registered = this.roots.get(value);
+    if (registered) return registered;
+
+    const projectPath = projectWorkspaceFromLegacyRef(value);
+    if (projectPath) {
+      const authorized = this.configuredProjectPaths().includes(projectPath)
+        || this.liveAgentPaths().some(entry => entry.path === projectPath);
+      if (!authorized) throw new WorkspaceFileError('project not found', 404);
+      return this.register({ kind: 'directory', canonicalPath: projectPath });
+    }
+
+    const agentPath = this.liveAgentPaths().find(entry => entry.agentId === value)?.path
+      || normalizeWorkspacePath(this.agentManager?.getAgentWorkspaceRoot?.(value));
+    if (agentPath) return this.register({ kind: 'directory', canonicalPath: agentPath });
+    throw new WorkspaceFileError(value.startsWith('wroot_') ? 'workspace root not found' : 'agent not found', 404);
+  }
+
+  list() {
+    this.refresh();
+    return [...this.roots.values()].map(workspaceRootSnapshot);
+  }
+}
+
+module.exports = {
+  GLOBAL_WORKSPACE_FILES_AGENT_ID,
+  GLOBAL_WORKSPACE_FILES_ROOT,
+  GLOBAL_WORKSPACE_ROOT_ID,
+  PROJECT_FILES_WORKSPACE_PREFIX,
+  WorkspaceRootRegistry,
+  canonicalWorkspacePath,
+  projectWorkspaceFromLegacyRef,
+  rootIdForPath,
+  workspaceRootSnapshot,
+};