@kortix/agent-tunnel 0.13.54 → 0.13.55

package/dist/agent-cli.js

@@ -4036,6 +4036,10 @@ function verifyMessageSignature(signingKey, payload, nonce, signature) {
 
 // src/agent/agent.ts
 var AGENT_VERSION = agentTunnelVersion();
+function openRelaySocket(url) {
+  const RelaySocket = WebSocket;
+  return new RelaySocket(url, { headers: { "User-Agent": `kortix-agent-tunnel/${AGENT_VERSION}` } });
+}
 var AUTH_REJECTED_CLOSE_CODES = [4001, 4003];
 var RELAY_FAULT_4001_REASONS = new Set(["auth timeout", "authentication error", "authentication response failed"]);
 function isCredentialRejection(code, reason = "") {
@@ -4137,7 +4141,7 @@ class TunnelAgent {
     this.connectStartedAt = this.now();
     this.setStatus("connecting");
     try {
-      this.ws = new WebSocket(new URL(wsUrl));
+      this.ws = openRelaySocket(new URL(wsUrl).href);
       this.setupWsHandlers();
     } catch (err) {
       log(`${c.red}✗${c.reset}`, `Connection failed`);
@@ -5677,17 +5681,17 @@ function probeCredentials(config, options = {}) {
   return new Promise((resolve3) => {
     let socket;
     try {
-      socket = new WebSocket(new URL(buildTunnelWsUrl(config)));
+      socket = openRelaySocket(new URL(buildTunnelWsUrl(config)).href);
     } catch {
       resolve3("unreachable");
       return;
     }
     const settle = (result) => {
       clearTimeout(timer);
+      resolve3(result);
       try {
         socket.close(1000, "probe complete");
       } catch {}
-      resolve3(result);
     };
     const timer = setTimeout(() => settle("unreachable"), options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);
     socket.addEventListener("open", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kortix/agent-tunnel",
-  "version": "0.13.54",
+  "version": "0.13.55",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kortix-ai/suna.git",

package/src/agent/agent.ts

@@ -32,6 +32,16 @@ import { signMessage, verifyMessageSignature } from '../shared/crypto';
 
 export const AGENT_VERSION = agentTunnelVersion();
 
+/**
+ * Opens a socket to the relay. It names the agent: Bun sends no User-Agent,
+ * and Cloudflare answers an upgrade without one with 403. Bun, Node 22 and
+ * `ws` all take `{ headers }` as the second argument.
+ */
+export function openRelaySocket(url: string): WebSocket {
+  const RelaySocket = WebSocket as unknown as new (url: string, init: { headers: Record<string, string> }) => WebSocket;
+  return new RelaySocket(url, { headers: { 'User-Agent': `kortix-agent-tunnel/${AGENT_VERSION}` } });
+}
+
 /**
  * Relay close codes that mean the credential itself is bad. They are terminal:
  * reconnecting with the same token can never succeed.
@@ -232,7 +242,7 @@ export class TunnelAgent {
 
     try {
       // lgtm[js/file-access-to-http] Tunnel endpoint is intentionally loaded from trusted local config.
-      this.ws = new WebSocket(new URL(wsUrl));
+      this.ws = openRelaySocket(new URL(wsUrl).href);
       this.setupWsHandlers();
     } catch (err) {
       log(`${c.red}✗${c.reset}`, `Connection failed`);

package/src/agent/credential-probe.ts

@@ -1,5 +1,5 @@
 import '../node-ws-polyfill';
-import { AGENT_REPLACED_CLOSE_CODE, AGENT_VERSION, isCredentialRejection } from './agent';
+import { AGENT_REPLACED_CLOSE_CODE, AGENT_VERSION, isCredentialRejection, openRelaySocket } from './agent';
 import { buildTunnelWsUrl, trustedCredential, type TunnelConfig } from './config';
 
 /**
@@ -36,18 +36,18 @@ export function probeCredentials(
   return new Promise<CredentialProbeResult>((resolve) => {
     let socket: WebSocket;
     try {
-      socket = new WebSocket(new URL(buildTunnelWsUrl(config)));
+      socket = openRelaySocket(new URL(buildTunnelWsUrl(config)).href);
     } catch {
       resolve('unreachable');
       return;
     }
 
     // resolve() is idempotent, so the first verdict wins and later events are
-    // harmless no-ops. That removes any need to track settled state by hand.
+    // harmless no-ops. Resolve before close(): Bun fires 'close' inside it.
     const settle = (result: CredentialProbeResult): void => {
       clearTimeout(timer);
-      try { socket.close(1000, 'probe complete'); } catch {}
       resolve(result);
+      try { socket.close(1000, 'probe complete'); } catch {}
     };
 
     const timer = setTimeout(() => settle('unreachable'), options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS);

package/src/agent/service-lifecycle.test.ts

@@ -13,6 +13,7 @@ import {
   rotateServiceLogs,
 } from './service';
 import { collapseRepeatedLines } from './log-format';
+import { AGENT_VERSION } from './agent';
 import { probeCredentials } from './credential-probe';
 
 const CLI_PATH = resolve(import.meta.dir, 'cli.ts');
@@ -104,6 +105,51 @@ describe('service log hygiene', () => {
 });
 
 describe('credential probe and the single-agent rule', () => {
+  test('every relay socket opens through openRelaySocket', () => {
+    const src = resolve(import.meta.dir, '..');
+    const raw: string[] = [];
+    for (const file of new Bun.Glob('**/*.ts').scanSync(src)) {
+      if (file.endsWith('.test.ts')) continue;
+      readFileSync(join(src, file), 'utf8').split('\n').forEach((line, i) => {
+        if (/\bnew WebSocket\(/.test(line) && !/^\s*(\/\/|\*)/.test(line)) raw.push(`${file}:${i + 1}`);
+      });
+    }
+    expect(raw).toEqual([]);
+  });
+
+  test('auth_ok is valid, though Bun fires close inside socket.close()', async () => {
+    let userAgent: string | null = null as string | null;
+    const server = Bun.serve({
+      port: 0,
+      fetch(request, server) {
+        // Cloudflare refuses an upgrade without a User-Agent, and Bun sends none by default.
+        userAgent = request.headers.get('user-agent');
+        return server.upgrade(request) ? undefined : new Response('no upgrade', { status: 400 });
+      },
+      websocket: {
+        message(ws) {
+          ws.send(JSON.stringify({ type: 'auth_ok' }));
+        },
+      },
+    });
+
+    try {
+      const result = await probeCredentials(
+        {
+          apiUrl: `http://127.0.0.1:${server.port}/v1/tunnel`,
+          tunnelId: '00000000-0000-4000-8000-000000000001',
+          token: 'kortix_tnl_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+          wsPath: '/ws',
+        } as never,
+        { timeoutMs: 5_000 },
+      );
+      expect(result).toBe('valid');
+      expect(userAgent).toBe(`kortix-agent-tunnel/${AGENT_VERSION}`);
+    } finally {
+      server.stop(true);
+    }
+  }, 30_000);
+
   test('treats being replaced as proof the credential is valid', async () => {
     // The relay only replaces a socket it already registered, and registration
     // happens after a successful handshake.