signalwire-agents 0.1.0

package/tests/ServerlessAdapter.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ServerlessAdapter } from '../src/ServerlessAdapter.js';
+import { AgentBase } from '../src/AgentBase.js';
+import { SwaigFunctionResult } from '../src/SwaigFunctionResult.js';
+import { suppressAllLogs } from '../src/Logger.js';
+
+describe('ServerlessAdapter', () => {
+  beforeEach(() => suppressAllLogs(true));
+  afterEach(() => suppressAllLogs(false));
+
+  it('detectPlatform returns lambda for AWS env', () => {
+    const saved = process.env['AWS_LAMBDA_FUNCTION_NAME'];
+    process.env['AWS_LAMBDA_FUNCTION_NAME'] = 'my-func';
+    try {
+      const adapter = new ServerlessAdapter('auto');
+      expect(adapter.getPlatform()).toBe('lambda');
+    } finally {
+      if (saved) process.env['AWS_LAMBDA_FUNCTION_NAME'] = saved;
+      else delete process.env['AWS_LAMBDA_FUNCTION_NAME'];
+    }
+  });
+
+  it('detectPlatform returns gcf for Google env', () => {
+    const saved = process.env['FUNCTION_TARGET'];
+    process.env['FUNCTION_TARGET'] = 'handler';
+    try {
+      const adapter = new ServerlessAdapter('auto');
+      expect(adapter.getPlatform()).toBe('gcf');
+    } finally {
+      if (saved) process.env['FUNCTION_TARGET'] = saved;
+      else delete process.env['FUNCTION_TARGET'];
+    }
+  });
+
+  it('explicit platform overrides detection', () => {
+    const adapter = new ServerlessAdapter('azure');
+    expect(adapter.getPlatform()).toBe('azure');
+  });
+
+  it('handleRequest routes through Hono app', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    const response = await adapter.handleRequest(app, {
+      httpMethod: 'GET',
+      path: '/health',
+      headers: { host: 'localhost' },
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = JSON.parse(response.body);
+    expect(body.status).toBe('ok');
+  });
+
+  it('handleRequest passes POST body', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    agent.defineTool({
+      name: 'echo',
+      description: 'Echo back',
+      parameters: { msg: { type: 'string' } },
+      handler: (args) => new SwaigFunctionResult(`Echo: ${args['msg']}`),
+    });
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    const response = await adapter.handleRequest(app, {
+      httpMethod: 'POST',
+      path: '/swaig',
+      headers: {
+        host: 'localhost',
+        'content-type': 'application/json',
+        authorization: 'Basic ' + Buffer.from('u:p').toString('base64'),
+      },
+      body: JSON.stringify({ function: 'echo', argument: { msg: 'hi' } }),
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = JSON.parse(response.body);
+    expect(body.response).toContain('Echo: hi');
+  });
+
+  it('handleRequest handles query parameters', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    const response = await adapter.handleRequest(app, {
+      httpMethod: 'GET',
+      path: '/health',
+      headers: { host: 'localhost' },
+      queryStringParameters: { foo: 'bar' },
+    });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('generateUrl produces Lambda URL', () => {
+    const adapter = new ServerlessAdapter('lambda');
+    const url = adapter.generateUrl({ region: 'us-west-2', apiId: 'abc123', stage: 'dev' });
+    expect(url).toContain('us-west-2');
+    expect(url).toContain('abc123');
+    expect(url).toContain('dev');
+  });
+
+  it('generateUrl produces GCF URL', () => {
+    const adapter = new ServerlessAdapter('gcf');
+    const url = adapter.generateUrl({ projectId: 'my-proj', region: 'us-central1', functionName: 'agent' });
+    expect(url).toContain('my-proj');
+    expect(url).toContain('us-central1');
+    expect(url).toContain('agent');
+  });
+
+  it('generateUrl produces Azure URL', () => {
+    const adapter = new ServerlessAdapter('azure');
+    const url = adapter.generateUrl({ functionName: 'my-agent' });
+    expect(url).toContain('my-agent');
+    expect(url).toContain('azurewebsites.net');
+  });
+
+  it('generateUrl produces CGI URL', () => {
+    const adapter = new ServerlessAdapter('cgi');
+    const url = adapter.generateUrl({ functionName: 'agent' });
+    expect(url).toContain('cgi-bin');
+  });
+
+  it('createLambdaHandler returns a function', () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    const handler = ServerlessAdapter.createLambdaHandler(agent.getApp());
+    expect(typeof handler).toBe('function');
+  });
+
+  it('Lambda handler processes requests', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const handler = ServerlessAdapter.createLambdaHandler(agent.getApp());
+
+    const response = await handler({
+      httpMethod: 'GET',
+      path: '/health',
+      headers: { host: 'localhost' },
+    });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('handleRequest uses rawPath if available', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    const response = await adapter.handleRequest(app, {
+      httpMethod: 'GET',
+      rawPath: '/health',
+      headers: { host: 'localhost' },
+    });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('handleRequest defaults to POST method', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    // No httpMethod specified
+    const response = await adapter.handleRequest(app, {
+      path: '/',
+      headers: {
+        host: 'localhost',
+        authorization: 'Basic ' + Buffer.from('u:p').toString('base64'),
+        'content-type': 'application/json',
+      },
+      body: '{}',
+    });
+
+    expect(response.statusCode).toBe(200);
+  });
+
+  it('response includes headers', async () => {
+    const agent = new AgentBase({ name: 'test', route: '/', basicAuth: ['u', 'p'] });
+    agent.setPromptText('hello');
+    const app = agent.getApp();
+    const adapter = new ServerlessAdapter('lambda');
+
+    const response = await adapter.handleRequest(app, {
+      httpMethod: 'GET',
+      path: '/health',
+      headers: { host: 'localhost' },
+    });
+
+    expect(response.headers).toBeDefined();
+    expect(response.headers['content-type']).toContain('application/json');
+  });
+});

package/tests/SessionManager.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { SessionManager } from '../src/SessionManager.js';
+
+describe('SessionManager', () => {
+  it('createSession generates an ID when none provided', () => {
+    const sm = new SessionManager();
+    const id = sm.createSession();
+    expect(id).toBeTruthy();
+    expect(typeof id).toBe('string');
+  });
+
+  it('createSession returns provided ID', () => {
+    const sm = new SessionManager();
+    expect(sm.createSession('my-call')).toBe('my-call');
+  });
+
+  it('generateToken produces a base64url string', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('get_time', 'call-1');
+    expect(typeof token).toBe('string');
+    // Should be valid base64url
+    expect(() => Buffer.from(token, 'base64url').toString()).not.toThrow();
+  });
+
+  it('validateToken accepts a valid token', () => {
+    const sm = new SessionManager();
+    const callId = 'call-1';
+    const fn = 'get_time';
+    const token = sm.generateToken(fn, callId);
+    expect(sm.validateToken(callId, fn, token)).toBe(true);
+  });
+
+  it('validateToken rejects wrong function name', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('fn_a', 'call-1');
+    expect(sm.validateToken('call-1', 'fn_b', token)).toBe(false);
+  });
+
+  it('validateToken rejects wrong call id', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('fn', 'call-1');
+    expect(sm.validateToken('call-2', 'fn', token)).toBe(false);
+  });
+
+  it('validateToken rejects expired tokens', () => {
+    const sm = new SessionManager(0); // 0 second expiry
+    const token = sm.generateToken('fn', 'call-1');
+    // Token is immediately expired (or within ms)
+    // Wait a tiny bit to ensure expiry
+    const result = sm.validateToken('call-1', 'fn', token);
+    // With 0 expiry the token expires at creation time, so it should be invalid
+    expect(result).toBe(false);
+  });
+
+  it('validateToken rejects tampered tokens', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('fn', 'call-1');
+    // Tamper with the token
+    const tampered = token.slice(0, -2) + 'XX';
+    expect(sm.validateToken('call-1', 'fn', tampered)).toBe(false);
+  });
+
+  it('validateToken rejects tokens from different secret', () => {
+    const sm1 = new SessionManager(3600, 'secret-1');
+    const sm2 = new SessionManager(3600, 'secret-2');
+    const token = sm1.generateToken('fn', 'call-1');
+    expect(sm2.validateToken('call-1', 'fn', token)).toBe(false);
+  });
+
+  it('aliases work', () => {
+    const sm = new SessionManager();
+    const callId = 'call-1';
+    const fn = 'fn';
+    const token = sm.createToolToken(fn, callId);
+    expect(sm.validateToolToken(fn, token, callId)).toBe(true);
+  });
+
+  it('validates token when callId is empty (uses token callId)', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('fn', 'call-1');
+    // Empty callId should use token's embedded callId
+    expect(sm.validateToken('', 'fn', token)).toBe(true);
+  });
+
+  // ── Pass 1: debugToken + session metadata ────────────────────────
+
+  it('debugToken decodes token components', () => {
+    const sm = new SessionManager();
+    const token = sm.generateToken('get_time', 'call-42');
+    const info = sm.debugToken(token);
+    expect(info).not.toBeNull();
+    expect(info!.callId).toBe('call-42');
+    expect(info!.functionName).toBe('get_time');
+    expect(typeof info!.expiry).toBe('number');
+    expect(typeof info!.nonce).toBe('string');
+    expect(typeof info!.signature).toBe('string');
+    expect(info!.expired).toBe(false);
+  });
+
+  it('debugToken returns null for invalid token', () => {
+    const sm = new SessionManager();
+    expect(sm.debugToken('not-valid')).toBeNull();
+  });
+
+  it('debugToken shows expired status for expired tokens', () => {
+    const sm = new SessionManager(0); // 0 second expiry
+    const token = sm.generateToken('fn', 'call-1');
+    const info = sm.debugToken(token);
+    expect(info).not.toBeNull();
+    expect(info!.expired).toBe(true);
+  });
+
+  it('setSessionMetadata stores and retrieves metadata', () => {
+    const sm = new SessionManager();
+    sm.setSessionMetadata('session-1', { caller: 'John', topic: 'billing' });
+    const meta = sm.getSessionMetadata('session-1');
+    expect(meta).toEqual({ caller: 'John', topic: 'billing' });
+  });
+
+  it('setSessionMetadata merges with existing metadata', () => {
+    const sm = new SessionManager();
+    sm.setSessionMetadata('session-1', { caller: 'John' });
+    sm.setSessionMetadata('session-1', { topic: 'billing' });
+    const meta = sm.getSessionMetadata('session-1');
+    expect(meta).toEqual({ caller: 'John', topic: 'billing' });
+  });
+
+  it('getSessionMetadata returns undefined for unknown session', () => {
+    const sm = new SessionManager();
+    expect(sm.getSessionMetadata('nope')).toBeUndefined();
+  });
+
+  it('deleteSessionMetadata removes metadata', () => {
+    const sm = new SessionManager();
+    sm.setSessionMetadata('session-1', { key: 'val' });
+    expect(sm.deleteSessionMetadata('session-1')).toBe(true);
+    expect(sm.getSessionMetadata('session-1')).toBeUndefined();
+  });
+});

package/tests/SslConfig.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { SslConfig } from '../src/SslConfig.js';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+const TEST_DIR = join(process.cwd(), '__ssl_test_tmp__');
+
+describe('SslConfig', () => {
+  beforeAll(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    writeFileSync(join(TEST_DIR, 'cert.pem'), '-----BEGIN CERTIFICATE-----\ntest\n-----END CERTIFICATE-----');
+    writeFileSync(join(TEST_DIR, 'key.pem'), '-----BEGIN PRIVATE KEY-----\ntest\n-----END PRIVATE KEY-----');
+  });
+
+  afterAll(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it('defaults to disabled', () => {
+    const ssl = new SslConfig();
+    expect(ssl.enabled).toBe(false);
+    expect(ssl.isConfigured()).toBe(false);
+  });
+
+  it('can be enabled via options', () => {
+    const ssl = new SslConfig({
+      enabled: true,
+      certPath: join(TEST_DIR, 'cert.pem'),
+      keyPath: join(TEST_DIR, 'key.pem'),
+    });
+    expect(ssl.enabled).toBe(true);
+    expect(ssl.isConfigured()).toBe(true);
+  });
+
+  it('isConfigured returns false when files missing', () => {
+    const ssl = new SslConfig({
+      enabled: true,
+      certPath: '/nonexistent/cert.pem',
+      keyPath: '/nonexistent/key.pem',
+    });
+    expect(ssl.isConfigured()).toBe(false);
+  });
+
+  it('getCert reads certificate file', () => {
+    const ssl = new SslConfig({
+      enabled: true,
+      certPath: join(TEST_DIR, 'cert.pem'),
+      keyPath: join(TEST_DIR, 'key.pem'),
+    });
+    const cert = ssl.getCert();
+    expect(cert).toContain('BEGIN CERTIFICATE');
+  });
+
+  it('getKey reads key file', () => {
+    const ssl = new SslConfig({
+      enabled: true,
+      certPath: join(TEST_DIR, 'cert.pem'),
+      keyPath: join(TEST_DIR, 'key.pem'),
+    });
+    const key = ssl.getKey();
+    expect(key).toContain('BEGIN PRIVATE KEY');
+  });
+
+  it('getCert returns null for missing file', () => {
+    const ssl = new SslConfig({ enabled: true, certPath: '/missing' });
+    expect(ssl.getCert()).toBeNull();
+  });
+
+  it('getHstsHeader returns HSTS value when enabled', () => {
+    const ssl = new SslConfig({ enabled: true, hsts: true });
+    const header = ssl.getHstsHeader();
+    expect(header).toContain('max-age=31536000');
+    expect(header).toContain('includeSubDomains');
+  });
+
+  it('getHstsHeader returns null when disabled', () => {
+    const ssl = new SslConfig({ enabled: false });
+    expect(ssl.getHstsHeader()).toBeNull();
+  });
+
+  it('getServerOptions returns cert and key', () => {
+    const ssl = new SslConfig({
+      enabled: true,
+      certPath: join(TEST_DIR, 'cert.pem'),
+      keyPath: join(TEST_DIR, 'key.pem'),
+    });
+    const opts = ssl.getServerOptions();
+    expect(opts).not.toBeNull();
+    expect(opts!.cert).toContain('CERTIFICATE');
+    expect(opts!.key).toContain('PRIVATE KEY');
+  });
+
+  it('getServerOptions returns null when files missing', () => {
+    const ssl = new SslConfig({ enabled: true });
+    expect(ssl.getServerOptions()).toBeNull();
+  });
+});