@elizaos/plugin-tunnel 2.0.0-beta.1 → 2.0.11-beta.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shaw Walters and elizaOS Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -4,19 +4,19 @@ Local Tailscale-CLI tunnel backend for elizaOS.
 
 Registers `serviceType = "tunnel"` and exposes:
 
-- **`TUNNEL` action** — dispatcher with `op` parameter-enum (`start | stop | status`). Legacy `TAILSCALE`-prefixed action names are kept as similes.
+- **`TUNNEL` action** — provider-neutral dispatcher with `action=start | stop | status`.
 - **`TUNNEL_STATE` provider** — reads the active service's `getStatus()` into model state.
 - **`LocalTunnelService`** — wraps `tailscale serve` / `tailscale funnel`.
 
 ## Coexistence
 
-`plugin-tunnel`, [`@elizaos/plugin-elizacloud`](../plugin-elizacloud) (hosted headscale + reverse proxy), and [`@elizaos/plugin-ngrok`](https://github.com/elizaos-plugins/plugin-ngrok) all register under `serviceType="tunnel"`. **First active wins** — each plugin's `init` only registers if its credentials are present *and* the slot is free.
+`plugin-tunnel`, [`@elizaos/plugin-elizacloud`](../plugin-elizacloud) (hosted headscale + reverse proxy), and [`@elizaos/plugin-ngrok`](../plugin-ngrok) all register under `serviceType="tunnel"`. **First active wins** — each plugin's `init` calls `tunnelSlotIsFree(runtime)` and only registers its service if the slot is still free (plus any backend-specific check: `plugin-tunnel` also requires the `tailscale` binary on PATH).
 
 ```
 character.plugins = [
-  '@elizaos/plugin-elizacloud',  // wins if ELIZAOS_CLOUD_API_KEY set
-  '@elizaos/plugin-tunnel',      // falls back to local tailscale CLI
-  '@elizaos/plugin-ngrok',       // last-resort, if NGROK_AUTHTOKEN set
+  '@elizaos/plugin-elizacloud',  // hosted headscale backend (ELIZAOS_CLOUD_API_KEY)
+  '@elizaos/plugin-tunnel',      // local tailscale CLI (requires tailscale on PATH)
+  '@elizaos/plugin-ngrok',       // ngrok backend (NGROK_AUTH_TOKEN)
 ];
 ```
 
@@ -36,4 +36,6 @@ character.plugins = [
 | `TUNNEL_FUNNEL` | `false` | When true, uses `tailscale funnel` instead of `tailscale serve` |
 | `TUNNEL_DEFAULT_PORT` | `3000` | Used when no port is extracted from the user's message |
 
-`TAILSCALE_*` aliases are accepted for one release window.
+`TUNNEL_*` env vars are canonical. `TAILSCALE_*` env vars are accepted only as
+backend configuration aliases for the local Tailscale provider, not as action
+names.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/plugin-tunnel",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.11-beta.7",
   "description": "Tunnel plugin for elizaOS — local Tailscale CLI backend (serve/funnel). Pair with @elizaos/plugin-elizacloud for the hosted headscale backend.",
   "type": "module",
   "main": "dist/index.js",
@@ -10,8 +10,24 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
+      "eliza-source": {
+        "types": "./src/index.ts",
+        "import": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./*.css": "./dist/*.css",
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "eliza-source": {
+        "types": "./src/*.ts",
+        "import": "./src/*.ts",
+        "default": "./src/*.ts"
+      },
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
     }
   },
   "files": [
@@ -21,7 +37,7 @@
   "scripts": {
     "build": "tsc --noCheck -p tsconfig.json",
     "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsgo --noEmit",
     "test": "bun test",
     "test:unit": "bun test src/__tests__/",
     "lint": "bunx @biomejs/biome check --write --unsafe .",
@@ -37,10 +53,10 @@
     "networking"
   ],
   "peerDependencies": {
-    "@elizaos/core": "2.0.0-beta.1"
+    "@elizaos/core": "2.0.11-beta.7"
   },
   "dependencies": {
-    "@elizaos/core": "2.0.0-beta.1",
+    "@elizaos/core": "2.0.11-beta.7",
     "zod": "^4.4.2"
   },
   "devDependencies": {
@@ -55,5 +71,6 @@
   "agentConfig": {
     "pluginType": "elizaos:plugin:1.0.0",
     "pluginParameters": {}
-  }
+  },
+  "gitHead": "cdbc876f793d96073d7eb0d09715a031ce0cd32e"
 }

package/src/__tests__/unit/local-tunnel-service.test.ts

@@ -1,23 +1,254 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, mock } from 'bun:test';
+import type { HandlerCallback, IAgentRuntime, Memory } from '@elizaos/core';
+import { ModelType } from '@elizaos/core';
+import { handleGetTunnelStatus } from '../../actions/get-tunnel-status';
+import { handleStartTunnel } from '../../actions/start-tunnel';
+import { handleStopTunnel } from '../../actions/stop-tunnel';
 import { tunnelAction } from '../../actions/tunnel';
+import { validateTunnelConfig } from '../../environment';
 import { tunnelStateProvider } from '../../providers/tunnel-state';
 import { LocalTunnelService } from '../../services/LocalTunnelService';
+import type { ITunnelService } from '../../types';
 
-describe('plugin-tunnel exports', () => {
-  it('LocalTunnelService registers under serviceType="tunnel"', () => {
-    expect(LocalTunnelService.serviceType).toBe('tunnel');
+function tunnelService(overrides: Partial<ITunnelService> = {}): ITunnelService {
+  return {
+    getStatus: mock(() => ({
+      active: false,
+      url: 'https://device.example.ts.net',
+      port: 8080,
+      startedAt: new Date('2026-01-01T00:00:00.000Z'),
+      provider: 'tailscale',
+      backend: 'local-cli',
+    })),
+    getUrl: mock(() => 'https://device.example.ts.net'),
+    isActive: mock(() => false),
+    startTunnel: mock(async () => 'https://device.example.ts.net'),
+    stopTunnel: mock(async () => {}),
+    ...overrides,
+  };
+}
+
+function runtime(service: ITunnelService | null, modelResponse = '{"port": 3000}'): IAgentRuntime {
+  return {
+    getService: mock(() => service),
+    useModel: mock(async () => modelResponse),
+  } as unknown as IAgentRuntime;
+}
+
+const message = { content: { text: 'start a tunnel' } } as Memory;
+
+describe('plugin-tunnel start action', () => {
+  it('starts the active tunnel service with an explicit string port and reports callback data', async () => {
+    const service = tunnelService();
+    const callback = mock(async () => {}) as HandlerCallback;
+
+    const result = await handleStartTunnel(
+      runtime(service),
+      message,
+      undefined,
+      { port: '8080' },
+      callback
+    );
+
+    expect(service.startTunnel).toHaveBeenCalledWith(8080);
+    expect(callback).toHaveBeenCalledWith({
+      text: 'Tunnel started (tailscale).\n\nURL: https://device.example.ts.net\nLocal port: 8080',
+    });
+    expect(result).toEqual({
+      success: true,
+      text: 'Tunnel started on port 8080',
+      data: {
+        action: 'tunnel_started',
+        tunnelUrl: 'https://device.example.ts.net',
+        port: 8080,
+        provider: 'tailscale',
+      },
+    });
+  });
+
+  it('falls back to model-derived ports and defaults invalid model output to 3000', async () => {
+    const validService = tunnelService();
+    const validRuntime = runtime(validService, '{"port": 4321}');
+
+    await handleStartTunnel(validRuntime, message);
+
+    expect(validRuntime.useModel).toHaveBeenCalledWith(ModelType.TEXT_SMALL, expect.any(Object));
+    expect(validService.startTunnel).toHaveBeenCalledWith(4321);
+
+    const invalidService = tunnelService();
+    await handleStartTunnel(runtime(invalidService, '{"port": 999999}'), message);
+
+    expect(invalidService.startTunnel).toHaveBeenCalledWith(3000);
   });
 
-  it('TUNNEL action exposes start/stop/status enum and similes', () => {
-    expect(tunnelAction.name).toBe('TUNNEL');
-    const opParam = tunnelAction.parameters?.find((p) => p.name === 'action');
-    expect(opParam).toBeDefined();
-    expect((opParam?.schema as { enum?: string[] }).enum).toEqual(['start', 'stop', 'status']);
-    expect(tunnelAction.similes).toEqual(expect.arrayContaining(['TAILSCALE', 'START_TUNNEL']));
+  it('does not start when the tunnel service is missing or already active', async () => {
+    const missingCallback = mock(async () => {}) as HandlerCallback;
+
+    await expect(
+      handleStartTunnel(runtime(null), message, undefined, undefined, missingCallback)
+    ).resolves.toEqual({ success: false, error: 'tunnel service unavailable' });
+    expect(missingCallback).toHaveBeenCalledWith({
+      text: 'Tunnel service is not available. Configure plugin-tunnel, plugin-elizacloud, or plugin-ngrok.',
+    });
+
+    const activeService = tunnelService({ isActive: mock(() => true) });
+    await expect(handleStartTunnel(runtime(activeService), message)).resolves.toEqual({
+      success: false,
+      error: 'tunnel already active',
+    });
+    expect(activeService.startTunnel).not.toHaveBeenCalled();
   });
 
-  it('TUNNEL_STATE provider has get() and is named correctly', () => {
-    expect(tunnelStateProvider.name).toBe('TUNNEL_STATE');
-    expect(typeof tunnelStateProvider.get).toBe('function');
+  it.each([
+    0,
+    65_536,
+    1.5,
+    Number.NaN,
+    'abc',
+    '../../3000',
+  ])('rejects explicit hostile port %s before model fallback or service start', async (port) => {
+    const service = tunnelService();
+    const rt = runtime(service);
+    const callback = mock(async () => {}) as HandlerCallback;
+
+    await expect(handleStartTunnel(rt, message, undefined, { port }, callback)).resolves.toEqual({
+      success: false,
+      error: 'invalid tunnel port',
+    });
+
+    expect(rt.useModel).not.toHaveBeenCalled();
+    expect(service.startTunnel).not.toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith({
+      text: 'Invalid tunnel port. Port must be an integer between 1 and 65535.',
+    });
+  });
+
+  it('dispatches nested TUNNEL action parameters to start without leaking action into sub-options', async () => {
+    const service = tunnelService();
+
+    const result = await tunnelAction.handler(runtime(service), message, undefined, {
+      parameters: { action: 'start', parameters: { port: 9090 } },
+    });
+
+    expect(service.startTunnel).toHaveBeenCalledWith(9090);
+    expect(result.success).toBe(true);
+  });
+
+  it('returns structured errors for missing and unknown TUNNEL actions', async () => {
+    const callback = mock(async () => {}) as HandlerCallback;
+    const rt = runtime(tunnelService());
+
+    await expect(tunnelAction.handler(rt, message, undefined, {}, callback)).resolves.toEqual({
+      success: false,
+      error: 'TUNNEL requires action=start|stop|status',
+    });
+    await expect(
+      tunnelAction.handler(rt, message, undefined, { action: 'restart<script>' }, callback)
+    ).resolves.toEqual({
+      success: false,
+      error: 'Unknown TUNNEL action "restart<script>". Supported: start, stop, status',
+    });
+  });
+});
+
+describe('plugin-tunnel stop/status/provider/config behavior', () => {
+  it('stops an active tunnel and reports the previous endpoint', async () => {
+    const service = tunnelService({
+      isActive: mock(() => true),
+      getStatus: mock(() => ({
+        active: true,
+        url: 'https://device.example.ts.net',
+        port: 8080,
+        startedAt: new Date('2026-01-01T00:00:00.000Z'),
+        provider: 'tailscale',
+        backend: 'local-cli',
+      })),
+    });
+    const callback = mock(async () => {}) as HandlerCallback;
+
+    await expect(
+      handleStopTunnel(runtime(service), message, undefined, undefined, callback)
+    ).resolves.toMatchObject({
+      success: true,
+      data: {
+        action: 'tunnel_stopped',
+        previousUrl: 'https://device.example.ts.net',
+        previousPort: 8080,
+      },
+    });
+    expect(service.stopTunnel).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({
+      text: 'Tunnel stopped.\n\nWas running on port: 8080\nPrevious URL: https://device.example.ts.net',
+    });
+  });
+
+  it('reports status and provider state without mutating inactive services', async () => {
+    const service = tunnelService({
+      isActive: mock(() => false),
+      getStatus: mock(() => ({
+        active: false,
+        url: null,
+        port: null,
+        startedAt: null,
+        provider: 'tailscale',
+        backend: 'local-cli',
+      })),
+    });
+
+    await expect(handleGetTunnelStatus(runtime(service), message)).resolves.toMatchObject({
+      success: true,
+      data: {
+        action: 'tunnel_status',
+        active: false,
+        provider: 'tailscale',
+        backend: 'local-cli',
+      },
+    });
+    await expect(tunnelStateProvider.get(runtime(service), message)).resolves.toEqual({
+      text: 'Tunnel idle (tailscale ready).',
+      data: {
+        available: true,
+        active: false,
+        url: null,
+        port: null,
+        startedAt: null,
+        provider: 'tailscale',
+        backend: 'local-cli',
+      },
+    });
+    expect(service.startTunnel).not.toHaveBeenCalled();
+    expect(service.stopTunnel).not.toHaveBeenCalled();
+  });
+
+  it('sanitizes tunnel config and falls back on hostile default ports', async () => {
+    const getSetting = mock((key: string) => {
+      const values: Record<string, unknown> = {
+        TUNNEL_TAGS: ' tag:one, ,tag:two ',
+        TUNNEL_FUNNEL: '1',
+        TUNNEL_DEFAULT_PORT: '../../99999',
+      };
+      return values[key] ?? null;
+    });
+
+    await expect(validateTunnelConfig({ getSetting } as unknown as IAgentRuntime)).resolves.toEqual(
+      {
+        TUNNEL_TAGS: ['tag:one', 'tag:two'],
+        TUNNEL_FUNNEL: true,
+        TUNNEL_DEFAULT_PORT: 3000,
+      }
+    );
+  });
+
+  it.each([
+    0,
+    65_536,
+    1.5,
+    Number.NaN,
+  ])('LocalTunnelService rejects hostile runtime port %s before config or CLI calls', async (port) => {
+    const service = new LocalTunnelService({
+      getSetting: mock(() => null),
+    } as unknown as IAgentRuntime);
+
+    await expect(service.startTunnel(port as number)).rejects.toThrow('Invalid port number');
   });
 });

package/src/actions/start-tunnel.ts

@@ -84,6 +84,11 @@ export async function handleStartTunnel(
     const parsed = Number.parseInt(explicitPort, 10);
     if (isValidPort(parsed)) port = parsed;
   }
+  if (explicitPort !== undefined && port === undefined) {
+    const message = 'Invalid tunnel port. Port must be an integer between 1 and 65535.';
+    if (callback) await callback({ text: message });
+    return { success: false, error: 'invalid tunnel port' };
+  }
 
   if (port === undefined) {
     const userMessage = message.content.text ?? '';

package/src/actions/tunnel.ts

@@ -1,9 +1,9 @@
 /**
  * @module tunnel
  * @description Single dispatcher action that fans out to the active
- * tunnel-service implementation. The action's name is `TUNNEL`; legacy
- * `TAILSCALE`-prefixed action names are kept as `similes` so older
- * characters and callers still resolve.
+ * tunnel-service implementation. The action's name is `TUNNEL`; concrete
+ * providers such as local Tailscale, Eliza Cloud headscale, and ngrok only
+ * register the service backend.
  *
  * Sub-ops (selected via the `action` parameter-enum):
  *   - start  -> handleStartTunnel    (optional `port`, defaults to 3000)
@@ -45,7 +45,7 @@ function resolveDispatch(options: Record<string, unknown> | undefined): {
   }
   const nested = pickRecord(options.parameters);
   const actionSource = nested ?? options;
-  const rawAction = actionSource.action ?? actionSource.subaction ?? actionSource.op;
+  const rawAction = actionSource.action;
   const action = typeof rawAction === 'string' ? rawAction.toLowerCase() : null;
 
   let subOptions: Record<string, unknown>;
@@ -54,17 +54,11 @@ function resolveDispatch(options: Record<string, unknown> | undefined): {
     if (innerParams) {
       subOptions = { ...innerParams };
     } else {
-      const {
-        action: _omitAction,
-        subaction: _omitSubaction,
-        op: _omitOp,
-        parameters: _omitParams,
-        ...rest
-      } = nested;
+      const { action: _omitAction, parameters: _omitParams, ...rest } = nested;
       subOptions = rest;
     }
   } else {
-    const { action: _omitAction, subaction: _omitSubaction, op: _omitOp, ...rest } = options;
+    const { action: _omitAction, ...rest } = options;
     subOptions = rest;
   }
 
@@ -73,24 +67,7 @@ function resolveDispatch(options: Record<string, unknown> | undefined): {
 
 export const tunnelAction: Action = {
   name: 'TUNNEL',
-  similes: [
-    // Legacy action names kept so existing characters/transcripts still resolve.
-    'TAILSCALE',
-    'START_TAILSCALE',
-    'STOP_TAILSCALE',
-    'GET_TAILSCALE_STATUS',
-    'START_TUNNEL',
-    'OPEN_TUNNEL',
-    'CREATE_TUNNEL',
-    'TAILSCALE_UP',
-    'STOP_TUNNEL',
-    'CLOSE_TUNNEL',
-    'TAILSCALE_DOWN',
-    'TAILSCALE_STATUS',
-    'CHECK_TUNNEL',
-    'TUNNEL_INFO',
-    'TUNNEL_STATUS',
-  ],
+  similes: ['OPEN_TUNNEL', 'CREATE_TUNNEL', 'CLOSE_TUNNEL', 'CHECK_TUNNEL', 'TUNNEL_INFO'],
   description:
     'Tunnel operations dispatched by `action`: start, stop, status. The `start` action accepts an optional `port` (defaults to 3000); `stop` and `status` take no parameters. Backed by whichever tunnel plugin is active (local Tailscale CLI, Eliza Cloud headscale, or ngrok).',
 

package/src/environment.ts

@@ -14,7 +14,8 @@ export const tunnelEnvSchema = z.object({
     .union([z.string(), z.array(z.string())])
     .optional()
     .transform((value) => {
-      if (Array.isArray(value)) return value.filter((tag) => tag.length > 0);
+      if (Array.isArray(value))
+        return value.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
       if (typeof value === 'string' && value.length > 0)
         return value
           .split(',')
@@ -33,8 +34,8 @@ export const tunnelEnvSchema = z.object({
     .optional()
     .transform((value) => {
       if (value === undefined || value === '') return 3000;
-      const num = typeof value === 'string' ? Number.parseInt(value, 10) : value;
-      if (Number.isNaN(num) || num <= 0 || num > 65535) return 3000;
+      const num = typeof value === 'string' && /^\d+$/.test(value) ? Number(value) : value;
+      if (typeof num !== 'number' || !Number.isInteger(num) || num <= 0 || num > 65535) return 3000;
       return num;
     })
     .default(3000),

package/src/index.ts

@@ -1,4 +1,4 @@
-import { elizaLogger, promoteSubactionsToActions, type Plugin } from '@elizaos/core';
+import { elizaLogger, type Plugin, promoteSubactionsToActions } from '@elizaos/core';
 import { TunnelTestSuite } from './__tests__/TunnelTestSuite';
 import { tunnelAction } from './actions/tunnel';
 import { tunnelStateProvider } from './providers/tunnel-state';

package/src/services/LocalTunnelService.ts

@@ -32,8 +32,8 @@ function runCommand(cmd: string, args: string[]): Promise<SpawnResult> {
     const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
     const out: Buffer[] = [];
     const err: Buffer[] = [];
-    child.stdout?.on('data', (chunk: Buffer) => out.push(chunk));
-    child.stderr?.on('data', (chunk: Buffer) => err.push(chunk));
+    child.stdout.on('data', (chunk: Buffer) => out.push(chunk));
+    child.stderr.on('data', (chunk: Buffer) => err.push(chunk));
     child.on('error', reject);
     child.on('exit', (code) =>
       resolve({
@@ -122,7 +122,7 @@ export class LocalTunnelService extends Service implements ITunnelService {
       return;
     }
 
-    if (port < 1 || port > 65535) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
       throw new Error('Invalid port number');
     }
 

package/dist/__tests__/TunnelTestSuite.d.ts

@@ -1,6 +0,0 @@
-import type { TestCase, TestSuite } from '@elizaos/core';
-export declare class TunnelTestSuite implements TestSuite {
-    name: string;
-    tests: TestCase[];
-}
-//# sourceMappingURL=TunnelTestSuite.d.ts.map

package/dist/__tests__/TunnelTestSuite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TunnelTestSuite.d.ts","sourceRoot":"","sources":["../../src/__tests__/TunnelTestSuite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAKxE,qBAAa,eAAgB,YAAW,SAAS;IAC/C,IAAI,SAAY;IAChB,KAAK,EAAE,QAAQ,EAAE,CAqCf;CACH"}

package/dist/__tests__/TunnelTestSuite.js

@@ -1,47 +0,0 @@
-import { tunnelAction } from '../actions/tunnel';
-import { tunnelStateProvider } from '../providers/tunnel-state';
-import { LocalTunnelService } from '../services/LocalTunnelService';
-export class TunnelTestSuite {
-    name = 'tunnel';
-    tests = [
-        {
-            name: 'LocalTunnelService — service-type contract',
-            fn: (_runtime) => {
-                if (LocalTunnelService.serviceType !== 'tunnel') {
-                    throw new Error('LocalTunnelService.serviceType must be "tunnel"');
-                }
-            },
-        },
-        {
-            name: 'tunnelAction — name and op enum',
-            fn: (_runtime) => {
-                if (tunnelAction.name !== 'TUNNEL') {
-                    throw new Error(`tunnelAction.name must be "TUNNEL", got ${tunnelAction.name}`);
-                }
-                const opParam = tunnelAction.parameters?.find((p) => p.name === 'op');
-                if (!opParam)
-                    throw new Error('tunnelAction must declare an `op` parameter');
-                const enumVals = opParam.schema?.enum;
-                if (!Array.isArray(enumVals))
-                    throw new Error('op parameter must declare a string enum');
-                for (const expected of ['start', 'stop', 'status']) {
-                    if (!enumVals.includes(expected)) {
-                        throw new Error(`op enum missing "${expected}"`);
-                    }
-                }
-            },
-        },
-        {
-            name: 'TUNNEL_STATE provider — name and shape',
-            fn: (_runtime) => {
-                if (tunnelStateProvider.name !== 'TUNNEL_STATE') {
-                    throw new Error(`tunnelStateProvider.name must be "TUNNEL_STATE"`);
-                }
-                if (typeof tunnelStateProvider.get !== 'function') {
-                    throw new Error('tunnelStateProvider must define get()');
-                }
-            },
-        },
-    ];
-}
-//# sourceMappingURL=TunnelTestSuite.js.map

package/dist/__tests__/TunnelTestSuite.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TunnelTestSuite.js","sourceRoot":"","sources":["../../src/__tests__/TunnelTestSuite.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE,MAAM,OAAO,eAAe;IAC1B,IAAI,GAAG,QAAQ,CAAC;IAChB,KAAK,GAAe;QAClB;YACE,IAAI,EAAE,4CAA4C;YAClD,EAAE,EAAE,CAAC,QAAuB,EAAE,EAAE;gBAC9B,IAAI,kBAAkB,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;oBAChD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;gBACrE,CAAC;YACH,CAAC;SACF;QACD;YACE,IAAI,EAAE,iCAAiC;YACvC,EAAE,EAAE,CAAC,QAAuB,EAAE,EAAE;gBAC9B,IAAI,YAAY,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACnC,MAAM,IAAI,KAAK,CAAC,2CAA2C,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;gBAClF,CAAC;gBACD,MAAM,OAAO,GAAG,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;gBACtE,IAAI,CAAC,OAAO;oBAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;gBAC7E,MAAM,QAAQ,GAAI,OAAO,CAAC,MAA2C,EAAE,IAAI,CAAC;gBAC5E,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBACzF,KAAK,MAAM,QAAQ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;oBACnD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;wBACjC,MAAM,IAAI,KAAK,CAAC,oBAAoB,QAAQ,GAAG,CAAC,CAAC;oBACnD,CAAC;gBACH,CAAC;YACH,CAAC;SACF;QACD;YACE,IAAI,EAAE,wCAAwC;YAC9C,EAAE,EAAE,CAAC,QAAuB,EAAE,EAAE;gBAC9B,IAAI,mBAAmB,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;oBAChD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;gBACrE,CAAC;gBACD,IAAI,OAAO,mBAAmB,CAAC,GAAG,KAAK,UAAU,EAAE,CAAC;oBAClD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;gBAC3D,CAAC;YACH,CAAC;SACF;KACF,CAAC;CACH"}

package/dist/actions/get-tunnel-status.d.ts

@@ -1,3 +0,0 @@
-import { type ActionResult, type HandlerCallback, type IAgentRuntime, type Memory, type State } from '@elizaos/core';
-export declare function handleGetTunnelStatus(runtime: IAgentRuntime, _message?: Memory, _state?: State, _options?: Record<string, unknown>, callback?: HandlerCallback): Promise<ActionResult>;
-//# sourceMappingURL=get-tunnel-status.d.ts.map

package/dist/actions/get-tunnel-status.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-tunnel-status.d.ts","sourceRoot":"","sources":["../../src/actions/get-tunnel-status.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AAavB,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,aAAa,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,KAAK,EACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,QAAQ,CAAC,EAAE,eAAe,GACzB,OAAO,CAAC,YAAY,CAAC,CAiCvB"}

package/dist/actions/get-tunnel-status.js

@@ -1,43 +0,0 @@
-import { elizaLogger, } from '@elizaos/core';
-import { getTunnelService } from '../types';
-function formatUptime(startedAt) {
-    const ms = Date.now() - startedAt.getTime();
-    const minutes = Math.floor(ms / 60_000);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-        return `${hours} hour${hours === 1 ? '' : 's'}, ${minutes % 60} minute${minutes % 60 === 1 ? '' : 's'}`;
-    }
-    return `${minutes} minute${minutes === 1 ? '' : 's'}`;
-}
-export async function handleGetTunnelStatus(runtime, _message, _state, _options, callback) {
-    const tunnelService = getTunnelService(runtime);
-    if (!tunnelService) {
-        if (callback) {
-            await callback({ text: 'Tunnel service is not available.' });
-        }
-        return { success: false, error: 'tunnel service unavailable' };
-    }
-    elizaLogger.info('[get-tunnel-status] reading status');
-    const status = tunnelService.getStatus();
-    const uptime = status.startedAt ? formatUptime(status.startedAt) : 'N/A';
-    const responseText = status.active
-        ? `✅ tunnel active (${status.provider}).\n\nURL: ${status.url}\nLocal port: ${status.port}\nUptime: ${uptime}`
-        : '❌ No active tunnel. Say "start tunnel on port [PORT]" to start one.';
-    if (callback) {
-        await callback({ text: responseText });
-    }
-    return {
-        success: true,
-        text: responseText,
-        data: {
-            action: 'tunnel_status',
-            active: status.active,
-            url: status.url ?? '',
-            port: status.port ?? 0,
-            provider: status.provider,
-            backend: status.backend ?? '',
-            uptime,
-        },
-    };
-}
-//# sourceMappingURL=get-tunnel-status.js.map

package/dist/actions/get-tunnel-status.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-tunnel-status.js","sourceRoot":"","sources":["../../src/actions/get-tunnel-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,GAKZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,SAAS,YAAY,CAAC,SAAe;IACnC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;IAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC;IACvC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,OAAO,GAAG,KAAK,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,OAAO,GAAG,EAAE,UAAU,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IAC1G,CAAC;IACD,OAAO,GAAG,OAAO,UAAU,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AACxD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,OAAsB,EACtB,QAAiB,EACjB,MAAc,EACd,QAAkC,EAClC,QAA0B;IAE1B,MAAM,aAAa,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,QAAQ,CAAC,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,4BAA4B,EAAE,CAAC;IACjE,CAAC;IAED,WAAW,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;IACvD,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,EAAE,CAAC;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAEzE,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM;QAChC,CAAC,CAAC,oBAAoB,MAAM,CAAC,QAAQ,cAAc,MAAM,CAAC,GAAG,iBAAiB,MAAM,CAAC,IAAI,aAAa,MAAM,EAAE;QAC9G,CAAC,CAAC,qEAAqE,CAAC;IAE1E,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,QAAQ,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IACzC,CAAC;IACD,OAAO;QACL,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,MAAM,EAAE,eAAe;YACvB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE;YACrB,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC;YACtB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE;YAC7B,MAAM;SACP;KACF,CAAC;AACJ,CAAC"}

package/dist/actions/start-tunnel.d.ts

@@ -1,3 +0,0 @@
-import { type ActionResult, type HandlerCallback, type IAgentRuntime, type Memory, type State } from '@elizaos/core';
-export declare function handleStartTunnel(runtime: IAgentRuntime, message: Memory, _state?: State, options?: Record<string, unknown>, callback?: HandlerCallback): Promise<ActionResult>;
-//# sourceMappingURL=start-tunnel.d.ts.map

package/dist/actions/start-tunnel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-tunnel.d.ts","sourceRoot":"","sources":["../../src/actions/start-tunnel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,MAAM,EAEX,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AA0CvB,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,CAAC,EAAE,eAAe,GACzB,OAAO,CAAC,YAAY,CAAC,CA4DvB"}