@kortix/agent-tunnel 0.13.49 → 0.13.50

package/dist/agent-cli.js

@@ -6139,7 +6139,7 @@ function acquireTunnelLease() {
       if (!serviceWasActive || resumed)
         return;
       resumed = true;
-      startService();
+      resumeService();
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kortix/agent-tunnel",
-  "version": "0.13.49",
+  "version": "0.13.50",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kortix-ai/suna.git",
@@ -32,10 +32,10 @@
     "build": "bun build src/agent/cli.ts --target=node --outfile=dist/agent-cli.js --banner='#!/usr/bin/env node' && bun build src/client/cli.ts --target=node --outfile=dist/client-cli.js --banner='#!/usr/bin/env node' && node -e \"const fs=require('node:fs'); fs.chmodSync('dist/agent-cli.js', 0o755); fs.chmodSync('dist/client-cli.js', 0o755);\"",
     "prepack": "bun run build",
     "typecheck": "tsc --noEmit",
-    "test": "bun test"
+    "test": "bun test --timeout ${KORTIX_TEST_TIMEOUT_MS:-15000}"
   },
   "dependencies": {
-    "hono": "^4.4.0",
+    "hono": "^4.13.7",
     "ws": "^8.18.0"
   },
   "devDependencies": {

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

@@ -0,0 +1,99 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { platform, tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  type ServicePaths,
+  getServicePaths,
+  getServiceStatus,
+  installService,
+  runnerPartsFor,
+} from './service';
+import { acquireTunnelLease } from './service-control';
+import { type ServiceDriver, serviceDriverFor, supervisor } from './service-drivers';
+
+const realRun = supervisor.run;
+
+let calls: string[] = [];
+let home = '';
+let paths: ServicePaths | undefined;
+let driver: ServiceDriver | undefined;
+let savedHomeEnv: string | undefined;
+
+/** The supervisor verb that (re)starts the service, per platform. */
+const startVerb = (): RegExp =>
+  platform() === 'win32'
+    ? /schtasks\.exe \/Run/
+    : platform() === 'darwin'
+      ? /launchctl (bootstrap|kickstart)/
+      : /systemctl --user (restart|enable --now|start) /;
+
+describe('tunnel lease', () => {
+  beforeEach(() => {
+    savedHomeEnv = process.env.AGENT_TUNNEL_HOME;
+    home = mkdtempSync(join(tmpdir(), 'agent-tunnel-lease-'));
+    // A non-default home derives a unique service label, so the unit file the
+    // test writes under the real home directory never touches a real service.
+    process.env.AGENT_TUNNEL_HOME = home;
+    paths = getServicePaths();
+    const resolvedDriver = serviceDriverFor(platform());
+    if (!resolvedDriver) throw new Error(`no service driver for ${platform()}`);
+    driver = resolvedDriver;
+    calls = [];
+    // ponytail: every supervisor command succeeds — the drivers' failure and
+    // retry paths are service-drivers.test.ts's job.
+    supervisor.run = (command, args) => {
+      calls.push([command, ...args].join(' '));
+      return { ok: true, detail: command === 'powershell.exe' ? 'Running' : '' };
+    };
+  });
+
+  afterEach(() => {
+    supervisor.run = realRun;
+    if (driver && paths) rmSync(driver.unitPath(paths), { force: true });
+    if (home) rmSync(home, { recursive: true, force: true });
+    if (savedHomeEnv === undefined) delete process.env.AGENT_TUNNEL_HOME;
+    else process.env.AGENT_TUNNEL_HOME = savedHomeEnv;
+  });
+
+  /** Installs a real unit for the temp home, then rewrites it with a stale runner. */
+  function driftUnit() {
+    installService();
+    if (!driver || !paths) throw new Error('beforeEach did not initialise the fixture');
+    // The same home, an old runner: what an app update that moved the bundle
+    // leaves on disk.
+    const staleRunner = runnerPartsFor('/defunct/agent-cli.js', { execPath: '/bin/sh' }, paths);
+    writeFileSync(driver.unitPath(paths), driver.render(paths, staleRunner), { mode: 0o600 });
+    calls.length = 0;
+  }
+
+  test('resume reinstalls a drifted unit before starting it', () => {
+    driftUnit();
+    expect(getServiceStatus().upToDate).toBe(false);
+
+    const lease = acquireTunnelLease();
+    expect(lease.serviceWasActive).toBe(true);
+    lease.resumeService();
+
+    // The resume went through the drift-safe path: the unit on disk is what an
+    // install would write now, and the supervisor was asked to run the service.
+    expect(getServiceStatus().upToDate).toBe(true);
+    expect(calls.some((line) => startVerb().test(line))).toBe(true);
+  });
+
+  test('resume starts a fresh unit and acts at most once', () => {
+    installService();
+    calls.length = 0;
+    expect(getServiceStatus().upToDate).toBe(true);
+
+    const lease = acquireTunnelLease();
+    lease.resumeService();
+    const callsAfterFirstResume = calls.length;
+
+    lease.resumeService();
+    expect(calls.length).toBe(callsAfterFirstResume);
+    expect(getServiceStatus().upToDate).toBe(true);
+    expect(calls.some((line) => startVerb().test(line))).toBe(true);
+  });
+});

package/src/agent/service-control.ts

@@ -5,7 +5,6 @@ import {
   pauseService,
   restartService,
   resumeService,
-  startService,
   stopService,
   uninstallService,
 } from './service';
@@ -34,7 +33,9 @@ export function acquireTunnelLease(): TunnelLease {
     resumeService() {
       if (!serviceWasActive || resumed) return;
       resumed = true;
-      startService();
+      // The drift-safe resume: a unit an app update has moved is reinstalled
+      // before it starts, or the service would run a runner that is gone.
+      resumeService();
     },
   };
 }

package/src/client/cli.test.ts

@@ -117,7 +117,10 @@ function runCli(
     const child = spawn('bun', cliArgs, {
       env: {
         ...process.env,
-        TUNNEL_API_URL: `http://localhost:${mockPort}`,
+        // The mock agent is loopback by address: `localhost` does not resolve
+        // on a platform sandbox, which turns every row here into
+        // "Unable to connect" instead of the response under test.
+        TUNNEL_API_URL: `http://127.0.0.1:${mockPort}`,
         TUNNEL_TOKEN: 'test-token',
         TUNNEL_ID: '',
         ...envOverrides,
@@ -320,7 +323,7 @@ describe('Agent Tunnel CLI', () => {
 
     test('permission denied returns structured response', async () => {
       const r = await runCli('cua_list_apps', undefined, {
-        TUNNEL_API_URL: `http://localhost:${permPort}`,
+        TUNNEL_API_URL: `http://127.0.0.1:${permPort}`,
       });
       expect(r.json!.success).toBe(false);
       expect(r.json!.permissionRequired).toBe(true);
@@ -330,7 +333,7 @@ describe('Agent Tunnel CLI', () => {
 
   describe('server unreachable', () => {
     test('status with dead server returns error JSON', async () => {
-      const r = await runCli('status', undefined, { TUNNEL_API_URL: 'http://localhost:1' });
+      const r = await runCli('status', undefined, { TUNNEL_API_URL: 'http://127.0.0.1:1' });
       expect(r.exitCode).toBe(1);
       expect(r.json!.success).toBe(false);
     });
@@ -357,7 +360,7 @@ describe('Agent Tunnel CLI', () => {
     });
 
     test('status with no connections returns empty list', async () => {
-      const r = await runCli('status', undefined, { TUNNEL_API_URL: `http://localhost:${emptyPort}` });
+      const r = await runCli('status', undefined, { TUNNEL_API_URL: `http://127.0.0.1:${emptyPort}` });
       expect(r.exitCode).toBe(0);
       expect(r.json!.success).toBe(true);
       expect((r.json!.connections as unknown[]).length).toBe(0);
@@ -365,7 +368,7 @@ describe('Agent Tunnel CLI', () => {
 
     test('fs_read with no connections returns error', async () => {
       const r = await runCli('fs_read', '{"path":"/tmp/x"}', {
-        TUNNEL_API_URL: `http://localhost:${emptyPort}`,
+        TUNNEL_API_URL: `http://127.0.0.1:${emptyPort}`,
       });
       expect(r.exitCode).toBe(1);
       expect(r.json!.success).toBe(false);