@elizaos/plugin-ngrok 2.0.0-beta.1

package/src/__tests__/test-setup.ts

@@ -0,0 +1,174 @@
+import { afterAll, beforeAll, beforeEach } from 'bun:test';
+import { spawn } from 'node:child_process';
+import * as path from 'node:path';
+import * as dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+
+// Store the original NGROK_DOMAIN to restore later
+const originalNgrokDomain = process.env.NGROK_DOMAIN;
+const originalNgrokAuthToken = process.env.NGROK_AUTH_TOKEN;
+
+// Global test state
+const activeNgrokProcesses: Set<number> = new Set();
+
+// Kill all ngrok processes before tests start
+async function killAllNgrokProcesses(): Promise<void> {
+  return new Promise((resolve) => {
+    // Use more specific pattern to only kill actual ngrok processes
+    const killProcess = spawn('pkill', ['-x', 'ngrok']);
+    killProcess.on('exit', () => {
+      // Give it a moment to fully terminate
+      setTimeout(resolve, 1000);
+    });
+    killProcess.on('error', () => {
+      // pkill might not exist on all systems, that's OK
+      resolve();
+    });
+  });
+}
+
+// Check if any ngrok processes are running
+async function checkNgrokProcesses(): Promise<boolean> {
+  return new Promise((resolve) => {
+    // Use more specific pattern to only find actual ngrok processes
+    const checkProcess = spawn('pgrep', ['-x', 'ngrok']);
+    let hasProcesses = false;
+
+    checkProcess.stdout.on('data', (data) => {
+      const pids = data.toString().trim().split('\n').filter(Boolean);
+      if (pids.length > 0) {
+        hasProcesses = true;
+        pids.forEach((pid: string) => {
+          const pidNum = parseInt(pid, 10);
+          if (!Number.isNaN(pidNum)) {
+            activeNgrokProcesses.add(pidNum);
+          }
+        });
+      }
+    });
+
+    checkProcess.on('exit', () => {
+      resolve(hasProcesses);
+    });
+
+    checkProcess.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+// Check if this is a pay-as-you-go account by trying to start without domain
+async function checkIfPayAsYouGo(): Promise<boolean> {
+  if (!originalNgrokAuthToken) {
+    return false;
+  }
+
+  return new Promise((resolve) => {
+    const envWithoutDomain: NodeJS.ProcessEnv = { ...process.env };
+    delete envWithoutDomain.NGROK_DOMAIN;
+
+    const checkProcess = spawn('ngrok', ['http', '8080'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: envWithoutDomain,
+    });
+
+    let isPayAsYouGo = false;
+
+    checkProcess.stderr?.on('data', (data: Buffer) => {
+      const message = data.toString();
+      if (message.includes('ERR_NGROK_15002') || message.includes('Pay-as-you-go')) {
+        isPayAsYouGo = true;
+        checkProcess.kill();
+      }
+    });
+
+    checkProcess.on('exit', () => {
+      resolve(isPayAsYouGo);
+    });
+
+    // Give it a few seconds then kill it
+    setTimeout(() => {
+      if (!checkProcess.killed) {
+        checkProcess.kill();
+      }
+    }, 3000);
+  });
+}
+
+beforeAll(async () => {
+  // Only run setup for test files, not for the main process
+  const isTestFile = process.argv.some((arg) => arg.includes('.test.') || arg.includes('.spec.'));
+  if (!isTestFile) {
+    return;
+  }
+
+  console.log('\n🧹 Cleaning up any existing ngrok processes...');
+  await killAllNgrokProcesses();
+
+  // Check if this is a pay-as-you-go account
+  const isPayAsYouGo = await checkIfPayAsYouGo();
+
+  if (isPayAsYouGo && originalNgrokDomain) {
+    // For pay-as-you-go accounts, we MUST use the domain
+    console.log('📌 Pay-as-you-go account detected, using domain:', originalNgrokDomain);
+    process.env.NGROK_DOMAIN = originalNgrokDomain;
+  } else {
+    // For free accounts, we should NOT use a fixed domain to avoid conflicts
+    console.log('🆓 Free account detected, using random URLs for tests');
+    delete process.env.NGROK_DOMAIN;
+  }
+
+  console.log('✅ Test environment ready\n');
+});
+
+beforeEach(async () => {
+  // Only run for test files
+  const isTestFile = process.argv.some((arg) => arg.includes('.test.') || arg.includes('.spec.'));
+  if (!isTestFile) {
+    return;
+  }
+
+  // Check for lingering ngrok processes between tests
+  const hasProcesses = await checkNgrokProcesses();
+  if (hasProcesses) {
+    console.log('⚠️  Found lingering ngrok processes, cleaning up...');
+    await killAllNgrokProcesses();
+  }
+
+  // Clear the active processes set
+  activeNgrokProcesses.clear();
+});
+
+afterAll(async () => {
+  // Only run for test files
+  const isTestFile = process.argv.some((arg) => arg.includes('.test.') || arg.includes('.spec.'));
+  if (!isTestFile) {
+    return;
+  }
+
+  console.log('\n🧹 Final cleanup...');
+
+  // Kill any remaining ngrok processes
+  await killAllNgrokProcesses();
+
+  // Restore original environment
+  if (originalNgrokDomain) {
+    process.env.NGROK_DOMAIN = originalNgrokDomain;
+  }
+
+  console.log('✅ Cleanup complete\n');
+});
+
+// Export helper to track ngrok processes
+export function trackNgrokProcess(pid: number): void {
+  activeNgrokProcesses.add(pid);
+}
+
+export function untrackNgrokProcess(pid: number): void {
+  activeNgrokProcesses.delete(pid);
+}
+
+// Export the original domain for tests that need it
+export const ORIGINAL_NGROK_DOMAIN = originalNgrokDomain;

package/src/__tests__/test-utils.ts

@@ -0,0 +1,155 @@
+import type { IAgentRuntime, Memory, Service, ServiceTypeName, State } from '@elizaos/core';
+import { MockNgrokService } from './mocks/NgrokServiceMock';
+
+type MockRuntimeOverrides = Partial<IAgentRuntime> & {
+  settings?: Record<string, string>;
+  services?: Record<string, Service | null | undefined>;
+};
+
+// Local mock implementations until core test-utils build issue is resolved
+const createCoreMockRuntime = (overrides: MockRuntimeOverrides = {}) => ({
+  agentId: 'test-agent-id',
+  character: { name: 'TestAgent', bio: ['Test agent'], ...overrides.character },
+  getSetting: overrides.getSetting || (() => null),
+  getService: overrides.getService || (() => null),
+  useModel: overrides.useModel || (() => Promise.resolve('{}')),
+  composeState: overrides.composeState || (() => Promise.resolve({})),
+  getMemories: overrides.getMemories || (() => Promise.resolve([])),
+  createMemory: overrides.createMemory || (() => Promise.resolve()),
+  ...overrides,
+});
+
+const createCoreMockMemory = (overrides: Partial<Memory> = {}) => ({
+  id: 'test-memory-id',
+  entityId: 'test-entity-id',
+  roomId: 'test-room-id',
+  content: { text: 'test message' },
+  createdAt: Date.now(),
+  ...overrides,
+});
+
+const createCoreMockState = (overrides: Partial<State> = {}) => ({
+  text: 'test state',
+  ...overrides,
+});
+
+/**
+ * Creates a mock runtime for testing ngrok plugin
+ * Uses the unified mock runtime from core with ngrok-specific overrides
+ *
+ * @param overrides - Optional overrides for the default mock methods and properties
+ * @returns A mock runtime for testing
+ */
+export function createMockRuntime(overrides: MockRuntimeOverrides = {}): IAgentRuntime {
+  const {
+    settings: extraSettings = {},
+    services: extraServices = {},
+    ...runtimeOverrides
+  } = overrides;
+
+  // Use the unified mock runtime from core with ngrok-specific overrides
+  return createCoreMockRuntime({
+    character: {
+      name: 'NgrokTestAgent',
+      bio: ['Test agent for ngrok tunnel functionality'],
+      system: 'You are a test agent for ngrok tunnel management',
+      messageExamples: [],
+      postExamples: [],
+      topics: ['ngrok', 'tunneling', 'webhooks'],
+      knowledge: [],
+      plugins: ['@elizaos/plugin-ngrok'],
+      ...runtimeOverrides.character,
+    },
+
+    // Ngrok-specific settings
+    getSetting: (key: string): string | boolean | number | null => {
+      const settings: Record<string, string> = {
+        NGROK_AUTH_TOKEN: process.env.NGROK_AUTH_TOKEN || 'test-ngrok-auth-token',
+        NGROK_DOMAIN: process.env.NGROK_DOMAIN || '',
+        NGROK_REGION: 'us',
+        LOG_LEVEL: 'info',
+        ...extraSettings,
+      };
+      const direct = settings[key];
+      if (direct !== undefined) return direct;
+      const envVal = process.env[key];
+      return envVal === undefined ? null : envVal;
+    },
+
+    // Ngrok-specific services
+    getService: <T extends Service>(name: ServiceTypeName | string): T | null => {
+      const placeholderRuntime = { agentId: 'mock' } as IAgentRuntime;
+      const defaults: Record<string, Service> = {
+        'ngrok-tunnel': new MockNgrokService(placeholderRuntime),
+      };
+      const merged: Record<string, Service | null | undefined> = {
+        ...defaults,
+        ...extraServices,
+      };
+      const resolved = merged[String(name)];
+      return (resolved ?? null) as T | null;
+    },
+
+    ...runtimeOverrides,
+  }) as IAgentRuntime;
+}
+
+/**
+ * Creates a mock Memory object for testing
+ * Uses the unified mock with ngrok-specific defaults
+ */
+export function createMockMemory(overrides: Partial<Memory> = {}): Memory {
+  return createCoreMockMemory({
+    content: {
+      text: 'Ngrok tunnel test message',
+      source: 'ngrok-test',
+    },
+    ...overrides,
+  }) as Memory;
+}
+
+/**
+ * Creates a mock State object for testing
+ * Uses the unified mock with ngrok-specific defaults
+ */
+export function createMockState(overrides: Partial<State> = {}): State {
+  return createCoreMockState({
+    values: {
+      ngrokTunnelActive: false,
+      ngrokUrl: null,
+    },
+    text: 'Ngrok tunnel context',
+    ...overrides,
+  }) as State;
+}
+
+/**
+ * Sets up logger spies for common usage in tests
+ */
+type ConsoleMockFactory = (
+  implementation: (...args: unknown[]) => void
+) => (...args: unknown[]) => void;
+
+export function setupLoggerSpies(mockFn?: ConsoleMockFactory) {
+  const originalConsole = {
+    info: console.info,
+    error: console.error,
+    warn: console.warn,
+    debug: console.debug,
+  };
+
+  if (mockFn) {
+    console.info = mockFn(() => {});
+    console.error = mockFn(() => {});
+    console.warn = mockFn(() => {});
+    console.debug = mockFn(() => {});
+  }
+
+  // Allow tests to restore originals
+  return () => {
+    console.info = originalConsole.info;
+    console.error = originalConsole.error;
+    console.warn = originalConsole.warn;
+    console.debug = originalConsole.debug;
+  };
+}