freertc 0.1.23 → 0.1.31

package/README.md

@@ -216,7 +216,7 @@ Quick checks:
 Expected `/health` response includes JSON like:
 
 ```json
-{"ok":true,"version":"0.1.23","protocol_version":"1.0","peers":0}
+{"ok":true,"version":"0.1.31","protocol_version":"1.0","peers":0}
 ```
 
 ## Auto WebRTC two-tab test

package/bin/freertc.mjs

@@ -76,6 +76,11 @@ function normalizeHost(value) {
   return host || null;
 }
 
+function isPlaceholderHost(host) {
+  if (!host || typeof host !== 'string') return false;
+  return /your-domain\.example|your[-_]?domain/i.test(host);
+}
+
 function sanitizeDomain(domain) {
   if (!domain || typeof domain !== 'string') return null;
   return domain
@@ -95,11 +100,46 @@ function patchJsoncVar(text, varName, value) {
   return text;
 }
 
+function ensureRoutesForHost(configText, host) {
+  const normalizedHost = normalizeHost(host);
+  if (!normalizedHost || isPlaceholderHost(normalizedHost)) {
+    return configText;
+  }
+
+  const pattern = `${normalizedHost}/*`;
+  let text = configText;
+
+  if (/^\s*"routes"\s*:\s*\[/m.test(text)) {
+    text = text.replace(/^(\s*"pattern"\s*:\s*")([^"]*)(")/m, `$1${pattern}$3`);
+    if (/^\s*"zone_name"\s*:\s*"[^"]*"/m.test(text)) {
+      text = text.replace(/^(\s*"zone_name"\s*:\s*")([^"]*)(")/m, `$1${normalizedHost}$3`);
+    }
+    return text;
+  }
+
+  const routesBlock = [
+    '  "routes": [',
+    '    {',
+    `      "pattern": "${pattern}",`,
+    `      "zone_name": "${normalizedHost}"`,
+    '    }',
+    '  ]'
+  ].join('\n');
+
+  if (/\n\s*"env"\s*:\s*\{/.test(text)) {
+    return text.replace(/\n\s*"env"\s*:\s*\{/, `\n${routesBlock},\n\n  "env": {`);
+  }
+
+  return text.replace(/\n}\s*$/, `\n${routesBlock}\n}`);
+}
+
 function extractRouteHost(configText) {
-  const routeMatch = configText.match(/"pattern"\s*:\s*"([^"]+)"/);
+  const routeMatch = configText.match(/^\s*"pattern"\s*:\s*"([^"]+)"/m);
   if (!routeMatch) return null;
   const pattern = routeMatch[1];
-  return normalizeHost(pattern.split('/')[0]);
+  const host = normalizeHost(pattern.split('/')[0]);
+  if (!host || isPlaceholderHost(host)) return null;
+  return host;
 }
 
 function extractCurrentWorkerName(configText) {
@@ -109,15 +149,24 @@ function extractCurrentWorkerName(configText) {
 
 function extractDeployHost(configPath) {
   const text = fs.readFileSync(configPath, 'utf8');
-  return extractRouteHost(text) || extractRelayUrlHost(text) || extractDatabaseDomainHost(text);
+  return extractRouteHost(text) || extractDatabaseDomainHost(text) || extractRelayUrlHost(text) || extractGlobalRelayUrlHost(text);
+}
+
+function extractGlobalRelayUrlHost(configText) {
+  const match = configText.match(/"GLOBAL_RELAY_URL"\s*:\s*"([^"]*)"/);
+  if (!match) return null;
+  const host = normalizeHost(match[1]);
+  if (!host || isPlaceholderHost(host)) return null;
+  return host;
 }
 
 function extractRelayUrlHost(configText) {
   const relayUrlMatch = configText.match(/"RELAY_URL"\s*:\s*"([^"]*)"/);
   if (!relayUrlMatch) return null;
   const raw = relayUrlMatch[1];
-  if (/your-domain\.example|your[-_]?domain/i.test(raw)) return null;
-  return normalizeHost(raw);
+  const host = normalizeHost(raw);
+  if (!host || isPlaceholderHost(host)) return null;
+  return host;
 }
 
 function extractDatabaseDomainHost(configText) {
@@ -134,22 +183,30 @@ function extractDatabaseDomainHost(configText) {
 function autoPatchWranglerConfig(configPath) {
   let text = fs.readFileSync(configPath, 'utf8');
 
+  const dbDomainHost = extractDatabaseDomainHost(text);
   const routeHost = extractRouteHost(text);
-  const envDomainHost = normalizeHost(process.env.CF_DOMAIN || process.env.CLOUD_FLARE_DOMAIN || '');
-  const relayHost = routeHost || envDomainHost || extractRelayUrlHost(text) || extractDatabaseDomainHost(text);
-
-  if (!relayHost) {
+  const relayUrlHost = extractRelayUrlHost(text);
+  const globalRelayHost = extractGlobalRelayUrlHost(text);
+  const publicHost = dbDomainHost || routeHost || relayUrlHost || globalRelayHost;
+  const envDomainCandidate = normalizeHost(process.env.CF_DOMAIN || process.env.CLOUD_FLARE_DOMAIN || '');
+  const envDomainHost = envDomainCandidate && !isPlaceholderHost(envDomainCandidate) ? envDomainCandidate : null;
+  const baseRelayDomain = dbDomainHost || routeHost || envDomainHost || relayUrlHost || globalRelayHost;
+
+  if (!baseRelayDomain) {
     return;
   }
 
+  const relayHost = baseRelayDomain;
+
   const relayWsUrl = `wss://${relayHost}/ws`;
   const relayName = relayHost;
-  const dbName = `freertc-signal-${sanitizeDomain(relayHost)}`;
+  const dbName = `freertc-signal-${sanitizeDomain(dbDomainHost || baseRelayDomain)}`;
 
   const before = text;
   text = patchJsoncVar(text, 'RELAY_URL', relayWsUrl);
   text = patchJsoncVar(text, 'RELAY_NAME', relayName);
   text = text.replace(/("database_name"\s*:\s*)"freertc-signal(?:-your[-_]?domain)?"/gi, `$1"${dbName}"`);
+  text = ensureRoutesForHost(text, publicHost || relayHost);
 
   if (text !== before) {
     fs.writeFileSync(configPath, text, 'utf8');
@@ -198,8 +255,11 @@ function validateWranglerConfigForDeploy(configPath) {
 
 function extractRouteConflictOwner(outputText) {
   if (!outputText) return null;
-  const match = outputText.match(/used by Worker:\s*([A-Za-z0-9._-]+)/i);
-  return match?.[1] || null;
+  const usedByMatch = outputText.match(/used by Worker:\s*([A-Za-z0-9._-]+)/i);
+  if (usedByMatch?.[1]) return usedByMatch[1];
+
+  const assignedMatch = outputText.match(/"([A-Za-z0-9._-]+)"\s+is already assigned to routes:/i);
+  return assignedMatch?.[1] || null;
 }
 
 function patchWranglerScriptName(configPath, workerName) {
@@ -268,6 +328,31 @@ async function apiGetJson(url, token) {
   return payload.result;
 }
 
+async function apiMutateJson(url, token, method, body) {
+  const response = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(body)
+  });
+
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    return null;
+  }
+
+  if (!response.ok || !payload?.success) {
+    return null;
+  }
+
+  return payload.result || {};
+}
+
 async function resolveZoneIdForHost(host, token) {
   const candidates = guessZoneCandidates(host);
   for (const candidate of candidates) {
@@ -313,6 +398,52 @@ async function findRouteOwnerForHost(host) {
   return wildcard ? (wildcard.script || wildcard.script_name) : null;
 }
 
+async function forceRouteBindingToWorker(host, workerName) {
+  const normalizedHost = normalizeHost(host);
+  const normalizedWorker = typeof workerName === 'string' ? workerName.trim() : '';
+  const token = getApiToken();
+  if (!normalizedHost || !normalizedWorker || !token) {
+    return false;
+  }
+
+  const zoneId = await resolveZoneIdForHost(normalizedHost, token);
+  if (!zoneId) {
+    return false;
+  }
+
+  const routes = await apiGetJson(`https://api.cloudflare.com/client/v4/zones/${zoneId}/workers/routes`, token);
+  if (!Array.isArray(routes)) {
+    return false;
+  }
+
+  const exactPattern = `${normalizedHost}/*`;
+  const matchingRoute = routes.find((route) => String(route?.pattern || '') === exactPattern)
+    || routes.find((route) => routePatternMatchesHost(route?.pattern, normalizedHost));
+
+  if (matchingRoute?.id) {
+    const currentScript = matchingRoute.script || matchingRoute.script_name || '';
+    if (currentScript === normalizedWorker) {
+      return false;
+    }
+
+    const updated = await apiMutateJson(
+      `https://api.cloudflare.com/client/v4/zones/${zoneId}/workers/routes/${matchingRoute.id}`,
+      token,
+      'PUT',
+      { pattern: matchingRoute.pattern || exactPattern, script: normalizedWorker }
+    );
+    return Boolean(updated);
+  }
+
+  const created = await apiMutateJson(
+    `https://api.cloudflare.com/client/v4/zones/${zoneId}/workers/routes`,
+    token,
+    'POST',
+    { pattern: exactPattern, script: normalizedWorker }
+  );
+  return Boolean(created);
+}
+
 async function maybeAlignWorkerNameToRouteOwner(configPath) {
   const text = fs.readFileSync(configPath, 'utf8');
   const host = extractRouteHost(text) || extractRelayUrlHost(text) || extractDatabaseDomainHost(text);
@@ -552,6 +683,19 @@ async function main() {
       }
     }
 
+    const finalText = fs.readFileSync(configPath, 'utf8');
+    const finalWorkerName = extractCurrentWorkerName(finalText);
+    if (finalWorkerName) {
+      const rebound = await forceRouteBindingToWorker(deployHost, finalWorkerName);
+      if (rebound) {
+        console.log(`Live health still stale on ${deployHost}. Rebound Cloudflare route to worker "${finalWorkerName}" and rechecking health.`);
+        liveVersion = await fetchLiveHealthVersion(deployHost);
+        if (liveVersion && compareVersions(liveVersion, CLI_VERSION) >= 0) {
+          process.exit(0);
+        }
+      }
+    }
+
     console.error(`Deploy completed but live health on https://${deployHost}/health is still stale (version=${liveVersion || 'unknown'}, expected>=${CLI_VERSION}).`);
     console.error('Refusing silent success. Please rerun deploy after Cloudflare route cache settles.');
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freertc",
-  "version": "0.1.23",
+  "version": "0.1.31",
   "description": "Cloudflare Worker signaling relay for WebRTC peers with D1 storage.",
   "keywords": [
     "webrtc",

package/scripts/non-cloudflare-server.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { WebSocketServer } from 'ws';
 
 const PSP_VERSION = '1.0';
-const WORKER_VERSION = '0.1.23';
+const WORKER_VERSION = '0.1.31';
 const DEFAULT_TTL_MS = 30_000;
 const MAX_TTL_MS = 120_000;
 const MAX_MESSAGE_SIZE = 64 * 1024;

package/src/index.js

@@ -1,5 +1,5 @@
 const PSP_VERSION = "1.0";
-const WORKER_VERSION = "0.1.23";
+const WORKER_VERSION = "0.1.31";
 
 const DISCOVERY_TYPES = new Set(["announce", "withdraw", "discover", "peer_list", "redirect"]);
 const NEGOTIATION_TYPES = new Set(["connect_request", "connect_accept", "connect_reject", "offer", "answer", "ice_candidate", "ice_end", "renegotiate"]);