farming-code 2.2.30 → 2.2.32

package/backend/provider-session-service.js

@@ -1,345 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { findAgentSession } = require('./agent-session-history');
-const {
-  codexSessionDateKeys,
-  listCodexSessionIdentities,
-} = require('./codex-session-history');
-const { mainPageAgentSessionKey } = require('./main-page-session');
-const { isTemporaryProviderSessionId } = require('./provider-session-id');
-
-const CODEX_RESOLVE_COOLDOWN_MS = 1000;
-const CODEX_MATCH_WINDOW_MS = 30 * 1000;
-const CODEX_STARTUP_RETRY_DELAYS_MS = [500, 1000, 2000, 4000, 8000, 12000];
-const TITLE_RESOLVE_COOLDOWN_MS = 30 * 1000;
-
-function normalizePath(value) {
-  if (typeof value !== 'string') return '';
-  const trimmed = value.trim();
-  if (!trimmed || trimmed === path.sep) return trimmed;
-  return trimmed.replace(/[\\/]+$/, '');
-}
-
-function canonicalPath(value) {
-  const normalized = normalizePath(value);
-  if (!normalized) return '';
-  try {
-    return normalizePath(fs.realpathSync.native(normalized));
-  } catch {
-    return normalized;
-  }
-}
-
-function timestampMs(value) {
-  const parsed = Date.parse(value || '');
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-
-class ProviderSessionService {
-  constructor(options = {}) {
-    this.agents = options.agents || new Map();
-    this.getProviderHomes = options.getProviderHomes || (() => undefined);
-    this.commit = options.commit || (() => {});
-    this.listCodexSessionIdentities = options.listCodexSessionIdentities || listCodexSessionIdentities;
-    this.findAgentSession = options.findAgentSession || findAgentSession;
-    this.codexStartupRetryDelaysMs = Array.isArray(options.codexStartupRetryDelaysMs)
-      ? options.codexStartupRetryDelaysMs
-      : CODEX_STARTUP_RETRY_DELAYS_MS;
-    this.resolutions = new Map();
-    this.codexIdentityScans = new Map();
-    this.codexStartupRetries = new Map();
-  }
-
-  activate(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent?.providerSessionProvider || !agent.providerSessionId) return;
-
-    if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
-      this.observe(agentId, { force: true });
-      this.scheduleTemporaryCodexStartupRetry(agentId);
-      return;
-    }
-
-    this.resolutions.delete(`codex:${agentId}`);
-    this.commit(agent, { kind: 'known-session' });
-    void this.resolveTitle(agentId, { force: true });
-  }
-
-  observe(agentId, options = {}) {
-    void this.resolveTemporaryCodex(agentId, options);
-    void this.resolveTitle(agentId, options);
-  }
-
-  stop(agentId) {
-    this.resolutions.delete(`codex:${agentId}`);
-    this.resolutions.delete(`title:${agentId}`);
-    const startupRetry = this.codexStartupRetries.get(agentId);
-    if (startupRetry?.timer) clearTimeout(startupRetry.timer);
-    this.codexStartupRetries.delete(agentId);
-  }
-
-  dispose() {
-    for (const startupRetry of this.codexStartupRetries.values()) {
-      if (startupRetry?.timer) clearTimeout(startupRetry.timer);
-    }
-    this.resolutions.clear();
-    this.codexIdentityScans.clear();
-    this.codexStartupRetries.clear();
-  }
-
-  scheduleTemporaryCodexStartupRetry(agentId) {
-    if (this.codexStartupRetries.has(agentId)) return;
-    const agent = this.agents.get(agentId);
-    const retry = {
-      attempt: 0,
-      timer: null,
-      deadlineAt: (Number(agent?.startedAt) || Date.now()) + CODEX_MATCH_WINDOW_MS,
-    };
-    this.codexStartupRetries.set(agentId, retry);
-
-    const scheduleNext = () => {
-      if (this.codexStartupRetries.get(agentId) !== retry) return;
-      const agent = this.agents.get(agentId);
-      if (
-        !agent
-        || agent.providerSessionProvider !== 'codex'
-        || agent.providerSessionTemporary !== true
-      ) {
-        this.stop(agentId);
-        return;
-      }
-      const delayMs = Number(this.codexStartupRetryDelaysMs[retry.attempt]);
-      if (!Number.isFinite(delayMs) || delayMs < 0) {
-        this.codexStartupRetries.delete(agentId);
-        return;
-      }
-      if (Date.now() + delayMs > retry.deadlineAt) {
-        this.codexStartupRetries.delete(agentId);
-        return;
-      }
-      retry.attempt += 1;
-      retry.timer = setTimeout(async () => {
-        retry.timer = null;
-        if (
-          this.codexStartupRetries.get(agentId) !== retry
-          || Date.now() > retry.deadlineAt
-        ) {
-          if (this.codexStartupRetries.get(agentId) === retry) {
-            this.codexStartupRetries.delete(agentId);
-          }
-          return;
-        }
-        const resolved = await this.resolveTemporaryCodex(agentId, { force: true });
-        if (this.codexStartupRetries.get(agentId) !== retry) return;
-        if (resolved) return;
-        scheduleNext();
-      }, delayMs);
-      retry.timer.unref?.();
-    };
-
-    scheduleNext();
-  }
-
-  bindConfirmed(agentId, provider, sessionId) {
-    const agent = this.agents.get(agentId);
-    if (!agent || !provider || !sessionId || isTemporaryProviderSessionId(sessionId)) return null;
-    agent.providerSessionProvider = provider;
-    agent.providerSessionId = sessionId;
-    agent.providerSessionKey = mainPageAgentSessionKey(provider, sessionId, agent.providerHomeId || '');
-    agent.providerSessionTemporary = false;
-    return agent;
-  }
-
-  runResolution(kind, agentId, cooldownMs, force, task) {
-    const key = `${kind}:${agentId}`;
-    const current = this.resolutions.get(key);
-    if (current?.promise) return current.promise;
-    const now = Date.now();
-    if (!force && current && now - current.lastAttemptAt < cooldownMs) {
-      return Promise.resolve(false);
-    }
-
-    const resolution = { lastAttemptAt: now, promise: null };
-    const attempt = Promise.resolve()
-      .then(task)
-      .catch(() => false)
-      .finally(() => {
-        if (this.resolutions.get(key) === resolution) resolution.promise = null;
-      });
-    resolution.promise = attempt;
-    this.resolutions.set(key, resolution);
-    return attempt;
-  }
-
-  resolveTemporaryCodex(agentId, options = {}) {
-    const agent = this.agents.get(agentId);
-    if (!agent || agent.providerSessionProvider !== 'codex' || agent.providerSessionTemporary !== true) {
-      this.resolutions.delete(`codex:${agentId}`);
-      return Promise.resolve(false);
-    }
-    const startedAt = Number(agent.startedAt) || 0;
-    if (
-      options.force !== true
-      && startedAt
-      && Date.now() > startedAt + CODEX_MATCH_WINDOW_MS
-    ) {
-      return Promise.resolve(false);
-    }
-
-    return this.runResolution(
-      'codex',
-      agentId,
-      CODEX_RESOLVE_COOLDOWN_MS,
-      options.force === true,
-      () => this.findTemporaryCodexSession(agent).then((session) => {
-        if (!session?.id) return false;
-        return this.confirm(agentId, {
-          provider: 'codex',
-          sessionId: session.id,
-          source: 'codex-rollout',
-          title: session.title || '',
-          workspace: session.workspace || session.cwd || '',
-        });
-      }),
-    );
-  }
-
-  resolveTitle(agentId, options = {}) {
-    const agent = this.agents.get(agentId);
-    if (
-      !agent?.providerSessionProvider
-      || !agent.providerSessionId
-      || agent.providerSessionTemporary === true
-      || isTemporaryProviderSessionId(agent.providerSessionId)
-      || String(agent.providerSessionTitle || '').trim()
-    ) {
-      this.resolutions.delete(`title:${agentId}`);
-      return Promise.resolve(false);
-    }
-
-    const provider = agent.providerSessionProvider;
-    const sessionId = agent.providerSessionId;
-    return this.runResolution(
-      'title',
-      agentId,
-      TITLE_RESOLVE_COOLDOWN_MS,
-      options.force === true,
-      () => this.findAgentSession(provider, sessionId, {
-        limit: 200,
-        providerLimit: 200,
-        providerHomeId: agent.providerHomeId || 'default',
-        providerHomes: this.getProviderHomes(),
-      }).then((session) => {
-        const title = String(session?.title || '').trim().slice(0, 160);
-        if (!title) return false;
-
-        const current = this.agents.get(agentId);
-        if (
-          !current
-          || current.providerSessionProvider !== provider
-          || current.providerSessionId !== sessionId
-          || current.providerSessionTemporary === true
-          || String(current.providerSessionTitle || '').trim()
-        ) {
-          return false;
-        }
-
-        current.providerSessionTitle = title;
-        this.commit(current, {
-          kind: 'session-updated',
-          event: { agentId, provider, sessionId, title, temporary: false },
-        });
-        return true;
-      }),
-    );
-  }
-
-  async findTemporaryCodexSession(agent) {
-    const startedAt = Number(agent.startedAt) || 0;
-    const codexHome = agent.providerHomePath || '';
-    const scanKey = [
-      codexHome,
-      ...codexSessionDateKeys(startedAt, CODEX_MATCH_WINDOW_MS),
-    ].join('\0');
-    let scan = this.codexIdentityScans.get(scanKey);
-    if (!scan) {
-      scan = Promise.resolve(this.listCodexSessionIdentities({
-        codexHome: codexHome || undefined,
-        startedAt,
-        windowMs: CODEX_MATCH_WINDOW_MS,
-      })).finally(() => {
-        if (this.codexIdentityScans.get(scanKey) === scan) {
-          this.codexIdentityScans.delete(scanKey);
-        }
-      });
-      this.codexIdentityScans.set(scanKey, scan);
-    }
-    const sessions = await scan;
-    const workspace = normalizePath(
-      agent?.projectWorkspace || agent?.cwd || agent?.gitWorktree?.workspace || ''
-    );
-    if (!workspace) return null;
-    const homeId = String(agent.providerHomeId || 'default').trim() || 'default';
-    const claimedSessionIds = new Set([...this.agents.values()]
-      .filter(candidate => candidate?.id !== agent.id
-        && candidate?.providerSessionProvider === 'codex'
-        && (String(candidate.providerHomeId || 'default').trim() || 'default') === homeId
-        && candidate.providerSessionId
-        && candidate.providerSessionTemporary !== true)
-      .map(candidate => candidate.providerSessionId));
-    const candidates = sessions
-      .filter(session => {
-        if (!session?.id || claimedSessionIds.has(session.id)) return false;
-        const sessionWorkspace = normalizePath(session.workspace || session.cwd);
-        if (workspace && !sessionWorkspace) return false;
-        const sessionTime = timestampMs(session.createdAt);
-        if (!sessionTime || !startedAt) return false;
-        return Math.abs(sessionTime - startedAt) <= CODEX_MATCH_WINDOW_MS;
-      });
-
-    const exact = candidates.filter(session => (
-      workspace === normalizePath(session.workspace || session.cwd)
-    ));
-    if (exact.length === 1) return exact[0];
-    if (exact.length > 1) return null;
-    const canonicalWorkspace = canonicalPath(workspace);
-    const canonical = candidates.filter(session => (
-      canonicalWorkspace === canonicalPath(session.workspace || session.cwd)
-    ));
-    if (canonical.length === 1) return canonical[0];
-    return null;
-  }
-
-  confirm(agentId, { provider, sessionId, source, title, workspace }) {
-    const current = this.agents.get(agentId);
-    const homeId = String(current?.providerHomeId || 'default').trim() || 'default';
-    const claimedByAnotherAgent = [...this.agents.values()].some(candidate => (
-      candidate?.id !== agentId
-      && candidate?.providerSessionProvider === provider
-      && candidate?.providerSessionId === sessionId
-      && candidate?.providerSessionTemporary !== true
-      && (String(candidate.providerHomeId || 'default').trim() || 'default') === homeId
-    ));
-    if (claimedByAnotherAgent) return false;
-    const previousSessionId = current?.providerSessionId || '';
-    const agent = this.bindConfirmed(agentId, provider, sessionId);
-    if (!agent) return false;
-    const providerSessionTitle = String(title || '').trim().slice(0, 160);
-    agent.providerSessionSource = source || agent.providerSessionSource || '';
-    agent.providerSessionResolvedAt = Date.now();
-    if (typeof workspace === 'string' && workspace.trim()) {
-      agent.providerSessionWorkspace = normalizePath(workspace);
-    }
-    if (providerSessionTitle) agent.providerSessionTitle = providerSessionTitle;
-
-    this.stop(agentId);
-    this.commit(agent, {
-      kind: 'session-updated',
-      event: { agentId, provider, sessionId, previousSessionId, temporary: false },
-      refreshWorkspace: agent.providerSessionWorkspace || '',
-    });
-    return true;
-  }
-}
-
-module.exports = { ProviderSessionService };

package/backend/qr-share-tickets.js

@@ -1,100 +0,0 @@
-const crypto = require('crypto');
-
-const SHARE_TICKET_TTL_MS = 5 * 60 * 1000;
-const DEFAULT_CODE_LENGTH = 10;
-const DEFAULT_MAX_TICKETS = 200;
-const SHARE_TICKET_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
-
-function normalizeCode(value) {
-  return String(value || '').trim().toUpperCase();
-}
-
-function createShareTicketCode(options = {}) {
-  const length = Math.max(6, Math.min(Number(options.length) || DEFAULT_CODE_LENGTH, 32));
-  const randomBytes = typeof options.randomBytes === 'function' ? options.randomBytes : crypto.randomBytes;
-  const bytes = randomBytes(length);
-  let code = '';
-  for (let index = 0; index < length; index += 1) {
-    code += SHARE_TICKET_ALPHABET[bytes[index] % SHARE_TICKET_ALPHABET.length];
-  }
-  return code;
-}
-
-class QrShareTicketStore {
-  constructor(options = {}) {
-    this.ttlMs = Math.max(30_000, Number(options.ttlMs) || SHARE_TICKET_TTL_MS);
-    this.codeLength = Math.max(6, Math.min(Number(options.codeLength) || DEFAULT_CODE_LENGTH, 32));
-    this.maxTickets = Math.max(1, Number(options.maxTickets) || DEFAULT_MAX_TICKETS);
-    this.randomBytes = typeof options.randomBytes === 'function' ? options.randomBytes : crypto.randomBytes;
-    this.tickets = new Map();
-  }
-
-  create(token, options = {}) {
-    const now = Number(options.now) || Date.now();
-    const targetQuery = typeof options.targetQuery === 'string' ? options.targetQuery : '';
-    this.cleanup(now);
-    this.trim(now);
-
-    let code = '';
-    for (let attempt = 0; attempt < 8; attempt += 1) {
-      code = createShareTicketCode({ length: this.codeLength, randomBytes: this.randomBytes });
-      if (!this.tickets.has(code)) break;
-      code = '';
-    }
-    if (!code) {
-      throw new Error('Unable to allocate share code');
-    }
-
-    const ticket = {
-      code,
-      token: String(token || ''),
-      targetQuery,
-      createdAt: now,
-      expiresAt: now + this.ttlMs,
-    };
-    this.tickets.set(code, ticket);
-    return { ...ticket };
-  }
-
-  consume(code, options = {}) {
-    const normalizedCode = normalizeCode(code);
-    const now = Number(options.now) || Date.now();
-    const ticket = this.tickets.get(normalizedCode);
-    if (!ticket) return null;
-    this.tickets.delete(normalizedCode);
-    if (ticket.expiresAt <= now) return null;
-    return { ...ticket };
-  }
-
-  revoke(code) {
-    return this.tickets.delete(normalizeCode(code));
-  }
-
-  cleanup(now = Date.now()) {
-    for (const [code, ticket] of this.tickets) {
-      if (ticket.expiresAt <= now) {
-        this.tickets.delete(code);
-      }
-    }
-  }
-
-  trim(now = Date.now()) {
-    if (this.tickets.size < this.maxTickets) return;
-    this.cleanup(now);
-    if (this.tickets.size < this.maxTickets) return;
-    const oldest = [...this.tickets.values()]
-      .sort((a, b) => a.expiresAt - b.expiresAt)
-      .slice(0, Math.max(1, this.tickets.size - this.maxTickets + 1));
-    for (const ticket of oldest) {
-      this.tickets.delete(ticket.code);
-    }
-  }
-}
-
-module.exports = {
-  QrShareTicketStore,
-  SHARE_TICKET_ALPHABET,
-  SHARE_TICKET_TTL_MS,
-  createShareTicketCode,
-  normalizeCode,
-};

package/backend/review-diff-router.js

@@ -1,180 +0,0 @@
-const express = require('express');
-const { ReviewSessionError } = require('./review-session-service');
-const { WorkspaceFileError } = require('./workspace-file-service');
-
-function createReviewDiffRouter(reviewDiffService, reviewSessionService) {
-  const router = express.Router();
-  function sendWorkspaceError(res, error, fallbackMessage, logMessage) {
-    if (error instanceof WorkspaceFileError) {
-      res.status(error.statusCode).json({ error: error.message, ...(Object.keys(error.details || {}).length ? { details: error.details } : {}) });
-      return true;
-    }
-    if (error instanceof ReviewSessionError) {
-      res.status(error.statusCode).json({ error: error.message });
-      return true;
-    }
-    console.error(logMessage, error);
-    res.status(500).json({ error: fallbackMessage });
-    return true;
-  }
-
-  function assertReviewSessionRange(req) {
-    if (req.query.reviewId === undefined) return;
-    reviewSessionService?.assertRange(req.query.reviewId, req.query.root, req.query.base, req.query.head);
-  }
-
-  function sendPatch(res, patch, filename, truncated) {
-    res.set({
-      'Content-Disposition': `attachment; filename="${filename}"`,
-      'Content-Type': 'text/x-diff; charset=utf-8',
-      'X-Farming-Review-Truncated': truncated === true ? 'true' : 'false',
-    });
-    res.send(patch);
-  }
-
-  router.get('/comparison-sources', async (req, res) => {
-    try {
-      res.json(await reviewDiffService.getComparisonSources(req.query.agentId, {
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      }));
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review comparison sources could not be loaded', 'Review comparison source API error:');
-    }
-  });
-
-  router.get('/working-copy/patch', async (req, res) => {
-    try {
-      const result = await reviewDiffService.getWorkingCopyPatch(req.query.agentId, {
-        context: req.query.context,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        limit: req.query.limit,
-        ...(req.query.modifiedWithinDays !== undefined ? { modifiedWithinDays: req.query.modifiedWithinDays } : {}),
-        ...(req.query.scope !== undefined ? { scope: req.query.scope } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      sendPatch(res, result.patch, 'working-copy.patch', result.truncated);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review patch download failed', 'Review patch download API error:');
-    }
-  });
-  router.get('/working-copy', async (req, res) => {
-    try {
-      const review = await reviewDiffService.getWorkingCopy(req.query.agentId, {
-        context: req.query.context,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        limit: req.query.limit,
-        metadataOnly: req.query.metadataOnly,
-        ...(req.query.modifiedWithinDays !== undefined ? { modifiedWithinDays: req.query.modifiedWithinDays } : {}),
-        ...(req.query.scope !== undefined ? { scope: req.query.scope } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(review);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review diff operation failed', 'Review diff API error:');
-    }
-  });
-  router.get('/working-copy/files/:filePath/diff', async (req, res) => {
-    try {
-      const file = await reviewDiffService.getWorkingCopyFile(req.query.agentId, req.params.filePath, {
-        context: req.query.context,
-        fileMeta: true,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        ...(req.query.modifiedWithinDays !== undefined ? { modifiedWithinDays: req.query.modifiedWithinDays } : {}),
-        ...(req.query.scope !== undefined ? { scope: req.query.scope } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(file);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review file diff operation failed', 'Review file diff API error:');
-    }
-  });
-  router.get('/working-copy/files/:filePath/context', async (req, res) => {
-    try {
-      const context = await reviewDiffService.getWorkingCopyFileContext(req.query.agentId, req.params.filePath, {
-        lines: req.query.lines,
-        newStart: req.query.newStart,
-        oldStart: req.query.oldStart,
-        ...(req.query.modifiedWithinDays !== undefined ? { modifiedWithinDays: req.query.modifiedWithinDays } : {}),
-        ...(req.query.scope !== undefined ? { scope: req.query.scope } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(context);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review context operation failed', 'Review context API error:');
-    }
-  });
-  router.get('/git-range/patch', async (req, res) => {
-    try {
-      assertReviewSessionRange(req);
-      const result = await reviewDiffService.getGitRangePatch(req.query.agentId, {
-        base: req.query.base,
-        context: req.query.context,
-        head: req.query.head,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        limit: req.query.limit,
-        ...(req.query.reviewId !== undefined ? { reviewId: req.query.reviewId } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      sendPatch(res, result.patch, 'git-range.patch', result.truncated);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review git range patch download failed', 'Review git range patch download API error:');
-    }
-  });
-  router.get('/git-range', async (req, res) => {
-    try {
-      assertReviewSessionRange(req);
-      const review = await reviewDiffService.getGitRange(req.query.agentId, {
-        base: req.query.base,
-        context: req.query.context,
-        head: req.query.head,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        limit: req.query.limit,
-        metadataOnly: req.query.metadataOnly,
-        ...(req.query.reviewId !== undefined ? { reviewId: req.query.reviewId } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(review);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review git range operation failed', 'Review git range API error:');
-    }
-  });
-  router.get('/git-range/files/:filePath/diff', async (req, res) => {
-    try {
-      assertReviewSessionRange(req);
-      const file = await reviewDiffService.getGitRangeFile(req.query.agentId, {
-        base: req.query.base,
-        context: req.query.context,
-        fileMeta: true,
-        head: req.query.head,
-        ignoreWhitespace: req.query.ignoreWhitespace,
-        path: req.params.filePath,
-        ...(req.query.reviewId !== undefined ? { reviewId: req.query.reviewId } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(file);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review git range file diff operation failed', 'Review git range file diff API error:');
-    }
-  });
-  router.get('/git-range/files/:filePath/context', async (req, res) => {
-    try {
-      assertReviewSessionRange(req);
-      const context = await reviewDiffService.getGitRangeFileContext(req.query.agentId, {
-        base: req.query.base,
-        head: req.query.head,
-        lines: req.query.lines,
-        newStart: req.query.newStart,
-        oldStart: req.query.oldStart,
-        path: req.params.filePath,
-        ...(req.query.reviewId !== undefined ? { reviewId: req.query.reviewId } : {}),
-        ...(req.query.root !== undefined ? { root: req.query.root } : {}),
-      });
-      res.json(context);
-    } catch (error) {
-      sendWorkspaceError(res, error, 'review git range context operation failed', 'Review git range context API error:');
-    }
-  });
-  return router;
-}
-
-module.exports = { createReviewDiffRouter };