freertc 0.1.17 → 0.1.18

package/README.md

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

package/bin/freertc.mjs

@@ -102,6 +102,11 @@ function extractRouteHost(configText) {
   return normalizeHost(pattern.split('/')[0]);
 }
 
+function extractCurrentWorkerName(configText) {
+  const match = configText.match(/"name"\s*:\s*"([^"]+)"/);
+  return match?.[1] || null;
+}
+
 function extractRelayUrlHost(configText) {
   const relayUrlMatch = configText.match(/"RELAY_URL"\s*:\s*"([^"]*)"/);
   if (!relayUrlMatch) return null;
@@ -201,6 +206,131 @@ function patchWranglerScriptName(configPath, workerName) {
   return true;
 }
 
+function getApiToken() {
+  return process.env.CLOUDFLARE_API_TOKEN || process.env.CF_API_TOKEN || '';
+}
+
+function getAccountId() {
+  return process.env.CLOUDFLARE_ACCOUNT_ID || process.env.CF_ACCOUNT_ID || '';
+}
+
+function guessZoneCandidates(host) {
+  const normalized = normalizeHost(host);
+  if (!normalized) return [];
+  const parts = normalized.split('.');
+  const candidates = [];
+  for (let i = 0; i <= Math.max(0, parts.length - 2); i += 1) {
+    candidates.push(parts.slice(i).join('.'));
+  }
+  return Array.from(new Set(candidates));
+}
+
+function routePatternMatchesHost(pattern, host) {
+  const normalizedHost = normalizeHost(host);
+  if (!pattern || !normalizedHost) return false;
+  const rawHost = normalizeHost(String(pattern).split('/')[0]);
+  if (!rawHost) return false;
+  if (rawHost === normalizedHost) return true;
+  if (rawHost.startsWith('*.')) {
+    const suffix = rawHost.slice(2);
+    return normalizedHost === suffix || normalizedHost.endsWith(`.${suffix}`);
+  }
+  return false;
+}
+
+async function apiGetJson(url, token) {
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json'
+    }
+  });
+  if (!response.ok) {
+    return null;
+  }
+
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    return null;
+  }
+
+  if (!payload?.success) {
+    return null;
+  }
+
+  return payload.result;
+}
+
+async function resolveZoneIdForHost(host, token) {
+  const candidates = guessZoneCandidates(host);
+  for (const candidate of candidates) {
+    const result = await apiGetJson(`https://api.cloudflare.com/client/v4/zones?name=${encodeURIComponent(candidate)}`, token);
+    if (Array.isArray(result) && result.length > 0 && result[0]?.id) {
+      return result[0].id;
+    }
+  }
+  return null;
+}
+
+async function findRouteOwnerForHost(host) {
+  const token = getApiToken();
+  const accountId = getAccountId();
+  if (!token || !accountId) {
+    return null;
+  }
+
+  const zoneId = await resolveZoneIdForHost(host, token);
+  if (!zoneId) {
+    return null;
+  }
+
+  const routes = await apiGetJson(`https://api.cloudflare.com/client/v4/zones/${zoneId}/workers/routes`, token);
+  if (!Array.isArray(routes)) {
+    return null;
+  }
+
+  // Prefer exact host matches over wildcard matches.
+  const exact = routes.find((route) => {
+    const patternHost = normalizeHost(String(route?.pattern || '').split('/')[0]);
+    const scriptName = route?.script || route?.script_name;
+    return patternHost === normalizeHost(host) && typeof scriptName === 'string' && scriptName.trim();
+  });
+  if (exact?.script || exact?.script_name) {
+    return exact.script || exact.script_name;
+  }
+
+  const wildcard = routes.find((route) => {
+    const scriptName = route?.script || route?.script_name;
+    return routePatternMatchesHost(route?.pattern, host) && typeof scriptName === 'string' && scriptName.trim();
+  });
+  return wildcard ? (wildcard.script || wildcard.script_name) : null;
+}
+
+async function maybeAlignWorkerNameToRouteOwner(configPath) {
+  const text = fs.readFileSync(configPath, 'utf8');
+  const host = extractRouteHost(text) || extractRelayUrlHost(text) || extractDatabaseDomainHost(text);
+  if (!host) {
+    return;
+  }
+
+  const routeOwner = await findRouteOwnerForHost(host);
+  if (!routeOwner) {
+    return;
+  }
+
+  const currentName = extractCurrentWorkerName(text);
+  if (!currentName || currentName === routeOwner) {
+    return;
+  }
+
+  const patched = patchWranglerScriptName(configPath, routeOwner);
+  if (patched) {
+    console.log(`Detected route owner worker "${routeOwner}" for ${host}. Auto-updated wrangler.jsonc name before deploy.`);
+  }
+}
+
 function runDeployWithAutoRouteRecovery(wrangler, configPath, extraArgs = []) {
   const attemptedOwners = new Set();
 
@@ -363,6 +493,7 @@ async function main() {
     ensureProjectFiles(PROJECT_ROOT);
     const configPath = requireWranglerConfig();
     autoPatchWranglerConfig(configPath);
+    await maybeAlignWorkerNameToRouteOwner(configPath);
     validateWranglerConfigForDeploy(configPath);
     const wrangler = resolveWranglerCommand(PROJECT_ROOT);
     runDeployWithAutoRouteRecovery(wrangler, configPath, rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freertc",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "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.17';
+const WORKER_VERSION = '0.1.18';
 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.17";
+const WORKER_VERSION = "0.1.18";
 
 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"]);