Function checkServerFeatureSupport

src/util/server.ts:46–100

(
  featureName: string,
  requiredBuildDate: string,
)

 * @returns Promise<boolean> - true if server supports the feature
 */
export async function checkServerFeatureSupport(
  featureName: string,
  requiredBuildDate: string,
): Promise<boolean> {
  const cacheKey = `${featureName}`;

  // Return cached result if available
  if (featureCache.has(cacheKey)) {
    return featureCache.get(cacheKey)!;
  }

  let supported = false;

  try {
    logger.debug(`[Feature Detection] Checking server support for feature: ${featureName}`);

    const versionUrl = getRemoteVersionUrl();

    if (versionUrl) {
      const response = await fetchWithProxy(versionUrl, {
        method: 'GET',
        headers: { 'Content-Type': 'application/json' },
      });

      const data = await response.json();

      if (data.buildDate) {
        // Parse build date and check if it's after the required date
        const buildDate = new Date(data.buildDate);
        const featureDate = new Date(requiredBuildDate);
        supported = buildDate >= featureDate;
        logger.debug(
          `[Feature Detection] ${featureName}: buildDate=${data.buildDate}, required=${requiredBuildDate}, supported=${supported}`,
        );
      } else {
        logger.debug(`[Feature Detection] ${featureName}: no version info, assuming not supported`);
        supported = false;
      }
    } else {
      logger.debug(
        `[Feature Detection] No remote URL available for ${featureName}, assuming local server supports it`,
      );
      supported = true;
    }
  } catch (error) {
    logger.debug(
      `[Feature Detection] Version check failed for ${featureName}, assuming not supported: ${error}`,
    );
    supported = false;
  }

  // Cache the result
  featureCache.set(cacheKey, supported);
  return supported;
}

export async function checkServerRunning(port = getDefaultPort()): Promise<boolean> {
  logger.debug(`Checking for existing server on port ${port}...`);