@kortix/agent-tunnel 0.14.8 → 0.14.9

package/dist/agent-cli.js

@@ -3478,6 +3478,20 @@ import { randomUUID } from "crypto";
 import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { platform } from "os";
 import { isAbsolute, join as join3 } from "path";
+
+// src/agent/process-liveness.ts
+function isAlive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+// src/agent/access.ts
 var ACCESS_HOLD_MS = 20000;
 var DESKTOP_APP_HEARTBEAT_MS = 30000;
 var MAX_GRANT_MS = 24 * 3600000;
@@ -3651,16 +3665,6 @@ function clearAccessRequest(id, home = agentTunnelHome()) {
   if (readAccessRequest(home)?.id === id)
     rmSync(accessRequestPath(home), { force: true });
 }
-function isAlive(pid) {
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function wakeDesktopApp(home = agentTunnelHome(), now = Date.now()) {
   let app;
   let touchedAt = 0;
@@ -3899,7 +3903,7 @@ function openBrowser(url) {
   };
   const [command, args] = opener[platform2()] ?? ["xdg-open", [safeUrl]];
   try {
-    spawn2(command, args, { detached: true, stdio: "ignore" }).unref();
+    spawn2(command, args, { detached: true, stdio: "ignore" }).on("error", () => {}).unref();
   } catch {}
 }
 
@@ -6369,22 +6373,12 @@ function writeAgentState(status, tunnel, home = agentTunnelHome()) {
     renameSync3(tmp, stateFilePath(home));
   } catch {}
 }
-function isAlive2(pid) {
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function readAgentState(home = agentTunnelHome()) {
   try {
     const parsed = JSON.parse(readFileSync10(stateFilePath(home), "utf8"));
     if (!parsed || typeof parsed !== "object" || typeof parsed.status !== "string")
       return null;
-    return parsed.status !== "offline" && !isAlive2(parsed.pid) ? { ...parsed, status: "offline" } : parsed;
+    return parsed.status !== "offline" && !isAlive(parsed.pid) ? { ...parsed, status: "offline" } : parsed;
   } catch {
     return null;
   }

package/package.json

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

package/src/agent/access.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from 'bun:test';
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
 import { mkdtempSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -272,3 +272,29 @@ describe('access after pairing', () => {
     expect(accessAfterPairing(tempHome(), false).mode).toBe('always');
   });
 });
+
+// Characterize the PID probe through the desktop observer, without launching an app.
+describe('desktop PID liveness', () => {
+  test.each([null, '1', 0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1])('rejects invalid PID %p without probing', (pid) => {
+    const home = tempHome();
+    writeFileSync(join(home, 'desktop-app.json'), JSON.stringify({ pid }));
+    const kill = spyOn(process, 'kill');
+    try {
+      expect(wakeDesktopApp(home)).toBe('no-app');
+      expect(kill).not.toHaveBeenCalled();
+    } finally { kill.mockRestore(); }
+  });
+
+  test.each(['live', 'ESRCH', 'EPERM'])('handles %s', (result) => {
+    const home = tempHome();
+    writeFileSync(join(home, 'desktop-app.json'), JSON.stringify({ pid: process.pid }));
+    const kill = spyOn(process, 'kill').mockImplementation(() => {
+      if (result !== 'live') throw Object.assign(new Error(result), { code: result });
+      return true;
+    });
+    try {
+      expect(wakeDesktopApp(home)).toBe(result === 'ESRCH' ? 'no-app' : 'running');
+      expect(kill).toHaveBeenCalledWith(process.pid, 0);
+    } finally { kill.mockRestore(); }
+  });
+});

package/src/agent/access.ts

@@ -4,6 +4,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, sta
 import { platform } from 'os';
 import { isAbsolute, join } from 'path';
 
+import { isAlive } from './process-liveness';
 import { agentTunnelHome } from './service-paths';
 
 /**
@@ -271,16 +272,6 @@ export function clearAccessRequest(id: string, home = agentTunnelHome()): void {
   if (readAccessRequest(home)?.id === id) rmSync(accessRequestPath(home), { force: true });
 }
 
-function isAlive(pid: unknown): boolean {
-  if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === 'EPERM';
-  }
-}
-
 /**
  * Starts the desktop app so it can show the access prompt. The app records how
  * to launch it in `desktop-app.json` at startup and touches the file while it

package/src/agent/cli-device-auth.test.ts

@@ -31,6 +31,50 @@ async function waitForFile(path: string, timeoutMs = 5_000): Promise<void> {
 }
 
 describe('agent tunnel device authorization CLI', () => {
+  test('Node pairing keeps the approval URL and polls when the browser cannot start', async () => {
+    const home = await mkdtemp(join(tmpdir(), 'agent-tunnel-node-home-'));
+    temporaryHomes.add(home);
+    const bundle = join(home, 'cli.mjs');
+    const build = await Bun.build({ entrypoints: [CLI_PATH], target: 'node' });
+    expect(build.success).toBe(true);
+    await Bun.write(bundle, await build.outputs[0].text());
+    let polls = 0;
+    const verificationUrl = 'https://example.invalid/tunnel/authorize/TEST-0004';
+    const server = Bun.serve({
+      port: 0,
+      fetch(request) {
+        if (request.method === 'POST') {
+          return Response.json({
+            deviceCode: 'TEST-0004', deviceSecret: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456',
+            verificationUrl, expiresAt: new Date(Date.now() + 60_000).toISOString(),
+            pollIntervalMs: 250,
+          });
+        }
+        polls++;
+        return Response.json({ status: polls === 1 ? 'pending' : 'denied' });
+      },
+    });
+    try {
+      const child = Bun.spawn([
+        Bun.which('node') ?? '/usr/local/bin/node', bundle, 'connect', '--foreground',
+        '--api-url', `http://127.0.0.1:${server.port}/v1/tunnel`,
+      ], {
+        env: { ...process.env, HOME: home, AGENT_TUNNEL_HOME: join(home, 'agent'),
+          PATH: home, KORTIX_AGENT_TUNNEL_NO_BROWSER: '0' },
+        stdout: 'pipe', stderr: 'pipe',
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+      ]);
+      expect(stdout).toContain(verificationUrl);
+      expect(stderr).toContain('Authorization denied.');
+      expect(stderr).not.toContain('Unhandled');
+      expect(polls).toBe(2);
+      expect(exitCode).toBe(1);
+    } finally {
+      server.stop(true);
+    }
+  });
   test('persists the exact browser-approved capability list as the local ceiling', async () => {
     const approvedCapabilities = ['desktop', 'filesystem'];
     const server = Bun.serve({

package/src/agent/device-auth.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, test } from 'bun:test';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import {
   InvalidDeviceAuthResponseError,
   awaitDeviceAuthorization,
@@ -9,6 +12,50 @@ import {
   requestDeviceAuthorization,
 } from './device-auth';
 
+describe('browser opener on Node', () => {
+  test.each([
+    ['missing opener', 'https://example.invalid/approve', '0'],
+    ['invalid URL', 'not a URL', '0'],
+    ['unsafe scheme', 'javascript:alert(1)', '0'],
+    ['browser disabled', 'https://example.invalid/approve', '1'],
+  ])('%s does not terminate authorization polling', async (_name, url, disabled) => {
+    const directory = await mkdtemp(join(tmpdir(), 'device-browser-'));
+    try {
+      const bundle = join(directory, 'device-auth.mjs');
+      const build = await Bun.build({
+        entrypoints: [join(import.meta.dir, 'device-auth.ts')],
+        target: 'node',
+      });
+      expect(build.success).toBe(true);
+      await Bun.write(bundle, await build.outputs[0].text());
+      const child = Bun.spawn([Bun.which('node') ?? '/usr/local/bin/node', '--input-type=module', '-e', `
+        import { openBrowser, awaitDeviceAuthorization } from ${JSON.stringify(bundle)};
+        openBrowser(${JSON.stringify(url)});
+        await awaitDeviceAuthorization('http://127.0.0.1:1', {
+          deviceCode: 'TEST-0001', deviceSecret: 'synthetic',
+          expiresAt: new Date(Date.now() + 60000).toISOString(), pollIntervalMs: 250,
+        }, { onWaiting() { console.log('polling'); }, sleep: async () => {
+          await new Promise(resolve => setImmediate(resolve));
+          console.log('survived');
+          process.exit(0);
+        }});
+      `], {
+        env: { ...process.env, PATH: directory, KORTIX_AGENT_TUNNEL_NO_BROWSER: disabled },
+        stdout: 'pipe', stderr: 'pipe',
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+      ]);
+      expect(stderr).toBe('');
+      expect(exitCode).toBe(0);
+      expect(stdout).toContain('polling');
+      expect(stdout).toContain('survived');
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  });
+});
+
 const VALID_TUNNEL_ID = '00000000-0000-4000-8000-000000000042';
 const VALID_TOKEN = `kortix_tnl_${'A'.repeat(36)}`;
 

package/src/agent/device-auth.ts

@@ -291,7 +291,7 @@ export function openBrowser(url: string): void {
   const [command, args] = opener[platform()] ?? ['xdg-open', [safeUrl]];
 
   try {
-    spawn(command, args, { detached: true, stdio: 'ignore' }).unref();
+    spawn(command, args, { detached: true, stdio: 'ignore' }).on('error', () => {}).unref();
   } catch {
     // An unopenable browser is not fatal: the URL is printed too.
   }

package/src/agent/process-liveness.ts

@@ -0,0 +1,9 @@
+export function isAlive(pid: unknown): boolean {
+  if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}

package/src/agent/state-file.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, spyOn, test } from 'bun:test';
 import { mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -40,3 +40,28 @@ describe('agent state file', () => {
     }
   });
 });
+
+describe('state PID liveness', () => {
+  test.each([null, '1', 0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1])('rejects invalid PID %p without probing', (pid) => {
+    const home = mkdtempSync(join(tmpdir(), 'agent-tunnel-state-'));
+    writeFileSync(stateFilePath(home), JSON.stringify({ status: 'online', pid }));
+    const kill = spyOn(process, 'kill');
+    try {
+      expect(readAgentState(home)?.status).toBe('offline');
+      expect(kill).not.toHaveBeenCalled();
+    } finally { kill.mockRestore(); rmSync(home, { recursive: true, force: true }); }
+  });
+
+  test.each(['live', 'ESRCH', 'EPERM'])('handles %s', (result) => {
+    const home = mkdtempSync(join(tmpdir(), 'agent-tunnel-state-'));
+    writeFileSync(stateFilePath(home), JSON.stringify({ status: 'online', pid: process.pid }));
+    const kill = spyOn(process, 'kill').mockImplementation(() => {
+      if (result !== 'live') throw Object.assign(new Error(result), { code: result });
+      return true;
+    });
+    try {
+      expect(readAgentState(home)?.status).toBe(result === 'ESRCH' ? 'offline' : 'online');
+      expect(kill).toHaveBeenCalledWith(process.pid, 0);
+    } finally { kill.mockRestore(); rmSync(home, { recursive: true, force: true }); }
+  });
+});

package/src/agent/state-file.ts

@@ -2,6 +2,7 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'f
 import { join } from 'path';
 
 import type { TunnelAgentStatus } from './agent';
+import { isAlive } from './process-liveness';
 import { agentTunnelHome } from './service-paths';
 import { agentTunnelVersion } from './version';
 
@@ -48,16 +49,6 @@ export function writeAgentState(
   }
 }
 
-function isAlive(pid: unknown): boolean {
-  if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === 'EPERM';
-  }
-}
-
 /** The last status the agent wrote. A writer that died without writing `offline` reads as offline. */
 export function readAgentState(home: string = agentTunnelHome()): AgentStateFile | null {
   try {