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

package/src/__tests__/unit/actions.test.ts

@@ -1,402 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import type { HandlerCallback, IAgentRuntime, Memory, State } from '@elizaos/core';
-
-type SimpleMock<TArgs extends readonly unknown[] = unknown[], TReturn = unknown> = ((
-  ...args: TArgs
-) => TReturn) & {
-  calls: TArgs[];
-  _returnValue: TReturn | undefined;
-  _implementation: ((...args: unknown[]) => TReturn) | null;
-  mockReturnValue: (value: TReturn) => SimpleMock<TArgs, TReturn>;
-  mockResolvedValue: (value: Awaited<TReturn>) => SimpleMock<TArgs, TReturn>;
-  mockRejectedValue: (reason: unknown) => SimpleMock<TArgs, TReturn>;
-  mockImplementation: (impl: (...args: unknown[]) => TReturn) => SimpleMock<TArgs, TReturn>;
-  mock: { calls: TArgs[]; results: unknown[] };
-};
-
-// Use local mock implementation until core test-utils build issue is resolved
-const mock = <const TArgs extends readonly unknown[] = unknown[], TReturn = unknown>(): SimpleMock<
-  TArgs,
-  TReturn
-> => {
-  const calls: TArgs[] = [];
-  const fn = ((...args: TArgs) => {
-    calls.push(args);
-    if (typeof fn._implementation === 'function') {
-      return fn._implementation(...args);
-    }
-    return fn._returnValue as TReturn;
-  }) as SimpleMock<TArgs, TReturn>;
-  fn.calls = calls;
-  fn._returnValue = undefined;
-  fn._implementation = null;
-  fn.mockReturnValue = (value: TReturn) => {
-    fn._returnValue = value;
-    fn._implementation = null;
-    return fn;
-  };
-  fn.mockResolvedValue = (value: Awaited<TReturn>) => {
-    fn._returnValue = Promise.resolve(value) as TReturn;
-    fn._implementation = null;
-    return fn;
-  };
-  fn.mockRejectedValue = (reason: unknown) => {
-    fn._returnValue = Promise.reject(reason) as TReturn;
-    fn._implementation = null;
-    return fn;
-  };
-  fn.mockImplementation = (impl: (...args: unknown[]) => TReturn) => {
-    fn._implementation = impl;
-    fn._returnValue = undefined;
-    return fn;
-  };
-  fn.mock = { calls, results: [] };
-  return fn;
-};
-
-import { getTunnelStatusAction } from '../../actions/get-tunnel-status';
-import { startTunnelAction } from '../../actions/start-tunnel';
-import { stopTunnelAction } from '../../actions/stop-tunnel';
-import { MockNgrokService } from '../mocks/NgrokServiceMock';
-import { createMockMemory, createMockRuntime, createMockState } from '../test-utils';
-
-describe('Ngrok Actions - Validation and Error Handling', () => {
-  let mockRuntime: IAgentRuntime;
-  let mockTunnelService: MockNgrokService;
-  let mockCallback: HandlerCallback;
-  let mockMemory: Memory;
-  let mockState: State;
-  let mockUseModel: ReturnType<typeof mock>;
-
-  beforeEach(() => {
-    mockTunnelService = new MockNgrokService({} as IAgentRuntime);
-
-    // Reset all mocks to default behavior
-    mockTunnelService.startTunnel.mockResolvedValue('https://test.ngrok.io');
-    mockTunnelService.stopTunnel.mockResolvedValue(undefined);
-    mockTunnelService.isActive.mockReturnValue(false);
-    mockTunnelService.getStatus.mockReturnValue({
-      active: false,
-      url: null,
-      port: null,
-      startedAt: null,
-      provider: 'ngrok',
-    });
-
-    mockUseModel = mock().mockResolvedValue('{"port": 8080}');
-    mockRuntime = createMockRuntime({
-      getService: mock().mockImplementation((name: string) => {
-        if (name === 'tunnel' || name === 'ngrok-tunnel') {
-          return mockTunnelService;
-        }
-        return null;
-      }),
-      useModel: mockUseModel,
-    });
-
-    mockCallback = mock();
-    mockMemory = createMockMemory();
-    mockState = createMockState();
-  });
-
-  afterEach(() => {
-    // Clear any mock state between tests
-  });
-
-  describe('startTunnelAction - Validation', () => {
-    it('should validate that tunnel service exists', async () => {
-      const runtimeWithoutService = createMockRuntime({
-        getService: mock().mockReturnValue(null),
-      });
-
-      const isValid = await startTunnelAction.validate(runtimeWithoutService, mockMemory);
-
-      expect(isValid).toBe(false);
-    });
-
-    it('should validate when tunnel service is available', async () => {
-      const isValid = await startTunnelAction.validate(mockRuntime, mockMemory);
-
-      expect(isValid).toBe(true);
-    });
-  });
-
-  describe('startTunnelAction - Error Handling', () => {
-    it('should handle service not available', async () => {
-      const runtimeWithoutService = createMockRuntime({
-        getService: mock().mockReturnValue(null),
-      });
-      const memory = createMockMemory({
-        content: { text: 'start tunnel on port 8080' },
-      });
-
-      const result = await startTunnelAction.handler(
-        runtimeWithoutService,
-        memory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('service_unavailable');
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-    });
-
-    it('should handle invalid port numbers gracefully', async () => {
-      const runtimeWithInvalidPort = createMockRuntime({
-        getService: mock().mockImplementation((name: string) => {
-          if (name === 'tunnel' || name === 'ngrok-tunnel') {
-            return mockTunnelService;
-          }
-          return null;
-        }),
-        useModel: mock().mockResolvedValue('{"port": -1}'),
-      });
-      const memory = createMockMemory({
-        content: { text: 'start tunnel on port -1' },
-      });
-      mockTunnelService.startTunnel.mockResolvedValue('https://test.ngrok.io');
-
-      const result = await startTunnelAction.handler(
-        runtimeWithInvalidPort,
-        memory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(true);
-      expect(result.values?.tunnelUrl).toContain('ngrok.io');
-      expect(mockTunnelService.startTunnel.calls.length).toBeGreaterThan(0);
-    });
-
-    it('should handle port extraction failure', async () => {
-      mockMemory.content = { text: 'start tunnel' };
-      mockUseModel.mockResolvedValue('invalid json');
-      mockTunnelService.startTunnel.mockResolvedValue('https://test.ngrok.io');
-
-      const result = await startTunnelAction.handler(
-        mockRuntime,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(true);
-      expect(result.values?.tunnelUrl).toContain('ngrok.io');
-      expect(mockTunnelService.startTunnel.calls.length).toBeGreaterThan(0);
-      expect(mockTunnelService.startTunnel.calls[0][0]).toBe(3000); // Should use default
-    });
-
-    it('should handle tunnel start failure', async () => {
-      // Create a fresh mock service for this test that will fail
-      const failingTunnelService = new MockNgrokService({} as IAgentRuntime);
-      failingTunnelService.startTunnel.mockRejectedValue(new Error('Ngrok auth failed'));
-      failingTunnelService.isActive.mockReturnValue(false);
-
-      const failingRuntime = createMockRuntime({
-        getService: mock().mockImplementation((name: string) => {
-          if (name === 'tunnel' || name === 'ngrok-tunnel') {
-            return failingTunnelService;
-          }
-          return null;
-        }),
-        useModel: mock().mockResolvedValue('{"port": 8080}'),
-      });
-
-      mockMemory.content = { text: 'start tunnel on port 8080' };
-
-      const result = await startTunnelAction.handler(
-        failingRuntime,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('Ngrok auth failed');
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      const call = mockCallback.calls[0][0];
-      expect(call.text).toContain('Failed to start ngrok tunnel');
-      expect(call.metadata.error).toBe('Ngrok auth failed');
-    });
-
-    it('should handle port already in use', async () => {
-      // Create a fresh mock service for this test that reports as active
-      const activeTunnelService = new MockNgrokService({} as IAgentRuntime);
-      activeTunnelService.isActive.mockReturnValue(true);
-      activeTunnelService.getStatus.mockReturnValue({
-        active: true,
-        url: 'https://existing.ngrok.io',
-        port: 8080,
-        startedAt: new Date(),
-        provider: 'ngrok',
-      });
-
-      const activeRuntime = createMockRuntime({
-        getService: mock().mockImplementation((name: string) => {
-          if (name === 'tunnel' || name === 'ngrok-tunnel') {
-            return activeTunnelService;
-          }
-          return null;
-        }),
-        useModel: mock().mockResolvedValue('{"port": 8080}'),
-      });
-
-      mockMemory.content = { text: 'start tunnel on port 8080' };
-
-      const result = await startTunnelAction.handler(
-        activeRuntime,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('tunnel_already_active');
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      expect(mockCallback.calls[0][0].text).toContain('Tunnel is already active');
-    });
-  });
-
-  describe('stopTunnelAction - Validation', () => {
-    it('should validate that tunnel service exists', async () => {
-      const runtimeWithoutService = createMockRuntime({
-        getService: mock().mockReturnValue(null),
-      });
-
-      const isValid = await stopTunnelAction.validate(runtimeWithoutService, mockMemory);
-
-      expect(isValid).toBe(false);
-    });
-  });
-
-  describe('stopTunnelAction - Error Handling', () => {
-    it('should handle service not available', async () => {
-      const runtimeWithoutService = createMockRuntime({
-        getService: mock().mockReturnValue(null),
-      });
-
-      const result = await stopTunnelAction.handler(
-        runtimeWithoutService,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('service_unavailable');
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      expect(mockCallback.calls[0][0].text).toContain('Tunnel service is not available');
-    });
-
-    it('should handle stopping when no tunnel is active', async () => {
-      mockTunnelService.isActive.mockReturnValue(false);
-
-      const result = await stopTunnelAction.handler(
-        mockRuntime,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(true);
-      expect(result.values?.wasActive).toBe(false);
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      expect(mockCallback.calls[0][0].text).toContain('No tunnel is currently running');
-      expect(mockTunnelService.stopTunnel.calls.length).toBe(0);
-    });
-
-    it('should handle stop failure gracefully', async () => {
-      // Create a fresh mock service for this test that will fail to stop
-      const failingStopService = new MockNgrokService({} as IAgentRuntime);
-      failingStopService.isActive.mockReturnValue(true);
-      failingStopService.getStatus.mockReturnValue({
-        active: true,
-        url: 'https://test.ngrok.io',
-        port: 8080,
-        startedAt: new Date(),
-        provider: 'ngrok',
-      });
-      failingStopService.stopTunnel.mockRejectedValue(new Error('Stop failed'));
-
-      const failingStopRuntime = createMockRuntime({
-        getService: mock().mockImplementation((name: string) => {
-          if (name === 'tunnel' || name === 'ngrok-tunnel') {
-            return failingStopService;
-          }
-          return null;
-        }),
-      });
-
-      const result = await stopTunnelAction.handler(
-        failingStopRuntime,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('Stop failed');
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      const call = mockCallback.calls[0][0];
-      expect(call.text).toContain('Failed to stop ngrok tunnel');
-      expect(call.metadata.error).toBe('Stop failed');
-    });
-  });
-
-  describe('getTunnelStatusAction - Edge Cases', () => {
-    it('should handle service not available', async () => {
-      const runtimeWithoutService = createMockRuntime({
-        getService: mock().mockReturnValue(null),
-      });
-
-      const result = await getTunnelStatusAction.handler(
-        runtimeWithoutService,
-        mockMemory,
-        mockState,
-        {},
-        mockCallback
-      );
-
-      expect(result.values?.success).toBe(false);
-      expect(result.values?.error).toBe('Tunnel service not found');
-    });
-
-    it('should format uptime correctly', async () => {
-      const startTime = new Date();
-      startTime.setHours(startTime.getHours() - 2); // 2 hours ago
-
-      // Create a fresh mock service for this test with active tunnel
-      const activeTunnelService = new MockNgrokService({} as IAgentRuntime);
-      activeTunnelService.getStatus.mockReturnValue({
-        active: true,
-        url: 'https://test.ngrok.io',
-        port: 8080,
-        startedAt: startTime,
-        provider: 'ngrok',
-      });
-
-      const activeRuntime = createMockRuntime({
-        getService: mock().mockImplementation((name: string) => {
-          if (name === 'tunnel' || name === 'ngrok-tunnel') {
-            return activeTunnelService;
-          }
-          return null;
-        }),
-      });
-
-      await getTunnelStatusAction.handler(activeRuntime, mockMemory, mockState, {}, mockCallback);
-
-      expect(mockCallback.calls.length).toBeGreaterThan(0);
-      expect(mockCallback.calls[0][0].text).toContain('2 hours');
-    });
-  });
-});

package/src/actions/get-tunnel-status.ts

@@ -1,218 +0,0 @@
-import {
-  type Action,
-  type ActionExample,
-  type ActionResult,
-  elizaLogger,
-  type HandlerCallback,
-  type IAgentRuntime,
-  type Memory,
-  type State,
-} from '@elizaos/core';
-import { getTunnelService } from '@elizaos/plugin-tunnel';
-
-export const getTunnelStatusAction: Action = {
-  name: 'GET_TUNNEL_STATUS',
-  similes: ['TUNNEL_STATUS', 'CHECK_TUNNEL', 'NGROK_STATUS', 'TUNNEL_INFO'],
-  description:
-    'Get the current status of the ngrok tunnel including URL, port, and uptime information. Supports action chaining by providing tunnel metadata for monitoring workflows, health checks, or conditional tunnel management.',
-  validate: async (runtime: IAgentRuntime, _message: Memory) => {
-    return !!getTunnelService(runtime);
-  },
-  handler: async (
-    runtime: IAgentRuntime,
-    _message: Memory,
-    _state?: State,
-    _options?: unknown,
-    callback?: HandlerCallback
-  ): Promise<ActionResult> => {
-    try {
-      elizaLogger.info('Getting ngrok tunnel status...');
-
-      const tunnelService = getTunnelService(runtime);
-      if (!tunnelService) {
-        throw new Error('Tunnel service not found');
-      }
-
-      const status = tunnelService.getStatus();
-
-      let responseText: string;
-      const response = {
-        ...status,
-        uptime: 'N/A',
-      };
-
-      if (status.active) {
-        if (status.startedAt) {
-          const uptimeMs = Date.now() - new Date(status.startedAt).getTime();
-          const minutes = Math.floor(uptimeMs / 60000);
-          const hours = Math.floor(minutes / 60);
-
-          if (hours > 0) {
-            response.uptime = `${hours} hour${hours > 1 ? 's' : ''}, ${minutes % 60} minute${
-              minutes % 60 !== 1 ? 's' : ''
-            }`;
-          } else {
-            response.uptime = `${minutes} minute${minutes !== 1 ? 's' : ''}`;
-          }
-        }
-
-        responseText = `✅ Ngrok tunnel is active!\n\n🌐 Public URL: ${status.url}\n🔌 Local Port: ${status.port}\n⏱️ Uptime: ${response.uptime}\n🏢 Provider: ${status.provider}\n\nYour local service is accessible from the internet.`;
-      } else {
-        responseText =
-          '❌ No active ngrok tunnel.\n\nTo start a tunnel, say "start ngrok tunnel on port [PORT]"';
-      }
-
-      const startedAtIso = status.startedAt ? status.startedAt.toISOString() : null;
-
-      if (callback) {
-        await callback({
-          text: responseText,
-          metadata: {
-            action: 'tunnel_status',
-            uptime: response.uptime,
-            active: status.active,
-            url: status.url,
-            port: status.port,
-            startedAt: startedAtIso,
-            provider: status.provider,
-            backend: status.backend ?? null,
-          },
-        });
-      }
-
-      return {
-        success: true,
-        text: responseText,
-        values: {
-          success: true,
-          isActive: status.active,
-          tunnelUrl: status.url,
-          port: status.port,
-          uptime: response.uptime,
-          provider: status.provider,
-        },
-        data: {
-          action: 'GET_TUNNEL_STATUS',
-          tunnelStatus: {
-            active: status.active,
-            url: status.url,
-            port: status.port,
-            startedAt: startedAtIso,
-            provider: status.provider,
-            backend: status.backend ?? null,
-            uptime: response.uptime,
-            checkedAt: new Date().toISOString(),
-          },
-        },
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const stack = error instanceof Error ? (error.stack ?? null) : null;
-      elizaLogger.error(`Failed to get tunnel status: ${message}`);
-
-      if (callback) {
-        await callback({
-          text: `❌ Failed to get tunnel status: ${message}`,
-          metadata: {
-            error: message,
-            action: 'tunnel_status_failed',
-          },
-        });
-      }
-
-      return {
-        success: false,
-        text: `❌ Failed to get tunnel status: ${message}`,
-        values: {
-          success: false,
-          error: message,
-        },
-        data: {
-          action: 'GET_TUNNEL_STATUS',
-          errorType: 'status_check_failed',
-          errorDetails: stack,
-        },
-      };
-    }
-  },
-  examples: [
-    [
-      {
-        name: '{{user}}',
-        content: {
-          text: 'What is the tunnel status?',
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: '✅ Ngrok tunnel is active!\n\n🌐 Public URL: https://abc123.ngrok.io\n🔌 Local Port: 3000\n⏱️ Uptime: 15 minutes\n🏢 Provider: ngrok\n\nYour local service is accessible from the internet.',
-          actions: ['GET_TUNNEL_STATUS'],
-        },
-      },
-    ],
-    [
-      {
-        name: '{{user}}',
-        content: {
-          text: "Check tunnel status and restart it if it's been running too long",
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: "I'll check the current tunnel status and restart it if needed.",
-          thought:
-            'User wants me to monitor tunnel uptime and restart if necessary - I should check status first, then decide whether to restart based on uptime.',
-          actions: ['GET_TUNNEL_STATUS'],
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: "Tunnel has been running for 2 hours. That seems like a long time - I'll restart it for optimal performance.",
-          thought:
-            'Status shows the tunnel has been up for 2 hours, which is quite long. I should stop and restart it as requested.',
-          actions: ['STOP_TUNNEL'],
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: 'Tunnel stopped. Now starting a fresh tunnel...',
-          thought:
-            'Old tunnel is down, now I can start a new fresh tunnel for optimal performance.',
-          actions: ['START_TUNNEL'],
-        },
-      },
-    ],
-    [
-      {
-        name: '{{user}}',
-        content: {
-          text: 'Get tunnel info and then update our webhook URLs',
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: "I'll check the current tunnel status and then update the webhook URLs.",
-          thought:
-            'User needs the current tunnel URL for webhook configuration - I should get the status first, then update webhooks with the public URL.',
-          actions: ['GET_TUNNEL_STATUS'],
-        },
-      },
-      {
-        name: '{{agent}}',
-        content: {
-          text: 'Tunnel is active at https://abc123.ngrok.io. Now updating webhook URLs...',
-          thought:
-            'I have the current tunnel URL from the status check. I can now update the webhook configurations with this public URL.',
-          actions: ['UPDATE_WEBHOOKS'],
-        },
-      },
-    ],
-  ] as ActionExample[][],
-};
-
-export default getTunnelStatusAction;