@barndoor-ai/sdk 0.2.0

package/test/client.test.js

@@ -0,0 +1,381 @@
+/**
+ * Tests for the main BarndoorSDK client.
+ */
+
+import * as SDK from '../dist/index.esm.js';
+const { BarndoorSDK, ServerSummary, ServerDetail, HTTPError, ConfigurationError, TokenError } = SDK;
+
+// Mock fetch
+const mockFetch = {
+  fn: () => {},
+  mockResolvedValueOnce: value => {
+    mockFetch.fn = () => Promise.resolve(value);
+    return mockFetch;
+  },
+  mockRejectedValueOnce: error => {
+    mockFetch.fn = () => Promise.reject(error);
+    return mockFetch;
+  },
+  mockClear: () => {
+    mockFetch.fn = () => {};
+    mockFetch.calls = [];
+  },
+  calls: [],
+};
+
+global.fetch = (...args) => {
+  mockFetch.calls.push(args);
+  return mockFetch.fn(...args);
+};
+
+beforeEach(() => {
+  mockFetch.mockClear();
+});
+
+describe('BarndoorSDK Constructor', () => {
+  const validToken =
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+
+  test('creates SDK with valid parameters', () => {
+    const sdk = new BarndoorSDK('https://api.example.com', { token: validToken });
+
+    expect(sdk.base).toBe('https://api.example.com');
+    expect(sdk.token).toBe(validToken);
+    expect(sdk._closed).toBe(false);
+  });
+
+  test('strips trailing slash from base URL', () => {
+    const sdk = new BarndoorSDK('https://api.example.com/', { token: validToken });
+    expect(sdk.base).toBe('https://api.example.com');
+  });
+
+  test('methods throw when token not provided', async () => {
+    const sdk = new BarndoorSDK('https://api.example.com');
+    await expect(sdk.listServers()).rejects.toThrow('No token available');
+  });
+
+  test('throws when empty token is provided', () => {
+    expect(() => new BarndoorSDK('https://api.example.com', { token: '' })).toThrow(TokenError);
+  });
+
+  test('validates URL format', () => {
+    expect(() => new BarndoorSDK('invalid-url', { token: validToken })).toThrow(ConfigurationError);
+
+    expect(() => new BarndoorSDK('', { token: validToken })).toThrow(ConfigurationError);
+  });
+
+  test('validates token format', () => {
+    expect(() => new BarndoorSDK('https://api.example.com', { token: '' })).toThrow(TokenError);
+
+    expect(() => new BarndoorSDK('https://api.example.com', { token: 'invalid-jwt' })).toThrow(
+      TokenError
+    );
+  });
+
+  test('validates timeout parameter', () => {
+    expect(
+      () =>
+        new BarndoorSDK('https://api.example.com', {
+          token: validToken,
+          timeout: -1,
+        })
+    ).toThrow(ConfigurationError);
+
+    expect(
+      () =>
+        new BarndoorSDK('https://api.example.com', {
+          token: validToken,
+          timeout: 'invalid',
+        })
+    ).toThrow(ConfigurationError);
+  });
+
+  test('validates maxRetries parameter', () => {
+    expect(
+      () =>
+        new BarndoorSDK('https://api.example.com', {
+          token: validToken,
+          maxRetries: -1,
+        })
+    ).toThrow(ConfigurationError);
+
+    expect(
+      () =>
+        new BarndoorSDK('https://api.example.com', {
+          token: validToken,
+          maxRetries: 1.5,
+        })
+    ).toThrow(ConfigurationError);
+  });
+});
+
+describe('BarndoorSDK Methods', () => {
+  const validToken =
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+  let sdk;
+
+  beforeEach(() => {
+    // Mock environment to skip token validation
+    process.env.BARNDOOR_ENV = 'test';
+    sdk = new BarndoorSDK('https://api.example.com', { token: validToken });
+  });
+
+  afterEach(async () => {
+    if (sdk && typeof sdk.close === 'function') {
+      await sdk.close();
+    }
+    delete process.env.BARNDOOR_ENV;
+  });
+
+  describe('listServers', () => {
+    test('returns array of ServerSummary objects', async () => {
+      const mockServers = [
+        {
+          id: '123e4567-e89b-12d3-a456-426614174000',
+          name: 'Test Server 1',
+          slug: 'test-server-1',
+          provider: 'github',
+          connection_status: 'connected',
+        },
+        {
+          id: '123e4567-e89b-12d3-a456-426614174001',
+          name: 'Test Server 2',
+          slug: 'test-server-2',
+          provider: null,
+          connection_status: 'available',
+        },
+      ];
+
+      const mockPaginatedResponse = {
+        data: mockServers,
+        pagination: {
+          page: 1,
+          limit: 10,
+          total: 2,
+          pages: 1,
+          previous_page: null,
+          next_page: null,
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockPaginatedResponse),
+      });
+
+      const servers = await sdk.listServers();
+
+      expect(servers).toHaveLength(2);
+      expect(servers[0]).toBeInstanceOf(ServerSummary);
+      expect(servers[0].id).toBe(mockServers[0].id);
+      expect(servers[1]).toBeInstanceOf(ServerSummary);
+      expect(servers[1].provider).toBeNull();
+
+      expect(mockFetch.calls.length).toBe(1);
+      expect(mockFetch.calls[0][0]).toBe('https://api.example.com/servers');
+      expect(mockFetch.calls[0][1]).toEqual(
+        expect.objectContaining({
+          method: 'GET',
+          headers: expect.objectContaining({
+            Authorization: `Bearer ${validToken}`,
+          }),
+        })
+      );
+    });
+
+    test('handles empty server list', async () => {
+      const mockEmptyResponse = {
+        data: [],
+        pagination: {
+          page: 1,
+          limit: 10,
+          total: 0,
+          pages: 0,
+          previous_page: null,
+          next_page: null,
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockEmptyResponse),
+      });
+
+      const servers = await sdk.listServers();
+      expect(servers).toEqual([]);
+    });
+  });
+
+  describe('getServer', () => {
+    test('returns ServerDetail object', async () => {
+      const serverId = '123e4567-e89b-12d3-a456-426614174000';
+      const mockServer = {
+        id: serverId,
+        name: 'Test Server',
+        slug: 'test-server',
+        provider: 'github',
+        connection_status: 'connected',
+        url: 'https://api.example.com/mcp',
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockServer),
+      });
+
+      const server = await sdk.getServer(serverId);
+
+      expect(server).toBeInstanceOf(ServerDetail);
+      expect(server.id).toBe(serverId);
+      expect(server.url).toBe(mockServer.url);
+
+      expect(mockFetch.calls[0][0]).toBe(`https://api.example.com/servers/${serverId}`);
+      expect(mockFetch.calls[0][1]).toEqual(expect.objectContaining({ method: 'GET' }));
+    });
+
+    test('validates server ID format', async () => {
+      await expect(sdk.getServer('invalid_uuid!')).rejects.toThrow(
+        'Server ID must be a valid UUID or slug'
+      );
+
+      await expect(sdk.getServer('')).rejects.toThrow('Server ID must be a non-empty string');
+    });
+  });
+
+  describe('initiateConnection', () => {
+    const serverId = '123e4567-e89b-12d3-a456-426614174000';
+
+    test('initiates connection without return URL', async () => {
+      const mockResponse = {
+        connection_id: 'conn-123',
+        auth_url: 'https://auth.example.com/oauth/authorize?...',
+        state: 'random-state',
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      const result = await sdk.initiateConnection(serverId);
+
+      expect(result).toEqual(mockResponse);
+      expect(mockFetch.calls.length).toBe(1);
+      expect(mockFetch.calls[0][0]).toBe(`https://api.example.com/servers/${serverId}/connect`);
+      expect(mockFetch.calls[0][1]).toEqual(
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({}),
+        })
+      );
+    });
+
+    test('initiates connection with return URL', async () => {
+      const returnUrl = 'https://app.example.com/callback';
+      const mockResponse = { auth_url: 'https://auth.example.com/...' };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      await sdk.initiateConnection(serverId, returnUrl);
+
+      expect(mockFetch.calls.length).toBe(1);
+      expect(mockFetch.calls[0][0]).toBe(
+        `https://api.example.com/servers/${serverId}/connect?return_url=${encodeURIComponent(returnUrl)}`
+      );
+      expect(mockFetch.calls[0][1]).toEqual(expect.any(Object));
+    });
+
+    test('handles OAuth configuration error', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        text: () => Promise.resolve('OAuth server configuration not found'),
+      });
+
+      await expect(sdk.initiateConnection(serverId)).rejects.toThrow(
+        'Server is missing OAuth configuration'
+      );
+    });
+  });
+
+  describe('getConnectionStatus', () => {
+    test('returns connection status', async () => {
+      const serverId = '123e4567-e89b-12d3-a456-426614174000';
+      const mockResponse = { status: 'connected' };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      const status = await sdk.getConnectionStatus(serverId);
+
+      expect(status).toBe('connected');
+      expect(mockFetch.calls.length).toBe(1);
+      expect(mockFetch.calls[0][0]).toBe(`https://api.example.com/servers/${serverId}/connection`);
+      expect(mockFetch.calls[0][1]).toEqual(
+        expect.objectContaining({
+          method: 'GET',
+        })
+      );
+    });
+  });
+
+  describe('disconnectServer', () => {
+    const serverId = '123e4567-e89b-12d3-a456-426614174000';
+
+    test('successfully disconnects from server', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 204,
+      });
+
+      await sdk.disconnectServer(serverId);
+
+      expect(mockFetch.calls.length).toBe(1);
+      expect(mockFetch.calls[0][0]).toBe(`https://api.example.com/servers/${serverId}/connection`);
+      expect(mockFetch.calls[0][1]).toEqual(
+        expect.objectContaining({
+          method: 'DELETE',
+        })
+      );
+    });
+
+    test('throws error when connection not found', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        json: () =>
+          Promise.resolve({
+            error: 'ConnectionNotFound',
+            message: 'Connection not found',
+          }),
+      });
+
+      await expect(sdk.disconnectServer(serverId)).rejects.toThrow(/Connection not found/i);
+    });
+
+    test('validates server ID format', async () => {
+      await expect(sdk.disconnectServer('invalid_server_id!')).rejects.toThrow(
+        'Server ID must be a valid UUID or slug'
+      );
+    });
+  });
+
+  describe('cleanup', () => {
+    test('close() prevents further requests', async () => {
+      await sdk.close();
+
+      await expect(sdk.listServers()).rejects.toThrow('SDK has been closed');
+    });
+
+    test('aclose() is alias for close()', async () => {
+      await sdk.aclose();
+      expect(sdk._closed).toBe(true);
+    });
+  });
+});

package/test/config.test.js

@@ -0,0 +1,202 @@
+/**
+ * Tests for configuration management.
+ */
+
+import {
+  BarndoorConfig,
+  getStaticConfig,
+  getDynamicConfig,
+  ConfigurationError,
+} from '../dist/index.esm.js';
+
+// Mock process.env for testing
+const originalEnv = process.env;
+
+beforeEach(() => {
+  // Reset environment variables
+  process.env = { ...originalEnv };
+});
+
+afterAll(() => {
+  process.env = originalEnv;
+});
+
+describe('BarndoorConfig', () => {
+  test('creates config with default values', () => {
+    const config = new BarndoorConfig();
+
+    expect(config.authDomain).toBe('auth.barndoor.ai');
+    expect(config.clientId).toBe('');
+    expect(config.clientSecret).toBe('');
+    expect(config.apiAudience).toBe('https://barndoor.ai/');
+    expect(config.environment).toBe('production');
+    expect(config.promptForLogin).toBe(false);
+    expect(config.skipLoginLocal).toBe(false);
+  });
+
+  test('uses environment variables when available', () => {
+    process.env.AUTH_DOMAIN = 'custom.auth0.com';
+    process.env.AGENT_CLIENT_ID = 'test-client-id';
+    process.env.AGENT_CLIENT_SECRET = 'test-client-secret';
+    process.env.API_AUDIENCE = 'https://custom.api/';
+    process.env.BARNDOOR_ENV = 'development';
+
+    const config = new BarndoorConfig();
+
+    expect(config.authDomain).toBe('custom.auth0.com');
+    expect(config.clientId).toBe('test-client-id');
+    expect(config.clientSecret).toBe('test-client-secret');
+    expect(config.apiAudience).toBe('https://custom.api/');
+    expect(config.environment).toBe('development');
+  });
+
+  test('constructor options override environment variables', () => {
+    process.env.AUTH_DOMAIN = 'env.auth0.com';
+
+    const config = new BarndoorConfig({
+      authDomain: 'override.auth0.com',
+    });
+
+    expect(config.authDomain).toBe('override.auth0.com');
+  });
+
+  test('sets environment-specific defaults for localdev', () => {
+    const config = new BarndoorConfig({ environment: 'localdev' });
+
+    expect(config.apiBaseUrl).toBe('http://localhost:8000');
+    expect(config.mcpBaseUrl).toBe('http://localhost:8000');
+  });
+
+  test('sets environment-specific defaults for development', () => {
+    const config = new BarndoorConfig({ environment: 'development' });
+
+    expect(config.apiBaseUrl).toBe('https://api.barndoordev.com');
+    expect(config.mcpBaseUrl).toBe('https://{organization_id}.mcp.barndoordev.com');
+  });
+
+  test('sets environment-specific defaults for production', () => {
+    const config = new BarndoorConfig({ environment: 'production' });
+
+    expect(config.apiBaseUrl).toBe('https://api.barndoor.ai');
+    expect(config.mcpBaseUrl).toBe('https://{organization_id}.mcp.barndoor.ai');
+  });
+
+  test('respects custom URLs even in specific environments', () => {
+    process.env.BARNDOOR_API = 'https://custom.api.com';
+    process.env.BARNDOOR_URL = 'https://custom.mcp.com';
+
+    const config = new BarndoorConfig({ environment: 'localdev' });
+
+    expect(config.apiBaseUrl).toBe('https://custom.api.com');
+    expect(config.mcpBaseUrl).toBe('https://custom.mcp.com');
+  });
+
+  test('MCP env var precedence prefers BARNDOOR_MCP over BARNDOOR_URL', () => {
+    process.env.BARNDOOR_MCP = 'https://mcp.preferred.com';
+    process.env.BARNDOOR_URL = 'https://mcp.legacy.com';
+
+    const config = new BarndoorConfig({ environment: 'development' });
+    expect(config.mcpBaseUrl).toBe('https://mcp.preferred.com');
+  });
+
+  test('options override API/MCP env vars', () => {
+    process.env.BARNDOOR_API = 'https://api.env.com';
+    process.env.BARNDOOR_MCP = 'https://mcp.env.com';
+
+    const config = new BarndoorConfig({
+      environment: 'production',
+      apiBaseUrl: 'https://api.options.com',
+      mcpBaseUrl: 'https://mcp.options.com',
+    });
+
+    expect(config.apiBaseUrl).toBe('https://api.options.com');
+    expect(config.mcpBaseUrl).toBe('https://mcp.options.com');
+  });
+
+  test('validation passes for valid config', () => {
+    const config = new BarndoorConfig();
+    expect(() => config.validate()).not.toThrow();
+  });
+
+  test('validation fails for missing required fields', () => {
+    const config = new BarndoorConfig({ authDomain: '' });
+    expect(() => config.validate()).toThrow(ConfigurationError);
+    expect(() => config.validate()).toThrow('authDomain is required');
+  });
+});
+
+describe('Static Configuration', () => {
+  test('getStaticConfig returns BarndoorConfig instance', () => {
+    const config = getStaticConfig();
+    expect(config).toBeInstanceOf(BarndoorConfig);
+  });
+
+  test('BarndoorConfig.getStaticConfig returns same as function', () => {
+    const config1 = getStaticConfig();
+    const config2 = BarndoorConfig.getStaticConfig();
+
+    expect(config1.authDomain).toBe(config2.authDomain);
+    expect(config1.apiAudience).toBe(config2.apiAudience);
+  });
+});
+
+describe('Dynamic Configuration', () => {
+  const mockJwtToken =
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwczovL2Jhcm5kb29yLmFpL29yZ2FuaXphdGlvbl9pZCI6InRlc3Qtb3JnIiwiaWF0IjoxNjAwMDAwMDAwLCJleHAiOjE2MDAwMDM2MDB9.signature';
+
+  test('getDynamicConfig substitutes organization ID', () => {
+    const config = getDynamicConfig(mockJwtToken);
+
+    expect(config.apiBaseUrl).toBe('https://api.barndoor.ai');
+    expect(config.mcpBaseUrl).toBe('https://test-org.mcp.barndoor.ai');
+  });
+
+  test('BarndoorConfig.getDynamicConfig works the same', () => {
+    const config1 = getDynamicConfig(mockJwtToken);
+    const config2 = BarndoorConfig.getDynamicConfig(mockJwtToken);
+
+    expect(config1.apiBaseUrl).toBe(config2.apiBaseUrl);
+    expect(config1.mcpBaseUrl).toBe(config2.mcpBaseUrl);
+  });
+
+  test('throws error for invalid JWT token', () => {
+    expect(() => getDynamicConfig('invalid-token')).toThrow(ConfigurationError);
+    expect(() => getDynamicConfig('invalid-token')).toThrow('Failed to extract organization ID');
+  });
+
+  test('throws error for JWT without organization ID', () => {
+    const tokenWithoutOrgId =
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE2MDAwMDAwMDAsImV4cCI6MTYwMDAwMzYwMH0.signature';
+
+    expect(() => getDynamicConfig(tokenWithoutOrgId)).toThrow(ConfigurationError);
+    expect(() => getDynamicConfig(tokenWithoutOrgId)).toThrow(
+      'No organization information found in token'
+    );
+  });
+});
+
+describe('Environment Detection', () => {
+  test('environment priority: MODE > BARNDOOR_ENV > default', () => {
+    process.env.MODE = 'test-mode';
+    process.env.BARNDOOR_ENV = 'test-barndoor-env';
+
+    const config = new BarndoorConfig();
+    expect(config.environment).toBe('test-mode');
+
+    delete process.env.MODE;
+    const config2 = new BarndoorConfig();
+    expect(config2.environment).toBe('test-barndoor-env');
+
+    delete process.env.BARNDOOR_ENV;
+    const config3 = new BarndoorConfig();
+    expect(config3.environment).toBe('production');
+  });
+
+  test('case insensitive environment matching', () => {
+    const localConfig = new BarndoorConfig({ environment: 'LOCALDEV' });
+    expect(localConfig.apiBaseUrl).toBe('http://localhost:8000');
+
+    const devConfig = new BarndoorConfig({ environment: 'DEV' });
+    expect(devConfig.apiBaseUrl).toBe('https://api.barndoordev.com');
+  });
+});