coding-tool-x 3.7.4 → 3.7.6

package/src/server/services/gemini-sessions.js

@@ -615,7 +615,11 @@ function normalizeSession(geminiSession) {
  * @param {string} projectHash - 项目 hash
  * @returns {string|null} 项目路径
  */
-function getProjectPath(projectHash) {
+function getProjectPath(projectHash, options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const pathMapping = buildPathMapping();
   return pathMapping.get(projectHash) || null;
 }
@@ -624,7 +628,11 @@ function getProjectPath(projectHash) {
  * 聚合项目列表
  * @returns {Array} 项目对象数组
  */
-function getProjects() {
+function getProjects(options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const sessions = getAllSessions();
   const projectMap = new Map();
 
@@ -680,7 +688,11 @@ function getProjects() {
  * @param {string} projectHash - 项目 hash
  * @returns {Array} 会话对象数组
  */
-function getProjectSessions(projectHash) {
+function getProjectSessions(projectHash, options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const allSessions = getAllSessions();
   return allSessions
     .filter(session => session.projectHash === projectHash)

package/src/server/services/native-oauth-adapters.js

@@ -1029,7 +1029,8 @@ function runOmpCommand(args = [], options = {}) {
       ...process.env,
       ...(options.env || {})
     },
-    timeout: options.timeout || 10000
+    timeout: options.timeout || 10000,
+    windowsHide: true
   });
   const status = result?.status === undefined || result?.status === null ? 0 : result.status;
   return {

package/src/server/services/omp-auth-provider-worker.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { getOmpAuthProviderSnapshot } = require('./omp-auth-providers');
+
+function attachWorkerHandler() {
+  process.on('message', (options = {}) => {
+    try {
+      const value = getOmpAuthProviderSnapshot(options);
+      if (process.send) {
+        process.send({ ok: true, value }, () => process.exit(0));
+        return;
+      }
+    } catch (error) {
+      if (process.send) {
+        process.send({ ok: false, error: error?.message || String(error) }, () => process.exit(1));
+        return;
+      }
+    }
+    process.exit(1);
+  });
+}
+
+if (process.env.CC_TOOL_OMP_AUTH_PROVIDER_WORKER === '1' || require.main === module) {
+  attachWorkerHandler();
+}
+
+module.exports = {
+  attachWorkerHandler
+};

package/src/server/services/omp-auth-providers.js

@@ -1,9 +1,11 @@
-const { spawnSync } = require('child_process');
+const path = require('path');
+const { fork, spawnSync } = require('child_process');
 const ompConfig = require('./omp-config');
 
 const COMMAND_TIMEOUT_MS = 5000;
 const TOKEN_LIST_TIMEOUT_MS = 3000;
 const CACHE_TTL_MS = 15000;
+const WARMUP_WORKER_TIMEOUT_MS = COMMAND_TIMEOUT_MS + 1000;
 
 const LOGIN_PROVIDER_IDS = new Set([
   'openai-codex',
@@ -50,6 +52,20 @@ const PROVIDER_ALIASES = {
 };
 
 let snapshotCache = {};
+const warmupTimers = new Map();
+const warmupErrors = new Map();
+
+function getSnapshotCacheKey(options = {}) {
+  return options.accountCheck === false
+    ? (options.includeStatus === false ? 'metadata' : 'metadata-status')
+    : 'full';
+}
+
+function writeSnapshotCache(cacheKey, loadedAt, value) {
+  snapshotCache[cacheKey] = { loadedAt, value };
+  warmupErrors.delete(cacheKey);
+  return value;
+}
 
 function normalizeProviderId(value = '') {
   return String(value || '')
@@ -95,7 +111,8 @@ function runCommand(command, args = [], options = {}) {
       ...process.env,
       ...(options.env || {})
     },
-    timeout: options.timeout || COMMAND_TIMEOUT_MS
+    timeout: options.timeout || COMMAND_TIMEOUT_MS,
+    windowsHide: true
   });
   if (typeof result === 'string' || Buffer.isBuffer(result)) {
     return { status: 0, stdout: normalizeCommandOutput(result), stderr: '' };
@@ -205,9 +222,7 @@ function buildEmptySnapshot(runtime, reason) {
 
 function getOmpAuthProviderSnapshot(options = {}) {
   const now = Date.now();
-  const cacheKey = options.accountCheck === false
-    ? (options.includeStatus === false ? 'metadata' : 'metadata-status')
-    : 'full';
+  const cacheKey = getSnapshotCacheKey(options);
   const cached = snapshotCache[cacheKey];
   if (!options.forceRefresh && cached && now - cached.loadedAt < CACHE_TTL_MS) {
     return cached.value;
@@ -217,16 +232,14 @@ function getOmpAuthProviderSnapshot(options = {}) {
   const runtime = options.runtime || ompConfig.resolveOmpRuntime(env, options.runtimeOptions || {});
   if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
     const value = buildEmptySnapshot(runtime || null, 'omp-not-available');
-    snapshotCache[cacheKey] = { loadedAt: now, value };
-    return value;
+    return writeSnapshotCache(cacheKey, now, value);
   }
 
   const command = runtime.command;
   const listResult = parseJsonCommand(command, ['auth-broker', 'list', '--json'], options);
   if (!listResult.ok || !Array.isArray(listResult.value)) {
     const value = buildEmptySnapshot(runtime, listResult.error || listResult.stderr || 'auth-provider-list-failed');
-    snapshotCache[cacheKey] = { loadedAt: now, value };
-    return value;
+    return writeSnapshotCache(cacheKey, now, value);
   }
 
   const supportedProviders = listResult.value
@@ -268,8 +281,112 @@ function getOmpAuthProviderSnapshot(options = {}) {
     aliases: { ...PROVIDER_ALIASES },
     checkedAt: new Date().toISOString()
   };
-  snapshotCache[cacheKey] = { loadedAt: now, value };
-  return value;
+  return writeSnapshotCache(cacheKey, now, value);
+}
+
+function getCachedOmpAuthProviderSnapshot(options = {}) {
+  const cacheKey = getSnapshotCacheKey(options);
+  const cached = snapshotCache[cacheKey];
+  if (!cached) return null;
+  return {
+    ...cached.value,
+    stale: Date.now() - cached.loadedAt >= CACHE_TTL_MS
+  };
+}
+
+function getOmpAuthProviderCacheMeta(options = {}) {
+  const cacheKey = getSnapshotCacheKey(options);
+  const cached = snapshotCache[cacheKey];
+  const stale = !cached || Date.now() - cached.loadedAt >= CACHE_TTL_MS;
+  const cachedReason = cached?.value?.available === false ? cached.value.reason || null : null;
+  return {
+    cached: Boolean(cached),
+    stale,
+    refreshing: warmupTimers.has(cacheKey),
+    fallback: !cached,
+    checkedAt: cached?.value?.checkedAt || null,
+    error: warmupErrors.get(cacheKey) || cachedReason || null
+  };
+}
+
+function warmOmpAuthProviderSnapshot(options = {}) {
+  const cacheKey = getSnapshotCacheKey(options);
+  if (warmupTimers.has(cacheKey)) return;
+
+  const finishWarmup = (task, error = null, value = null) => {
+    if (!warmupTimers.has(cacheKey)) return;
+    if (task.timeout) clearTimeout(task.timeout);
+    if (task.child) {
+      task.child.removeAllListeners();
+      if (!task.child.killed) task.child.kill();
+    }
+    warmupTimers.delete(cacheKey);
+    if (error) {
+      warmupErrors.set(cacheKey, sanitizeIdentity(error?.message || String(error || 'auth-provider-warmup-failed')));
+      return;
+    }
+    if (value) {
+      writeSnapshotCache(cacheKey, Date.now(), value);
+    }
+  };
+
+  // Tests and callers that supply a function-based command runner cannot cross
+  // the process boundary. Production channel-list warmups use the worker path.
+  if (process.env.NODE_ENV === 'test' || options.commandRunner) {
+    const task = { timeout: null, child: null };
+    const timer = setTimeout(() => {
+      try {
+        finishWarmup(task, null, getOmpAuthProviderSnapshot(options));
+      } catch (error) {
+        finishWarmup(task, error);
+      }
+    }, 0);
+    task.timeout = timer;
+    warmupTimers.set(cacheKey, task);
+    return;
+  }
+
+  const workerPath = path.join(__dirname, 'omp-auth-provider-worker.js');
+  const task = { timeout: null, child: null };
+  try {
+    const child = fork(workerPath, [], {
+      stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+      env: {
+        ...process.env,
+        CC_TOOL_OMP_AUTH_PROVIDER_WORKER: '1'
+      }
+    });
+    task.child = child;
+    task.timeout = setTimeout(() => {
+      finishWarmup(task, new Error('auth-provider-warmup-timed-out'));
+    }, WARMUP_WORKER_TIMEOUT_MS);
+    warmupTimers.set(cacheKey, task);
+
+    child.on('message', (message) => {
+      if (message?.ok) {
+        finishWarmup(task, null, message.value);
+      } else {
+        finishWarmup(task, new Error(message?.error || 'auth-provider-warmup-failed'));
+      }
+    });
+    child.on('error', (error) => finishWarmup(task, error));
+    child.on('exit', (code, signal) => {
+      if (warmupTimers.get(cacheKey) === task) {
+        finishWarmup(task, new Error(`auth-provider-warmup-worker-exited-${code || signal || 'unknown'}`));
+      }
+    });
+    child.send({
+      accountCheck: options.accountCheck,
+      includeStatus: options.includeStatus,
+      forceRefresh: options.forceRefresh === true,
+      runtime: options.runtime,
+      runtimeOptions: options.runtimeOptions
+    });
+  } catch (error) {
+    // `fork` itself can fail before the task is registered. Preserve the
+    // failure for the non-blocking status endpoint instead of dropping it.
+    warmupErrors.set(cacheKey, sanitizeIdentity(error?.message || String(error || 'auth-provider-warmup-failed')));
+  }
 }
 
 function findAuthProviderForKey(providerKey, snapshot) {
@@ -280,6 +397,12 @@ function findAuthProviderForKey(providerKey, snapshot) {
 
 function clearOmpAuthProviderCache() {
   snapshotCache = {};
+  for (const task of warmupTimers.values()) {
+    if (task.timeout) clearTimeout(task.timeout);
+    if (task.child && !task.child.killed) task.child.kill();
+  }
+  warmupTimers.clear();
+  warmupErrors.clear();
 }
 
 module.exports = {
@@ -287,7 +410,10 @@ module.exports = {
   ACCOUNT_CHECK_PROVIDER_IDS,
   clearOmpAuthProviderCache,
   findAuthProviderForKey,
+  getCachedOmpAuthProviderSnapshot,
+  getOmpAuthProviderCacheMeta,
   getOmpAuthProviderSnapshot,
+  warmOmpAuthProviderSnapshot,
   normalizeProviderId,
   resolveProviderAlias,
   sanitizeIdentity

package/src/server/services/omp-config.js

@@ -61,7 +61,10 @@ function runOmpCommand(command, args = [], env = process.env, options = {}, stdi
     encoding: 'utf8',
     env: buildCommandEnv(env),
     stdio,
-    timeout: options.timeout || 3000
+    timeout: options.timeout || 3000,
+    // On Windows, an npm/PowerShell command shim can otherwise create a visible
+    // console every time we probe OMP or resolve its configuration directory.
+    windowsHide: true
   });
 }
 
@@ -76,8 +79,8 @@ function readOmpAgentDirFromCommand(command, env = process.env, options = {}) {
 }
 
 function getOmpAgentDir(env = process.env, options = {}) {
-  const runtime = options.runtime || resolveOmpRuntime(env, options);
-  if (runtime.runtime === 'omp' && runtime.installed) {
+  const runtime = options.runtime || (options.resolveRuntime === false ? null : resolveOmpRuntime(env, options));
+  if (runtime?.runtime === 'omp' && runtime.installed) {
     const commandAgentDir = readOmpAgentDirFromCommand(runtime.command, env, options);
     if (commandAgentDir) {
       return commandAgentDir;
@@ -87,7 +90,7 @@ function getOmpAgentDir(env = process.env, options = {}) {
 }
 
 function getOmpPaths(env = process.env, options = {}) {
-  const runtime = options.runtime || resolveOmpRuntime(env, options);
+  const runtime = options.runtime || (options.resolveRuntime === false ? null : resolveOmpRuntime(env, options));
   const agentDir = getOmpAgentDir(env, { ...options, runtime });
   return {
     agentDir,

package/src/server/services/omp-sessions.js

@@ -1,11 +1,12 @@
 const fs = require('fs');
 const path = require('path');
-const { execFileSync } = require('child_process');
 const { PATHS, HOME_DIR } = require('../../config/paths');
-const { getOmpCommand, getOmpPaths, isOmpInstalled, resolveOmpRuntime } = require('./omp-config');
+const { getOmpCommand, getOmpPaths, resolveOmpRuntime } = require('./omp-config');
 
 const PROJECT_ORDER_FILE = PATHS.ompProjectOrder;
 const SESSION_ORDER_FILE = PATHS.ompSessionOrder;
+const OMP_INSTALL_CACHE_TTL_MS = 5 * 60 * 1000;
+let ompInstallCache = { expiresAt: 0, value: false };
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -211,7 +212,20 @@ function parseSessionFile(filePath) {
   };
 }
 
-function scanSessionFiles(rootDir = getOmpPaths().sessions) {
+function getOmpSessionPaths() {
+  // Reading historical sessions normally only needs OMP's native directory
+  // convention. Avoid starting the CLI here: project/count snapshot workers
+  // invoke this path independently, which made Windows repeatedly open
+  // PowerShell shims. Keep the CLI lookup as a fallback for non-standard OMP
+  // locations that cannot be derived from the environment.
+  const nativePaths = getOmpPaths(process.env, { resolveRuntime: false });
+  if (fs.existsSync(nativePaths.agentDir) || fs.existsSync(nativePaths.sessions)) {
+    return nativePaths;
+  }
+  return getOmpPaths();
+}
+
+function scanSessionFiles(rootDir = getOmpSessionPaths().sessions) {
   if (!fs.existsSync(rootDir)) {
     return [];
   }
@@ -259,7 +273,7 @@ function loadSessionOrder() {
   return safeReadJson(SESSION_ORDER_FILE, {});
 }
 
-function getProjects() {
+function getProjects(_options = {}) {
   const sessions = getAllSessions();
   const projectMap = new Map();
   sessions.forEach((session) => {
@@ -299,7 +313,7 @@ function getProjects() {
   return projects;
 }
 
-function getSessionsByProject(projectName) {
+function getSessionsByProject(projectName, _options = {}) {
   const orderMap = loadSessionOrder();
   const order = Array.isArray(orderMap[projectName]) ? orderMap[projectName] : [];
   const sessions = getAllSessions().filter(session => session.projectName === projectName);
@@ -425,7 +439,7 @@ function saveSessionOrder(projectName, order) {
   safeWriteJson(SESSION_ORDER_FILE, data);
 }
 
-function getProjectAndSessionCounts() {
+function getProjectAndSessionCounts(_options = {}) {
   const sessions = getAllSessions();
   return {
     projectCount: new Set(sessions.map(session => session.projectName)).size,
@@ -454,15 +468,25 @@ function shellQuote(value) {
 }
 
 function isOmpCliInstalled() {
-  if (isOmpInstalled()) return true;
-  const runtime = resolveOmpRuntime();
-  if (runtime.installed) return true;
-  try {
-    execFileSync(getOmpCommand(), ['--version'], { stdio: 'ignore', timeout: 3000 });
-    return true;
-  } catch {
-    return false;
+  const now = Date.now();
+  if (ompInstallCache.expiresAt > now) {
+    return ompInstallCache.value;
   }
+
+  let installed = false;
+  const nativePaths = getOmpSessionPaths();
+  if (fs.existsSync(nativePaths.agentDir)) {
+    installed = true;
+  } else {
+    const runtime = resolveOmpRuntime();
+    installed = Boolean(runtime && runtime.installed);
+  }
+
+  ompInstallCache = {
+    value: installed,
+    expiresAt: now + OMP_INSTALL_CACHE_TTL_MS
+  };
+  return installed;
 }
 
 module.exports = {

package/src/server/services/opencode-sessions.js

@@ -493,7 +493,7 @@ function getProjectDisplayName(project) {
 }
 
 // 获取所有项目
-function getProjects() {
+function getProjects(_options = {}) {
   const projects = getProjectRows().map((project) => ({
     name: project.id,
     displayName: getProjectDisplayName(project),
@@ -512,7 +512,7 @@ function getProjects() {
 }
 
 // 根据项目ID获取会话列表
-function getSessionsByProjectId(projectId) {
+function getSessionsByProjectId(projectId, _options = {}) {
   const sessions = getSessionRowsByProjectId(projectId).map(session => normalizeSession(session, projectId));
   const order = getSessionOrder(projectId);
 
@@ -536,8 +536,8 @@ function getSessionsByProjectId(projectId) {
 }
 
 // 根据项目名获取会话列表
-function getSessionsByProject(projectName) {
-  return getSessionsByProjectId(projectName);
+function getSessionsByProject(projectName, options = {}) {
+  return getSessionsByProjectId(projectName, options);
 }
 
 function getSessionLocation(sessionId) {
@@ -628,9 +628,12 @@ function getSessionMessages(sessionId) {
 }
 
 // 获取项目和会话数量统计
-function getProjectAndSessionCounts() {
+function getProjectAndSessionCounts(options = {}) {
   const now = Date.now();
-  if (countsCache.expiresAt > now) {
+  if (options.force) {
+    countsCache.expiresAt = 0;
+  }
+  if (!options.force && countsCache.expiresAt > now) {
     return countsCache.value;
   }
 

package/src/server/services/plugins-service.js

@@ -833,7 +833,8 @@ class PluginsService {
       cwd: process.cwd(),
       encoding: 'utf8',
       stdio: 'pipe',
-      timeout: 120000
+      timeout: 120000,
+      windowsHide: true
     });
   }
 

package/src/server/services/project-snapshots.js

@@ -6,6 +6,8 @@ const {
 } = require('./snapshot-cache');
 
 const PROJECT_SNAPSHOT_TTL_MS = 60 * 1000;
+const PROJECT_SNAPSHOT_WAIT_ON_MISS_MS = process.env.NODE_ENV === 'test' ? 0 : 1500;
+const PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS = process.env.NODE_ENV === 'test' ? 0 : 1500;
 
 function projectListKey(source) {
   return `projects:list:${source}`;
@@ -33,7 +35,10 @@ async function getProjectListSnapshot(source, {
     fallbackValue,
     refresh,
     force,
-    backgroundOnMiss: !force
+    backgroundOnMiss: !force,
+    staleWhileForce: true,
+    waitOnMissMs: PROJECT_SNAPSHOT_WAIT_ON_MISS_MS,
+    waitOnForceMs: PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS
   });
 }
 
@@ -44,6 +49,8 @@ function invalidateProjectSnapshots(source) {
 
 module.exports = {
   PROJECT_SNAPSHOT_TTL_MS,
+  PROJECT_SNAPSHOT_WAIT_ON_MISS_MS,
+  PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS,
   projectListKey,
   projectCountKey,
   emptyProjectList,

package/src/server/services/session-snapshot-worker.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const path = require('path');
+
+function totalSizeOf(sessions) {
+  return sessions.reduce((sum, session) => sum + (Number(session.size) || 0), 0);
+}
+
+function getAliases() {
+  const { loadAliases } = require('./alias');
+  return loadAliases();
+}
+
+async function buildClaudePayload(projectName, config, options = {}) {
+  const {
+    getSessionsForProject,
+    parseRealProjectPath
+  } = require('./sessions');
+
+  const result = await getSessionsForProject(config, projectName, { force: options.force === true });
+  const { fullPath, projectName: displayName } = parseRealProjectPath(projectName);
+
+  return {
+    sessions: result.sessions,
+    totalSize: result.totalSize,
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      displayName,
+      fullPath
+    }
+  };
+}
+
+function buildCodexPayload(projectName, options = {}) {
+  const { getSessionsByProject } = require('./codex-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath: projectName,
+      path: projectName,
+      displayName: projectName
+    }
+  };
+}
+
+function buildGeminiPayload(projectHash, options = {}) {
+  const { getProjectSessions, getProjectPath } = require('./gemini-sessions');
+  const sessions = getProjectSessions(projectHash, { force: options.force === true });
+  const realPath = getProjectPath(projectHash, { force: options.force === true });
+  const displayName = realPath ? path.basename(realPath) : `Project ${projectHash.substring(0, 8)}`;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectHash,
+      fullPath: realPath || projectHash,
+      path: realPath || projectHash,
+      displayName
+    }
+  };
+}
+
+function buildOpenCodePayload(projectName, options = {}) {
+  const { getSessionsByProject, getProjects } = require('./opencode-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+  const firstDirectory = sessions.find(session => session.directory)?.directory;
+  const project = firstDirectory ? null : getProjects({ force: options.force === true }).find(p => p.name === projectName);
+  const fullPath = firstDirectory || project?.fullPath || projectName;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath,
+      path: project?.path || fullPath,
+      displayName: project?.displayName || (fullPath ? path.basename(fullPath) : projectName)
+    }
+  };
+}
+
+function buildOmpPayload(projectName, options = {}) {
+  const { getProjects, getSessionsByProject } = require('./omp-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+  const firstDirectory = sessions.find(session => session.directory)?.directory;
+  let project = null;
+  try {
+    project = getProjects({ force: options.force === true }).find(p => p.name === projectName) || null;
+  } catch {
+    project = null;
+  }
+  const fullPath = project?.fullPath || project?.path || firstDirectory || projectName;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath,
+      path: project?.path || fullPath,
+      displayName: project?.displayName || (fullPath ? path.basename(fullPath) : projectName)
+    }
+  };
+}
+
+async function buildPayload({ source, projectName, config, options }) {
+  const snapshotOptions = options || {};
+  switch (source) {
+    case 'claude':
+      return buildClaudePayload(projectName, config || {}, snapshotOptions);
+    case 'codex':
+      return buildCodexPayload(projectName, snapshotOptions);
+    case 'gemini':
+      return buildGeminiPayload(projectName, snapshotOptions);
+    case 'opencode':
+      return buildOpenCodePayload(projectName, snapshotOptions);
+    case 'omp':
+      return buildOmpPayload(projectName, snapshotOptions);
+    default:
+      throw new Error(`Unsupported session snapshot source: ${source}`);
+  }
+}
+
+function attachWorkerHandler() {
+  process.on('message', async (message) => {
+    try {
+      const value = await buildPayload(message || {});
+      if (process.send) {
+        process.send({ ok: true, value }, () => process.exit(0));
+        return;
+      }
+    } catch (error) {
+      if (process.send) {
+        process.send({ ok: false, error: error?.message || String(error) }, () => process.exit(1));
+        return;
+      }
+    }
+    process.exit(0);
+  });
+}
+
+if (process.env.CC_TOOL_SESSION_SNAPSHOT_WORKER === '1' || require.main === module) {
+  attachWorkerHandler();
+}
+
+module.exports = {
+  buildPayload
+};