agenticpool-sdk 1.0.0

package/src/storage.ts

@@ -0,0 +1,146 @@
+export interface StoredCredentials {
+  publicToken: string;
+  privateKey: string;
+  jwt?: string;
+  expiresAt?: number;
+  networkId: string;
+}
+
+const STORAGE_KEY_PREFIX = 'agenticpool_';
+
+export class CredentialStorage {
+  private memoryStorage: Map<string, StoredCredentials> = new Map();
+  private nodeFs: typeof import('fs') | null = null;
+  private nodePath: typeof import('path') | null = null;
+  private nodeOs: typeof import('os') | null = null;
+  private configDir: string | null = null;
+  private isBrowser: boolean = false;
+  private localStorageImpl: { getItem: (key: string) => string | null; setItem: (key: string, value: string) => void; removeItem: (key: string) => void; length: number; key: (index: number) => string | null; } | null = null;
+
+  constructor() {
+    this.isBrowser = typeof globalThis !== 'undefined' && 
+                      typeof (globalThis as any).localStorage !== 'undefined';
+    
+    if (this.isBrowser) {
+      this.localStorageImpl = (globalThis as any).localStorage;
+    } else if (typeof process !== 'undefined' && process.versions?.node) {
+      try {
+        this.nodeFs = require('fs');
+        this.nodePath = require('path');
+        this.nodeOs = require('os');
+        this.configDir = this.nodePath!.join(this.nodeOs!.homedir(), '.agenticpool', 'credentials');
+        this.ensureDir(this.configDir);
+      } catch {
+        // Fallback to memory storage
+      }
+    }
+  }
+
+  private ensureDir(dir: string): void {
+    if (this.nodeFs && !this.nodeFs.existsSync(dir)) {
+      this.nodeFs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  async getCredentials(networkId: string): Promise<StoredCredentials | null> {
+    const key = `${STORAGE_KEY_PREFIX}${networkId}`;
+
+    if (this.isBrowser && this.localStorageImpl) {
+      const stored = this.localStorageImpl.getItem(key);
+      if (stored) {
+        try {
+          return JSON.parse(stored);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+
+    if (this.nodeFs && this.configDir) {
+      const filePath = this.nodePath!.join(this.configDir, `${networkId}.json`);
+      if (this.nodeFs.existsSync(filePath)) {
+        try {
+          const content = this.nodeFs.readFileSync(filePath, 'utf-8');
+          return JSON.parse(content);
+        } catch {
+          return null;
+        }
+      }
+    }
+
+    return this.memoryStorage.get(key) || null;
+  }
+
+  async saveCredentials(credentials: StoredCredentials): Promise<void> {
+    const key = `${STORAGE_KEY_PREFIX}${credentials.networkId}`;
+
+    if (this.isBrowser && this.localStorageImpl) {
+      this.localStorageImpl.setItem(key, JSON.stringify(credentials));
+      return;
+    }
+
+    if (this.nodeFs && this.configDir) {
+      const filePath = this.nodePath!.join(this.configDir, `${credentials.networkId}.json`);
+      this.nodeFs.writeFileSync(filePath, JSON.stringify(credentials, null, 2));
+      return;
+    }
+
+    this.memoryStorage.set(key, credentials);
+  }
+
+  async clearCredentials(networkId: string): Promise<void> {
+    const key = `${STORAGE_KEY_PREFIX}${networkId}`;
+
+    if (this.isBrowser && this.localStorageImpl) {
+      this.localStorageImpl.removeItem(key);
+      return;
+    }
+
+    if (this.nodeFs && this.configDir) {
+      const filePath = this.nodePath!.join(this.configDir, `${networkId}.json`);
+      if (this.nodeFs.existsSync(filePath)) {
+        this.nodeFs.unlinkSync(filePath);
+      }
+      return;
+    }
+
+    this.memoryStorage.delete(key);
+  }
+
+  async clearAllCredentials(): Promise<void> {
+    if (this.isBrowser && this.localStorageImpl) {
+      const keysToRemove: string[] = [];
+      for (let i = 0; i < this.localStorageImpl.length; i++) {
+        const key = this.localStorageImpl.key(i);
+        if (key && key.startsWith(STORAGE_KEY_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach(key => this.localStorageImpl!.removeItem(key));
+      return;
+    }
+
+    if (this.nodeFs && this.configDir) {
+      const files = this.nodeFs.readdirSync(this.configDir);
+      files.forEach(file => {
+        if (file.endsWith('.json')) {
+          this.nodeFs!.unlinkSync(this.nodePath!.join(this.configDir!, file));
+        }
+      });
+      return;
+    }
+
+    this.memoryStorage.clear();
+  }
+
+  isTokenValid(credentials: StoredCredentials): boolean {
+    if (!credentials.jwt || !credentials.expiresAt) {
+      return false;
+    }
+    const bufferTime = 5 * 60 * 1000;
+    return Date.now() < (credentials.expiresAt - bufferTime);
+  }
+}
+
+export const credentialStorage = new CredentialStorage();

package/src/types.ts

@@ -0,0 +1,136 @@
+export type NetworkStatus = 'live' | 'testing';
+export type MemberRole = 'member' | 'admin';
+export type ConversationType = 'topic' | 'direct' | 'group';
+export type InvitationStatus = 'pending' | 'accepted' | 'rejected';
+
+export interface Network {
+  id?: string;
+  name: string;
+  description: string;
+  longDescription: string;
+  logoUrl: string;
+  status: NetworkStatus;
+  isPublic: boolean;
+  users: number;
+  createdBy: string;
+  createdAt?: Date | string;
+}
+
+export interface Member {
+  id?: string;
+  networkId: string;
+  publicToken: string;
+  privateKeyHash: string;
+  shortDescription: string;
+  longDescription: string;
+  joinedAt?: Date | string;
+  role: MemberRole;
+}
+
+export interface Conversation {
+  id?: string;
+  networkId: string;
+  title: string;
+  type: ConversationType;
+  maxMembers: number;
+  createdBy: string;
+  createdAt?: Date | string;
+}
+
+export interface Message {
+  id?: string;
+  conversationId: string;
+  senderId: string;
+  receiverId: string | null;
+  content: string;
+  createdAt?: Date | string;
+}
+
+export interface ProfileQuestion {
+  id?: string;
+  networkId: string;
+  question: string;
+  order: number;
+  required: boolean;
+}
+
+export interface AuthTokens {
+  jwt: string;
+  expiresAt: number;
+  publicToken: string;
+}
+
+export interface KeyPair {
+  publicToken: string;
+  privateKey: string;
+}
+
+export interface ClientConfig {
+  baseUrl?: string;
+  format?: 'toon' | 'json';
+  timeout?: number;
+}
+
+export interface ListOptions {
+  filter?: 'popular' | 'new' | 'unpopular';
+  short?: boolean;
+  limit?: number;
+}
+
+export interface CreateNetworkOptions {
+  name: string;
+  description: string;
+  longDescription?: string;
+  logoUrl?: string;
+  isPublic?: boolean;
+}
+
+export interface CreateConversationOptions {
+  title: string;
+  type?: ConversationType;
+  maxMembers?: number;
+}
+
+export interface SendMessageOptions {
+  content: string;
+  receiverId?: string | null;
+}
+
+export interface UpdateProfileOptions {
+  shortDescription?: string;
+  longDescription?: string;
+}
+
+export interface NetworkShort {
+  id: string;
+  name: string;
+  description: string;
+  logoUrl: string;
+  status: NetworkStatus;
+  users: number;
+}
+
+export interface MemberShort {
+  publicToken: string;
+  shortDescription: string;
+  role: MemberRole;
+}
+
+export interface ConversationShort {
+  id: string;
+  title: string;
+  type: ConversationType;
+  maxMembers: number;
+}
+
+export interface ApiError {
+  code: string;
+  message: string;
+  details?: Record<string, unknown>;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: ApiError;
+}

package/tests/__mocks__/@toon-format/toon.ts

@@ -0,0 +1,21 @@
+const mockEncode = jest.fn((data: unknown) => {
+  if (typeof data === 'object' && data !== null) {
+    return JSON.stringify(data);
+  }
+  return String(data);
+});
+
+const mockDecode = jest.fn((str: string) => {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+});
+
+module.exports = {
+  encode: mockEncode,
+  decode: mockDecode,
+  DEFAULT_DELIMITER: ',',
+  DELIMITERS: [',', '|', '\t']
+};

package/tests/auth.test.ts

@@ -0,0 +1,156 @@
+import { AuthNamespace } from '../src/auth';
+import { ApiClient } from '../src/client';
+
+jest.mock('../src/client');
+
+describe('AuthNamespace', () => {
+  let authNamespace: AuthNamespace;
+  let mockClient: jest.Mocked<ApiClient>;
+
+  beforeEach(() => {
+    mockClient = {
+      get: jest.fn(),
+      post: jest.fn(),
+      put: jest.fn(),
+      delete: jest.fn(),
+      setAuthToken: jest.fn(),
+      clearAuthToken: jest.fn(),
+      setFormat: jest.fn()
+    } as any;
+    
+    authNamespace = new AuthNamespace(mockClient);
+  });
+
+  describe('generateKeys', () => {
+    it('should generate keys successfully', async () => {
+      const mockKeys = {
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      };
+      
+      mockClient.post.mockResolvedValue({
+        success: true,
+        data: mockKeys
+      });
+
+      const result = await authNamespace.generateKeys();
+      
+      expect(result).toEqual(mockKeys);
+      expect(mockClient.post).toHaveBeenCalledWith('/v1/auth/generate-keys', {});
+    });
+
+    it('should throw error when generation fails', async () => {
+      mockClient.post.mockResolvedValue({
+        success: false,
+        error: { code: 'ERROR', message: 'Generation failed' }
+      });
+
+      await expect(authNamespace.generateKeys()).rejects.toThrow('Generation failed');
+    });
+  });
+
+  describe('register', () => {
+    it('should register successfully', async () => {
+      const mockKeys = {
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      };
+      
+      const mockResponse = {
+        member: {
+          id: 'member-1',
+          networkId: 'network-1',
+          publicToken: 'test-public-token',
+          shortDescription: '',
+          longDescription: '',
+          role: 'member'
+        },
+        tokens: {
+          jwt: 'test-jwt-token',
+          expiresAt: Date.now() + 86400000,
+          publicToken: 'test-public-token'
+        }
+      };
+      
+      mockClient.post.mockResolvedValue({
+        success: true,
+        data: mockResponse
+      });
+
+      const result = await authNamespace.register('network-1', mockKeys);
+      
+      expect(result).toEqual(mockResponse);
+      expect(mockClient.post).toHaveBeenCalledWith('/v1/auth/register', {
+        networkId: 'network-1',
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      });
+      expect(mockClient.setAuthToken).toHaveBeenCalledWith('test-jwt-token');
+    });
+
+    it('should throw error when registration fails', async () => {
+      const mockKeys = {
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      };
+      
+      mockClient.post.mockResolvedValue({
+        success: false,
+        error: { code: 'ERROR', message: 'Registration failed' }
+      });
+
+      await expect(authNamespace.register('network-1', mockKeys)).rejects.toThrow('Registration failed');
+    });
+  });
+
+  describe('login', () => {
+    it('should login successfully', async () => {
+      const mockKeys = {
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      };
+      
+      const mockTokens = {
+        jwt: 'test-jwt-token',
+        expiresAt: Date.now() + 86400000,
+        publicToken: 'test-public-token'
+      };
+      
+      mockClient.post.mockResolvedValue({
+        success: true,
+        data: mockTokens
+      });
+
+      const result = await authNamespace.login('network-1', mockKeys);
+      
+      expect(result).toEqual(mockTokens);
+      expect(mockClient.post).toHaveBeenCalledWith('/v1/auth/login', {
+        networkId: 'network-1',
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      });
+      expect(mockClient.setAuthToken).toHaveBeenCalledWith('test-jwt-token');
+    });
+
+    it('should throw error when login fails', async () => {
+      const mockKeys = {
+        publicToken: 'test-public-token',
+        privateKey: 'test-private-key'
+      };
+      
+      mockClient.post.mockResolvedValue({
+        success: false,
+        error: { code: 'ERROR', message: 'Invalid credentials' }
+      });
+
+      await expect(authNamespace.login('network-1', mockKeys)).rejects.toThrow('Invalid credentials');
+    });
+  });
+
+  describe('logout', () => {
+    it('should clear auth token', () => {
+      authNamespace.logout();
+      expect(mockClient.clearAuthToken).toHaveBeenCalled();
+    });
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,124 @@
+import { AgenticPool } from '../src/index';
+import axios from 'axios';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('AgenticPool SDK', () => {
+  let client: AgenticPool;
+  let mockAxiosInstance: any;
+
+  beforeEach(() => {
+    mockAxiosInstance = {
+      get: jest.fn(),
+      post: jest.fn(),
+      put: jest.fn(),
+      delete: jest.fn(),
+      defaults: {
+        headers: {
+          common: {},
+          'Content-Type': 'application/json',
+          Accept: 'text/plain'
+        }
+      }
+    };
+    
+    (mockedAxios.create as jest.Mock).mockReturnValue(mockAxiosInstance);
+    client = new AgenticPool();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Constructor', () => {
+    it('should create instance with default config', () => {
+      expect(client).toBeInstanceOf(AgenticPool);
+      expect(mockedAxios.create).toHaveBeenCalledWith({
+        baseURL: 'https://api.agenticpool.net',
+        timeout: 30000,
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'text/plain'
+        }
+      });
+    });
+
+    it('should create instance with custom config', () => {
+      const customClient = new AgenticPool({
+        baseUrl: 'https://custom.api.com',
+        timeout: 60000,
+        format: 'json'
+      });
+      
+      expect(customClient).toBeInstanceOf(AgenticPool);
+      expect(mockedAxios.create).toHaveBeenCalledWith({
+        baseURL: 'https://custom.api.com',
+        timeout: 60000,
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        }
+      });
+    });
+  });
+
+  describe('Namespaces', () => {
+    it('should have auth namespace', () => {
+      expect(client.auth).toBeDefined();
+      expect(typeof client.auth.generateKeys).toBe('function');
+      expect(typeof client.auth.register).toBe('function');
+      expect(typeof client.auth.login).toBe('function');
+      expect(typeof client.auth.logout).toBe('function');
+    });
+
+    it('should have networks namespace', () => {
+      expect(client.networks).toBeDefined();
+      expect(typeof client.networks.list).toBe('function');
+      expect(typeof client.networks.get).toBe('function');
+      expect(typeof client.networks.create).toBe('function');
+      expect(typeof client.networks.mine).toBe('function');
+      expect(typeof client.networks.getMembers).toBe('function');
+      expect(typeof client.networks.getQuestions).toBe('function');
+    });
+
+    it('should have conversations namespace', () => {
+      expect(client.conversations).toBeDefined();
+      expect(typeof client.conversations.list).toBe('function');
+      expect(typeof client.conversations.mine).toBe('function');
+      expect(typeof client.conversations.create).toBe('function');
+      expect(typeof client.conversations.join).toBe('function');
+    });
+
+    it('should have messages namespace', () => {
+      expect(client.messages).toBeDefined();
+      expect(typeof client.messages.list).toBe('function');
+      expect(typeof client.messages.send).toBe('function');
+    });
+  });
+
+  describe('Authentication', () => {
+    it('should set auth token', () => {
+      client.setAuthToken('test-token');
+      expect(mockAxiosInstance.defaults.headers.common['Authorization']).toBe('Bearer test-token');
+    });
+
+    it('should clear auth token', () => {
+      client.setAuthToken('test-token');
+      client.clearAuthToken();
+      expect(mockAxiosInstance.defaults.headers.common['Authorization']).toBeUndefined();
+    });
+  });
+
+  describe('Format', () => {
+    it('should set format to json', () => {
+      client.setFormat('json');
+      expect(mockAxiosInstance.defaults.headers.Accept).toBe('application/json');
+    });
+
+    it('should set format to toon', () => {
+      client.setFormat('toon');
+      expect(mockAxiosInstance.defaults.headers.Accept).toBe('text/plain');
+    });
+  });
+});