better handling of version

Author: worph

src/common/EnvConfig.ts

@@ -35,6 +35,8 @@ interface EnvConfig {
     HEALTH_CHECK_PATH: string;
     /** [requester] Optional health check Host header override */
     HEALTH_CHECK_HOST: string;
+    /** [requester] Provider retry interval in seconds when version check fails (default: 600 = 10 minutes) */
+    PROVIDER_RETRY_INTERVAL: number;
 }
 
 /**
@@ -70,6 +72,7 @@ export const config: EnvConfig = {
     ROUTE_REFRESH_INTERVAL: parseInt(process.env.ROUTE_REFRESH_INTERVAL || '300', 10),
     HEALTH_CHECK_PATH: process.env.HEALTH_CHECK_PATH || '',
     HEALTH_CHECK_HOST: process.env.HEALTH_CHECK_HOST || '',
+    PROVIDER_RETRY_INTERVAL: parseInt(process.env.PROVIDER_RETRY_INTERVAL || '600', 10),
 };
 
 /**

src/requester/ProviderTools.ts

@@ -79,4 +79,36 @@ export async function waitForProvider(providerURL: string, retryIntervalSeconds:
   }
 
   throw new Error(`Provider ${providerURL} not available after ${maxRetries} attempts`);
+}
+
+export interface ProviderVersionInfo {
+  compatible: boolean;
+  version: number;
+  error?: string;
+}
+
+/**
+ * Checks the provider backend API version for compatibility.
+ * Returns version info indicating if the backend is compatible (v2+).
+ * Used for graceful migration - clients wait if backend is outdated.
+ */
+export async function checkProviderVersion(providerURL: string): Promise<ProviderVersionInfo> {
+  try {
+    const curlCommand = `curl -s -k --max-time 10 ${providerURL}/router/api/version`;
+    const { stdout } = await execPromise(curlCommand);
+    const data = JSON.parse(stdout);
+
+    if (typeof data.version !== 'number') {
+      return { compatible: false, version: 0, error: 'Invalid version response' };
+    }
+
+    const compatible = data.version >= 2;
+    return { compatible, version: data.version };
+  } catch (error) {
+    return {
+      compatible: false,
+      version: 0,
+      error: error instanceof Error ? error.message : 'Version check failed'
+    };
+  }
 }

src/requester/Requester.ts

@@ -6,7 +6,8 @@ import {promisify} from 'util';
 import {Config} from "./RequesterConfig.js";
 import {HandshakesWatcher} from './HandshakesWatcher.js';
 import {getConfigPath} from "./WireGuard.js";
-import {ProviderTools, registerProvider, waitForProvider} from "./ProviderTools.js";
+import {ProviderTools, registerProvider, waitForProvider, checkProviderVersion} from "./ProviderTools.js";
+import {config} from "../common/EnvConfig.js";
 import {getOrGenerateKeyPair} from "./KeyPair.js";
 import {registerTunnelRoute, startRouteRefreshLoop, stopRouteRefreshLoop} from "./RouteRegistrar.js";
 
@@ -103,10 +104,24 @@ async function stopRequester(providerString: string) {
 }
 
 async function startRequester(provider:ProviderTools) {
+  const [providerURL, userId = '', signature = ''] = provider.provider.split(',');
+  console.log(`Starting requester for ${providerURL}`);
+
+  // Check version FIRST (before waitForProvider)
+  console.log('Checking provider version...');
+  const versionInfo = await checkProviderVersion(providerURL);
+
+  if (!versionInfo.compatible) {
+    console.warn(`Provider version incompatible (v${versionInfo.version}). Requires v2+. ${versionInfo.error || ''}`);
+    console.warn(`Will retry in ${config.PROVIDER_RETRY_INTERVAL}s...`);
+
+    // Schedule retry
+    setTimeout(() => startRequester(provider), config.PROVIDER_RETRY_INTERVAL * 1000);
+    return;
+  }
+  console.log(`Provider version: v${versionInfo.version} (compatible)`);
 
   try {
-    const [providerURL, userId = '', signature = ''] = provider.provider.split(',');
-    console.log(`Starting requester for ${providerURL}`);
     // Wait for provider to become available
     await waitForProvider(providerURL, RETRY_INTERVAL_SECONDS);
 

src/requester/RouteRegistrar.ts

@@ -85,10 +85,35 @@ export async function registerTunnelRoute(
 
         const url = `${backendUrl}/router/api/routes/${encodeURIComponent(userId)}/${encodeURIComponent(signature)}`;
         const jsonData = JSON.stringify({ routes: [route] }).replace(/"/g, '\\"');
-        const curlCommand = `curl -s -X POST -H "Content-Type: application/json" -d "${jsonData}" "${url}"`;
+        const curlCommand = `curl -s -w "\\n%{http_code}" -X POST -H "Content-Type: application/json" -d "${jsonData}" "${url}"`;
 
         const { stdout } = await exec(curlCommand);
-        const response = JSON.parse(stdout);
+
+        // Parse response and HTTP status code
+        const lines = stdout.trim().split('\n');
+        const httpCode = parseInt(lines.pop() || '0', 10);
+        const body = lines.join('\n');
+
+        // Check for HTTP errors
+        if (httpCode >= 400 || httpCode === 0) {
+            return {
+                success: false,
+                message: 'Route registration failed',
+                error: `HTTP ${httpCode}: Server returned an error (endpoint may not exist on this backend version)`,
+            };
+        }
+
+        // Parse JSON response
+        let response;
+        try {
+            response = JSON.parse(body);
+        } catch {
+            return {
+                success: false,
+                message: 'Route registration failed',
+                error: `Invalid JSON response from server (backend may not support routes API)`,
+            };
+        }
 
         if (response.error) {
             return {