agenticpool 1.0.0

package/src/limits/LimitsManager.ts

@@ -0,0 +1,76 @@
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs-extra';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agenticpool');
+const LIMITS_FILE = path.join(CONFIG_DIR, 'limits.json');
+
+export interface PlanLimits {
+  plan: 'starter' | 'pro' | 'elite';
+  maxNetworks: number;
+  skills: string[];
+  premiumLlms: boolean;
+  stripePriceId?: string;
+  stripeCustomerId?: string;
+}
+
+const PLAN_DEFAULTS: Record<string, Partial<PlanLimits>> = {
+  starter: { maxNetworks: 1, skills: ['agenticpool-social', 'openclaw-free'], premiumLlms: false },
+  pro: { maxNetworks: 3, skills: ['agenticpool-social', 'openclaw-free', 'google-search', 'web-scraper', 'translation'], premiumLlms: false },
+  elite: { maxNetworks: Infinity, skills: ['agenticpool-social', 'openclaw-free', 'google-search', 'web-scraper', 'translation', 'news-api', 'advanced-summarization'], premiumLlms: true },
+};
+
+export class LimitsManager {
+  private cached: PlanLimits | null = null;
+
+  async getLimits(): Promise<PlanLimits | null> {
+    if (this.cached) return this.cached;
+
+    const exists = await fs.pathExists(LIMITS_FILE);
+    if (!exists) return null;
+
+    try {
+      const raw = await fs.readJson(LIMITS_FILE);
+      this.cached = {
+        plan: raw.plan || 'starter',
+        maxNetworks: raw.maxNetworks ?? PLAN_DEFAULTS[raw.plan]?.maxNetworks ?? 1,
+        skills: raw.skills || PLAN_DEFAULTS[raw.plan]?.skills || [],
+        premiumLlms: raw.premiumLlms ?? PLAN_DEFAULTS[raw.plan]?.premiumLlms ?? false,
+        stripePriceId: raw.stripePriceId,
+        stripeCustomerId: raw.stripeCustomerId,
+      };
+      return this.cached;
+    } catch {
+      return null;
+    }
+  }
+
+  async canJoinNetwork(currentNetworkCount: number): Promise<{ allowed: boolean; reason?: string }> {
+    const limits = await this.getLimits();
+    if (!limits) return { allowed: true };
+
+    if (currentNetworkCount >= limits.maxNetworks) {
+      return {
+        allowed: false,
+        reason: `Limit reached: Your ${limits.plan} plan allows a maximum of ${limits.maxNetworks} network(s). Upgrade at shop.agenticpool.com`,
+      };
+    }
+
+    return { allowed: true };
+  }
+
+  async canCreateNetwork(currentNetworkCount: number): Promise<{ allowed: boolean; reason?: string }> {
+    return this.canJoinNetwork(currentNetworkCount);
+  }
+
+  hasSkill(skill: string): boolean {
+    if (!this.cached) return true;
+    return this.cached.skills.includes(skill);
+  }
+
+  clearCache(): void {
+    this.cached = null;
+  }
+}
+
+export const limitsManager = new LimitsManager();

package/tests/ApiClient.test.ts

@@ -0,0 +1,99 @@
+import { ApiClient } from '../src/api/ApiClient';
+import axios from 'axios';
+import { configManager } from '../src/config';
+
+jest.mock('axios');
+jest.mock('../src/config');
+
+describe('ApiClient', () => {
+  let client: ApiClient;
+  let mockAxios: jest.Mocked<typeof axios>;
+
+  beforeEach(() => {
+    mockAxios = axios as jest.Mocked<typeof axios>;
+    
+    const mockInstance = {
+      get: jest.fn(),
+      post: jest.fn(),
+      put: jest.fn(),
+      delete: jest.fn(),
+      defaults: {
+        headers: {
+          common: {}
+        }
+      }
+    };
+    
+    mockAxios.create.mockReturnValue(mockInstance as any);
+    
+    client = new ApiClient('https://test.api.com');
+  });
+
+  describe('create', () => {
+    it('should create client with config', async () => {
+      (configManager.getGlobalConfig as jest.Mock).mockResolvedValue({
+        apiUrl: 'https://config.api.com',
+        defaultFormat: 'toon'
+      });
+      
+      const newClient = await ApiClient.create();
+      
+      expect(newClient).toBeDefined();
+    });
+  });
+
+  describe('setAuthToken', () => {
+    it('should set authorization header', () => {
+      client.setAuthToken('test-token');
+      
+      expect(client['client'].defaults.headers.common['Authorization']).toBe('Bearer test-token');
+    });
+  });
+
+  describe('clearAuthToken', () => {
+    it('should remove authorization header', () => {
+      client.setAuthToken('test-token');
+      client.clearAuthToken();
+      
+      expect(client['client'].defaults.headers.common['Authorization']).toBeUndefined();
+    });
+  });
+
+  describe('HTTP methods', () => {
+    it('should make GET request', async () => {
+      const mockGet = client['client'].get as jest.Mock;
+      mockGet.mockResolvedValue({ data: { success: true, data: { id: 1 } } });
+      
+      const result = await client.get('/test');
+      
+      expect(mockGet).toHaveBeenCalledWith('/test', expect.any(Object));
+    });
+
+    it('should make POST request', async () => {
+      const mockPost = client['client'].post as jest.Mock;
+      mockPost.mockResolvedValue({ data: { success: true, data: { id: 1 } } });
+      
+      const result = await client.post('/test', { name: 'test' });
+      
+      expect(mockPost).toHaveBeenCalledWith('/test', expect.any(String), expect.any(Object));
+    });
+
+    it('should make PUT request', async () => {
+      const mockPut = client['client'].put as jest.Mock;
+      mockPut.mockResolvedValue({ data: { success: true } });
+      
+      const result = await client.put('/test', { name: 'updated' });
+      
+      expect(mockPut).toHaveBeenCalledWith('/test', expect.any(String), expect.any(Object));
+    });
+
+    it('should make DELETE request', async () => {
+      const mockDelete = client['client'].delete as jest.Mock;
+      mockDelete.mockResolvedValue({ data: { success: true } });
+      
+      const result = await client.delete('/test');
+      
+      expect(mockDelete).toHaveBeenCalledWith('/test', expect.any(Object));
+    });
+  });
+});

package/tests/ConfigManager.test.ts

@@ -0,0 +1,41 @@
+import { ConfigManager } from '../src/config/ConfigManager';
+
+jest.mock('fs-extra', () => ({
+  ensureDir: jest.fn().mockResolvedValue(undefined),
+  pathExists: jest.fn().mockResolvedValue(true),
+  readJson: jest.fn().mockResolvedValue({
+    apiUrl: 'https://test.api.com',
+    defaultFormat: 'toon'
+  }),
+  writeJson: jest.fn().mockResolvedValue(undefined),
+  readFile: jest.fn().mockResolvedValue('# Profile'),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  remove: jest.fn().mockResolvedValue(undefined),
+  emptyDir: jest.fn().mockResolvedValue(undefined)
+}));
+
+describe('ConfigManager', () => {
+  let configManager: ConfigManager;
+
+  beforeEach(() => {
+    configManager = new ConfigManager();
+  });
+
+  describe('getGlobalConfig', () => {
+    it('should return global config', async () => {
+      const config = await configManager.getGlobalConfig();
+      
+      expect(config).toEqual({
+        apiUrl: 'https://test.api.com',
+        defaultFormat: 'toon'
+      });
+    });
+  });
+
+  describe('getConfigPath', () => {
+    it('should return config path', () => {
+      const path = configManager.getConfigPath();
+      expect(path).toContain('.agenticpool');
+    });
+  });
+});

package/tests/LimitsManager.test.ts

@@ -0,0 +1,169 @@
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs-extra';
+import { LimitsManager, PlanLimits } from '../src/limits/LimitsManager';
+
+jest.mock('fs-extra', () => ({
+  pathExists: jest.fn(),
+  readJson: jest.fn(),
+  ensureDir: jest.fn(),
+}));
+
+const mockedFs = fs as any;
+
+describe('LimitsManager', () => {
+  let manager: LimitsManager;
+
+  beforeEach(() => {
+    manager = new LimitsManager();
+    jest.clearAllMocks();
+    mockedFs.pathExists.mockResolvedValue(false);
+    mockedFs.readJson.mockResolvedValue({});
+  });
+
+  describe('when limits.json does not exist', () => {
+    beforeEach(() => {
+      mockedFs.pathExists.mockResolvedValue(false);
+    });
+
+    test('getLimits returns null', async () => {
+      expect(await manager.getLimits()).toBeNull();
+    });
+
+    test('canJoinNetwork always allowed', async () => {
+      expect((await manager.canJoinNetwork(999)).allowed).toBe(true);
+    });
+
+    test('canCreateNetwork always allowed', async () => {
+      expect((await manager.canCreateNetwork(999)).allowed).toBe(true);
+    });
+
+    test('hasSkill returns true when no limits loaded', () => {
+      expect(manager.hasSkill('anything')).toBe(true);
+    });
+  });
+
+  describe('starter plan', () => {
+    const limits: PlanLimits = {
+      plan: 'starter',
+      maxNetworks: 1,
+      skills: ['agenticpool-social', 'openclaw-free'],
+      premiumLlms: false,
+    };
+
+    beforeEach(() => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(limits);
+    });
+
+    test('reads plan correctly', async () => {
+      const result = await manager.getLimits();
+      expect(result!.plan).toBe('starter');
+      expect(result!.maxNetworks).toBe(1);
+      expect(result!.premiumLlms).toBe(false);
+    });
+
+    test('allows when under limit', async () => {
+      expect((await manager.canJoinNetwork(0)).allowed).toBe(true);
+    });
+
+    test('blocks when at limit', async () => {
+      const result = await manager.canJoinNetwork(1);
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('starter');
+      expect(result.reason).toContain('1');
+      expect(result.reason).toContain('shop.agenticpool.com');
+    });
+
+    test('hasSkill true for allowed', async () => {
+      await manager.getLimits();
+      expect(manager.hasSkill('agenticpool-social')).toBe(true);
+    });
+
+    test('hasSkill false for disallowed', async () => {
+      await manager.getLimits();
+      expect(manager.hasSkill('google-search')).toBe(false);
+    });
+  });
+
+  describe('pro plan', () => {
+    const limits: PlanLimits = {
+      plan: 'pro',
+      maxNetworks: 3,
+      skills: ['agenticpool-social', 'openclaw-free', 'google-search', 'web-scraper', 'translation'],
+      premiumLlms: false,
+    };
+
+    beforeEach(() => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(limits);
+    });
+
+    test('allows up to 3 networks', async () => {
+      expect((await manager.canJoinNetwork(0)).allowed).toBe(true);
+      expect((await manager.canJoinNetwork(2)).allowed).toBe(true);
+      expect((await manager.canJoinNetwork(3)).allowed).toBe(false);
+    });
+
+    test('has google-search skill', async () => {
+      await manager.getLimits();
+      expect(manager.hasSkill('google-search')).toBe(true);
+    });
+  });
+
+  describe('elite plan', () => {
+    const limits: PlanLimits = {
+      plan: 'elite',
+      maxNetworks: Infinity,
+      skills: ['agenticpool-social', 'openclaw-free', 'google-search', 'web-scraper', 'translation', 'news-api', 'advanced-summarization'],
+      premiumLlms: true,
+    };
+
+    beforeEach(() => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockResolvedValue(limits);
+    });
+
+    test('allows unlimited networks', async () => {
+      expect((await manager.canJoinNetwork(100)).allowed).toBe(true);
+      expect((await manager.canJoinNetwork(1000)).allowed).toBe(true);
+    });
+
+    test('has all skills', async () => {
+      await manager.getLimits();
+      expect(manager.hasSkill('news-api')).toBe(true);
+      expect(manager.hasSkill('advanced-summarization')).toBe(true);
+    });
+
+    test('has premium LLMs', async () => {
+      expect((await manager.getLimits())!.premiumLlms).toBe(true);
+    });
+  });
+
+  describe('corrupt file', () => {
+    beforeEach(() => {
+      mockedFs.pathExists.mockResolvedValue(true);
+      mockedFs.readJson.mockRejectedValue(new Error('bad json'));
+    });
+
+    test('getLimits returns null gracefully', async () => {
+      expect(await manager.getLimits()).toBeNull();
+    });
+
+    test('canJoinNetwork allowed as fallback', async () => {
+      expect((await manager.canJoinNetwork(999)).allowed).toBe(true);
+    });
+  });
+
+  describe('caching', () => {
+    test('clearCache forces re-read', async () => {
+      mockedFs.pathExists.mockResolvedValue(false);
+      await manager.getLimits();
+      await manager.getLimits();
+      const callsAfterCacheHit = mockedFs.pathExists.mock.calls.length;
+      manager.clearCache();
+      await manager.getLimits();
+      expect(mockedFs.pathExists.mock.calls.length).toBeGreaterThan(callsAfterCacheHit);
+    });
+  });
+});

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

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

package/tests/integration/cleanup.ts

@@ -0,0 +1,187 @@
+import * as admin from 'firebase-admin';
+import * as path from 'path';
+
+const NETWORK_ID = 'gamers-united';
+const ROOT_DIR = path.resolve(__dirname, '../../..');
+const MAIN_SA_PATH = path.join(ROOT_DIR, '.credenciales', 'produccion.json');
+const HUMANS_SA_PATH = path.join(ROOT_DIR, '.credenciales', 'humans-produccion.json');
+
+function createMainApp(): admin.firestore.Firestore {
+  try {
+    const sa = require(MAIN_SA_PATH);
+    const app = admin.initializeApp({
+      credential: admin.credential.cert(sa),
+    }, 'cleanup-main');
+    return app.firestore();
+  } catch (e) {
+    throw new Error(`Cannot load main service account from ${MAIN_SA_PATH}`);
+  }
+}
+
+function createHumansApp(): admin.firestore.Firestore {
+  try {
+    const sa = require(HUMANS_SA_PATH);
+    const app = admin.initializeApp({
+      credential: admin.credential.cert(sa),
+    }, 'cleanup-humans');
+    return app.firestore();
+  } catch (e) {
+    throw new Error(`Cannot load humans service account from ${HUMANS_SA_PATH}`);
+  }
+}
+
+async function deleteCollection(
+  db: admin.firestore.Firestore,
+  collectionPath: string,
+  filter?: (doc: admin.firestore.QueryDocumentSnapshot) => boolean
+): Promise<number> {
+  const snapshot = await db.collection(collectionPath).get();
+  let count = 0;
+  for (const doc of snapshot.docs) {
+    if (filter && !filter(doc)) continue;
+    await doc.ref.delete();
+    count++;
+  }
+  return count;
+}
+
+async function deleteSubcollection(
+  db: admin.firestore.Firestore,
+  parentPath: string,
+  subcollectionName: string,
+  filter?: (doc: admin.firestore.QueryDocumentSnapshot) => boolean
+): Promise<number> {
+  let count = 0;
+  const parentSnapshot = await db.collection(parentPath).get();
+  for (const parentDoc of parentSnapshot.docs) {
+    const subSnapshot = await parentDoc.ref.collection(subcollectionName).get();
+    for (const doc of subSnapshot.docs) {
+      if (filter && !filter(doc)) continue;
+      await doc.ref.delete();
+      count++;
+    }
+  }
+  return count;
+}
+
+async function cleanupMain(db: admin.firestore.Firestore): Promise<void> {
+  console.log('\n=== Cleaning Main Firestore (agenticpool) ===\n');
+
+  const membersPath = `networks/${NETWORK_ID}/members`;
+  const convsPath = `networks/${NETWORK_ID}/conversations`;
+
+  const isTestMember = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return (
+      d.shortDescription?.includes('E2E Test') ||
+      d.shortDescription?.includes('e2e-test') ||
+      d.longDescription?.includes('E2E test') ||
+      d.longDescription?.includes('end-to-end integration') ||
+      d.longDescription?.includes('integration testing') ||
+      d.shortDescription?.includes('Manual test')
+    );
+  };
+
+  const isTestConversation = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return (
+      d.title?.includes('E2E Test Topic') ||
+      d.title?.includes('Manual test topic')
+    );
+  };
+
+  const n1 = await deleteCollection(db, membersPath, isTestMember);
+  console.log(`  members:       ${n1} deleted`);
+
+  const testConvSnapshot = await db.collection(convsPath)
+    .where('title', '>=', 'E2E Test Topic')
+    .where('title', '<', 'E2E Test Topio')
+    .get();
+
+  let convCount = 0;
+  let msgCount = 0;
+  let partCount = 0;
+
+  for (const convDoc of testConvSnapshot.docs) {
+    const parts = await convDoc.ref.collection('participants').get();
+    for (const p of parts.docs) {
+      await p.ref.delete();
+      partCount++;
+    }
+
+    const msgs = await convDoc.ref.collection('messages').get();
+    for (const m of msgs.docs) {
+      await m.ref.delete();
+      msgCount++;
+    }
+
+    await convDoc.ref.delete();
+    convCount++;
+  }
+
+  console.log(`  conversations: ${convCount} deleted`);
+  console.log(`  participants:  ${partCount} deleted`);
+  console.log(`  messages:      ${msgCount} deleted`);
+}
+
+async function cleanupHumans(db: admin.firestore.Firestore): Promise<void> {
+  console.log('\n=== Cleaning Humans Firestore (agenticpool-humans) ===\n');
+
+  const isTestUser = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return d.displayName?.includes('E2E Human');
+  };
+
+  const isTestIdentity = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return d.agentDescription?.includes('E2E Test Agent');
+  };
+
+  const isTestConnection = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return d.fromExplanation?.includes('E2E test');
+  };
+
+  const isTestContact = (doc: admin.firestore.QueryDocumentSnapshot) => {
+    const d = doc.data();
+    return d.contactDisplayName?.includes('E2E Human');
+  };
+
+  const n1 = await deleteCollection(db, 'users', isTestUser);
+  console.log(`  users:         ${n1} deleted`);
+
+  const n2 = await deleteCollection(db, 'identities', isTestIdentity);
+  console.log(`  identities:    ${n2} deleted`);
+
+  const n3 = await deleteCollection(db, 'connections', isTestConnection);
+  console.log(`  connections:   ${n3} deleted`);
+
+  const n4 = await deleteCollection(db, 'contacts', isTestContact);
+  console.log(`  contacts:      ${n4} deleted`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const mode = args[0] || 'all';
+
+  console.log(`Cleanup mode: ${mode}`);
+
+  try {
+    if (mode === 'all' || mode === 'main') {
+      const mainDb = createMainApp();
+      await cleanupMain(mainDb);
+    }
+
+    if (mode === 'all' || mode === 'humans') {
+      const humansDb = createHumansApp();
+      await cleanupHumans(humansDb);
+    }
+
+    console.log('\nCleanup complete.\n');
+  } catch (e) {
+    console.error('\nCleanup failed:', (e as Error).message);
+    process.exit(1);
+  }
+}
+
+main();