vibelet 1.0.0 → 1.0.2

package/bin/vibelet.mjs

@@ -586,6 +586,7 @@ async function stopRunningDaemon(backend) {
 }
 
 function createCompactPairingPayload(pairingPayload) {
+  const connections = normalizePairingConnections(pairingPayload);
   const compactPayload = {
     t: 'vp',
     d: pairingPayload.daemonId,
@@ -596,9 +597,170 @@ function createCompactPairingPayload(pairingPayload) {
     e: pairingPayload.expiresAt,
   };
   if (pairingPayload.fallbackHosts) compactPayload.f = pairingPayload.fallbackHosts;
+  if (connections.length > 0) {
+    compactPayload.o = connections.map((target) => [
+      target.kind,
+      target.host,
+      target.port,
+      target.source,
+      target.stability,
+    ]);
+  }
   return compactPayload;
 }
 
+function normalizeHostValue(host) {
+  if (typeof host !== 'string') {
+    return '';
+  }
+  return host.trim().replace(/\.$/, '').toLowerCase();
+}
+
+function isIpv4Host(host) {
+  const parts = host.split('.');
+  return parts.length === 4 && parts.every((part) => /^\d+$/.test(part) && Number(part) >= 0 && Number(part) <= 255);
+}
+
+function isTailscaleHost(host) {
+  if (host.endsWith('.ts.net')) {
+    return true;
+  }
+  if (!isIpv4Host(host)) {
+    return false;
+  }
+  const [first, second] = host.split('.').map(Number);
+  return first === 100 && second >= 64 && second <= 127;
+}
+
+function isLocalNetworkHost(host) {
+  if (host.endsWith('.local')) {
+    return true;
+  }
+  if (!isIpv4Host(host)) {
+    return false;
+  }
+  const [first, second] = host.split('.').map(Number);
+  return first === 10
+    || (first === 172 && second >= 16 && second <= 31)
+    || (first === 192 && second === 168);
+}
+
+function isQuickTunnelHost(host) {
+  return host.endsWith('.trycloudflare.com');
+}
+
+function buildLegacyConnection(host, port, isPrimary) {
+  if (isQuickTunnelHost(host)) {
+    return {
+      kind: 'relay',
+      host,
+      port,
+      source: 'quick_tunnel',
+      stability: 'ephemeral',
+    };
+  }
+  if (isTailscaleHost(host)) {
+    return {
+      kind: 'direct',
+      host,
+      port,
+      source: 'tailscale',
+      stability: 'stable',
+    };
+  }
+  if (isLocalNetworkHost(host)) {
+    return {
+      kind: 'direct',
+      host,
+      port,
+      source: 'local_network',
+      stability: 'stable',
+    };
+  }
+  return {
+    kind: 'direct',
+    host,
+    port,
+    source: isPrimary ? 'configured_host' : 'fallback',
+    stability: 'stable',
+  };
+}
+
+function normalizePairingConnections(pairingPayload) {
+  const explicitConnections = Array.isArray(pairingPayload.connections)
+    ? pairingPayload.connections
+      .filter((target) => (
+        target
+        && typeof target.host === 'string'
+        && Number.isFinite(target.port)
+        && typeof target.source === 'string'
+        && typeof target.stability === 'string'
+      ))
+      .map((target) => ({
+        kind: target.kind === 'relay' ? 'relay' : 'direct',
+        host: normalizeHostValue(target.host),
+        port: Math.floor(Number(target.port)),
+        source: target.source,
+        stability: target.stability,
+      }))
+      .filter((target) => target.host && target.port > 0)
+    : [];
+
+  const dedupe = (targets) => {
+    const seen = new Set();
+    return targets.filter((target) => {
+      const key = `${target.host}:${target.port}`;
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  };
+
+  if (explicitConnections.length > 0) {
+    return dedupe(explicitConnections);
+  }
+
+  const canonicalHost = normalizeHostValue(pairingPayload.canonicalHost) || 'localhost';
+  const port = Number.isFinite(pairingPayload.port) && pairingPayload.port > 0
+    ? Math.floor(Number(pairingPayload.port))
+    : 9876;
+  const fallbackHosts = Array.isArray(pairingPayload.fallbackHosts)
+    ? pairingPayload.fallbackHosts
+      .map((host) => normalizeHostValue(host))
+      .filter((host) => host && host !== canonicalHost)
+    : [];
+
+  return dedupe([
+    buildLegacyConnection(canonicalHost, port, true),
+    ...fallbackHosts.map((host) => buildLegacyConnection(host, port, false)),
+  ]);
+}
+
+function formatConnectionSourceLabel(source) {
+  switch (source) {
+    case 'configured_relay':
+      return 'Custom Relay';
+    case 'quick_tunnel':
+      return 'Quick Tunnel';
+    case 'configured_host':
+      return 'Manual Host';
+    case 'tailscale':
+      return 'Tailscale';
+    case 'local_network':
+      return 'LAN';
+    case 'fallback':
+    default:
+      return 'Fallback';
+  }
+}
+
+function formatConnectionSummary(target) {
+  const stabilityLabel = target.stability === 'ephemeral' ? 'ephemeral' : 'stable';
+  return `${target.host}:${target.port} [${formatConnectionSourceLabel(target.source)}, ${stabilityLabel}]`;
+}
+
 async function printPairingQr(pairingPayload) {
   const payload = JSON.stringify(createCompactPairingPayload(pairingPayload));
   mkdirSync(vibeletDir, { recursive: true });
@@ -622,12 +784,23 @@ async function printPairingQr(pairingPayload) {
 async function printPairingSummary(existingHealth = null) {
   const health = existingHealth ?? await waitForHealth();
   const pairingPayload = await postJson('/pair/open');
+  const connections = normalizePairingConnections(pairingPayload);
+  const [preferredConnection, ...otherConnections] = connections;
 
   process.stdout.write(`Vibelet daemon is ready.\n\n`);
   process.stdout.write(`Device: ${health.displayName}\n`);
   process.stdout.write(`Daemon ID: ${health.daemonId}\n`);
   process.stdout.write(`Host: ${pairingPayload.canonicalHost}\n`);
   process.stdout.write(`Port: ${pairingPayload.port}\n`);
+  if (preferredConnection) {
+    process.stdout.write(`Preferred path: ${formatConnectionSummary(preferredConnection)}\n`);
+  }
+  if (otherConnections.length > 0) {
+    process.stdout.write(`Other paths:\n`);
+    otherConnections.forEach((target) => {
+      process.stdout.write(`  - ${formatConnectionSummary(target)}\n`);
+    });
+  }
   process.stdout.write(`Paired devices: ${health.pairedDevices}\n`);
   await printPairingQr(pairingPayload);
 }