@solworks/poll-mcp 0.1.0

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@solworks/poll-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Poll.fun betting platform",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "poll-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:security": "vitest run tests/security"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "poll-api-client": "@solworks/poll-api-client",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0"
+  }
+}

package/tests/integration/server.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeAll, afterAll } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { createServer } from '../../src/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return {
+    getAccount: vi.fn().mockResolvedValue({
+      id: 1,
+      uuid: 'test-uuid',
+      displayName: 'TestUser',
+      email: 'test@example.com',
+    }),
+    getProfile: vi.fn().mockResolvedValue({
+      uuid: 'test-uuid',
+      displayName: 'TestUser',
+    }),
+    getXpBalance: vi.fn().mockResolvedValue({ xp: 1000, error: null }),
+    getUsdcBalance: vi.fn().mockResolvedValue({ usdc: 50, error: null }),
+    getTrendingBets: vi.fn().mockResolvedValue([
+      { question: 'Trending bet 1', totalVolume: 100 },
+    ]),
+    getLeaderboard: vi.fn().mockResolvedValue([
+      { userId: 1, uuid: 'u1', displayName: 'Top', rank: 1, points: 999 },
+    ]),
+    getMyBets: vi.fn().mockResolvedValue([]),
+    getMyWagers: vi.fn().mockResolvedValue([]),
+    ...overrides,
+  } as unknown as PollClient;
+}
+
+describe('MCP Server integration', () => {
+  let mcpClient: Client;
+  let mcpServer: ReturnType<typeof createServer>;
+  let client: PollClient;
+
+  beforeAll(async () => {
+    client = mockClient();
+    mcpServer = createServer(undefined, client);
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await mcpServer.connect(serverTransport);
+
+    mcpClient = new Client({ name: 'test-client', version: '1.0.0' });
+    await mcpClient.connect(clientTransport);
+  });
+
+  afterAll(async () => {
+    await mcpClient.close();
+    await mcpServer.close();
+  });
+
+  it('lists all expected tools', async () => {
+    const { tools } = await mcpClient.listTools();
+    const toolNames = tools.map((t) => t.name);
+
+    const expectedTools = [
+      'get_account',
+      'get_profile',
+      'get_balance',
+      'list_public_bets',
+      'get_trending_bets',
+      'get_bet',
+      'get_my_wagers',
+      'get_leaderboard',
+      'get_my_ranking',
+      'get_wallet_transactions',
+      'get_friends',
+      'get_notifications',
+      'get_streak',
+      'get_favourite_bets',
+      'get_probability_history',
+      'create_bet',
+      'join_bet',
+      'place_wager',
+      'cancel_wager',
+      'initiate_vote',
+      'vote',
+      'settle_bet',
+      'update_display_name',
+      'send_friend_request',
+      'respond_friend_request',
+      'favourite_bet',
+      'unfavourite_bet',
+    ];
+
+    for (const name of expectedTools) {
+      expect(toolNames).toContain(name);
+    }
+    expect(tools.length).toBe(27);
+  });
+
+  it('does NOT expose excluded tools', async () => {
+    const { tools } = await mcpClient.listTools();
+    const toolNames = tools.map((t) => t.name);
+
+    const excluded = [
+      'private_key',
+      'delete_account',
+      'admin_ban',
+      'admin_resolve',
+      'onramp',
+      'merge_accounts',
+      'coinbase_webhook',
+    ];
+
+    for (const name of excluded) {
+      expect(toolNames).not.toContain(name);
+    }
+  });
+
+  it('can call get_account tool', async () => {
+    const result = await mcpClient.callTool({ name: 'get_account', arguments: {} });
+    expect(result.isError).toBeFalsy();
+    const textContent = result.content as Array<{ type: string; text: string }>;
+    expect(textContent[0].text).toContain('TestUser');
+    expect(textContent[0].text).toContain('test-uuid');
+  });
+
+  it('lists expected resources', async () => {
+    const { resources } = await mcpClient.listResources();
+    const uris = resources.map((r) => r.uri);
+    expect(uris).toContain('poll://user/profile');
+    expect(uris).toContain('poll://user/balances');
+    expect(uris).toContain('poll://bets/active');
+    expect(uris).toContain('poll://bets/trending');
+    expect(uris).toContain('poll://leaderboard/top10');
+    expect(resources.length).toBe(5);
+  });
+
+  it('lists expected prompts', async () => {
+    const { prompts } = await mcpClient.listPrompts();
+    const promptNames = prompts.map((p) => p.name);
+    expect(promptNames).toContain('analyze_bet');
+    expect(promptNames).toContain('suggest_bets');
+    expect(promptNames).toContain('portfolio_review');
+    expect(prompts.length).toBe(3);
+  });
+
+  it('handles API errors gracefully', async () => {
+    const errorClient = mockClient({
+      getAccount: vi.fn().mockRejectedValue(new Error('API Error 401: Unauthorized')),
+    });
+    const errorServer = createServer(undefined, errorClient);
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    await errorServer.connect(st);
+    const errorMcpClient = new Client({ name: 'error-test', version: '1.0.0' });
+    await errorMcpClient.connect(ct);
+
+    const result = await errorMcpClient.callTool({ name: 'get_account', arguments: {} });
+    expect(result.isError).toBe(true);
+    const textContent = result.content as Array<{ type: string; text: string }>;
+    expect(textContent[0].text).toContain('Unauthorized');
+
+    await errorMcpClient.close();
+    await errorServer.close();
+  });
+});

package/tests/security/excluded-endpoints.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../src/tools/index.js';
+
+describe('Excluded endpoints', () => {
+  const excludedPatterns = [
+    'private_key',
+    'delete_account',
+    'admin',
+    'onramp',
+    'merge',
+    'coinbase',
+  ];
+
+  it('no tool name matches excluded patterns', () => {
+    const toolNames = Object.keys(TOOL_DEFINITIONS);
+    for (const pattern of excludedPatterns) {
+      for (const name of toolNames) {
+        expect(
+          name.toLowerCase().includes(pattern.toLowerCase()),
+          `Tool "${name}" matches excluded pattern "${pattern}"`
+        ).toBe(false);
+      }
+    }
+  });
+});

package/tests/security/scope-enforcement.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../src/tools/index.js';
+
+describe('Scope enforcement', () => {
+  it('every tool has a requiredScope defined', () => {
+    for (const [name, tool] of Object.entries(TOOL_DEFINITIONS)) {
+      expect(tool.requiredScope, `Tool ${name} missing requiredScope`).toBeTruthy();
+      expect(typeof tool.requiredScope).toBe('string');
+    }
+  });
+
+  it('write tools require :write scopes', () => {
+    const writeTools = [
+      'create_bet',
+      'join_bet',
+      'place_wager',
+      'cancel_wager',
+      'initiate_vote',
+      'vote',
+      'settle_bet',
+      'update_display_name',
+      'send_friend_request',
+      'respond_friend_request',
+      'favourite_bet',
+      'unfavourite_bet',
+    ];
+
+    for (const name of writeTools) {
+      const tool = TOOL_DEFINITIONS[name];
+      expect(tool, `Tool ${name} not found`).toBeDefined();
+      expect(
+        tool.requiredScope.includes(':write'),
+        `Tool ${name} has scope "${tool.requiredScope}" but should include ":write"`
+      ).toBe(true);
+    }
+  });
+
+  it('read tools require read scope', () => {
+    const readTools = [
+      'get_account',
+      'get_profile',
+      'get_balance',
+      'list_public_bets',
+      'get_trending_bets',
+      'get_bet',
+      'get_my_wagers',
+      'get_leaderboard',
+      'get_my_ranking',
+      'get_wallet_transactions',
+      'get_friends',
+      'get_notifications',
+      'get_streak',
+      'get_favourite_bets',
+      'get_probability_history',
+    ];
+
+    for (const name of readTools) {
+      const tool = TOOL_DEFINITIONS[name];
+      expect(tool, `Tool ${name} not found`).toBeDefined();
+      expect(
+        tool.requiredScope,
+        `Tool ${name} has scope "${tool.requiredScope}" but should be "read"`
+      ).toBe('read');
+    }
+  });
+});

package/tests/security/token-handling.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../src/tools/index.js';
+
+describe('Token handling security', () => {
+  const sensitivePatterns = ['polld_', 'Bearer', 'https://api.'];
+
+  it('no tool description contains sensitive tokens', () => {
+    for (const [name, tool] of Object.entries(TOOL_DEFINITIONS)) {
+      for (const pattern of sensitivePatterns) {
+        expect(
+          tool.description.includes(pattern),
+          `Tool "${name}" description contains "${pattern}"`
+        ).toBe(false);
+      }
+    }
+  });
+
+  it('no tool inputSchema references token/apiKey/secret/password', () => {
+    const forbiddenKeys = ['token', 'apiKey', 'secret', 'password', 'apikey', 'api_key'];
+    for (const [name, tool] of Object.entries(TOOL_DEFINITIONS)) {
+      const schemaStr = JSON.stringify(tool.inputSchema).toLowerCase();
+      for (const key of forbiddenKeys) {
+        expect(
+          schemaStr.includes(`"${key}"`),
+          `Tool "${name}" inputSchema contains forbidden key "${key}"`
+        ).toBe(false);
+      }
+    }
+  });
+});

package/tests/unit/resources.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi } from 'vitest';
+import { RESOURCE_DEFINITIONS } from '../../src/resources/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return overrides as PollClient;
+}
+
+describe('Resource handlers', () => {
+  it('poll://user/profile returns profile data', async () => {
+    const client = mockClient({
+      getProfile: vi.fn().mockResolvedValue({
+        uuid: 'uuid-1',
+        displayName: 'Alice',
+      }),
+    });
+    const resource = RESOURCE_DEFINITIONS.find((r) => r.uri === 'poll://user/profile')!;
+    const text = await resource.handler(client);
+    expect(text).toContain('Alice');
+    expect(text).toContain('uuid-1');
+  });
+
+  it('poll://user/balances returns balances', async () => {
+    const client = mockClient({
+      getXpBalance: vi.fn().mockResolvedValue({ xp: 500, error: null }),
+      getUsdcBalance: vi.fn().mockResolvedValue({ usdc: 25.0, error: null }),
+    });
+    const resource = RESOURCE_DEFINITIONS.find((r) => r.uri === 'poll://user/balances')!;
+    const text = await resource.handler(client);
+    expect(text).toContain('XP: 500');
+    expect(text).toContain('USDC: 25');
+  });
+
+  it('poll://bets/active returns bets and wagers', async () => {
+    const client = mockClient({
+      getMyBets: vi.fn().mockResolvedValue([
+        { question: 'My bet', status: 'OPEN' },
+      ]),
+      getMyWagers: vi.fn().mockResolvedValue([
+        { betAddress: 'addr1', amount: 10, status: 'PLACED' },
+      ]),
+    });
+    const resource = RESOURCE_DEFINITIONS.find((r) => r.uri === 'poll://bets/active')!;
+    const text = await resource.handler(client);
+    expect(text).toContain('My bet');
+    expect(text).toContain('addr1');
+  });
+
+  it('poll://bets/trending returns trending bets', async () => {
+    const client = mockClient({
+      getTrendingBets: vi.fn().mockResolvedValue([
+        { question: 'Hot bet', totalVolume: 9999 },
+      ]),
+    });
+    const resource = RESOURCE_DEFINITIONS.find((r) => r.uri === 'poll://bets/trending')!;
+    const text = await resource.handler(client);
+    expect(text).toContain('Hot bet');
+    expect(text).toContain('9999');
+  });
+
+  it('poll://leaderboard/top10 returns top 10 entries', async () => {
+    const entries = Array.from({ length: 15 }, (_, i) => ({
+      userId: i + 1,
+      uuid: `uuid-${i}`,
+      displayName: `Player ${i + 1}`,
+      rank: i + 1,
+      points: 500 - i * 10,
+    }));
+    const client = mockClient({
+      getLeaderboard: vi.fn().mockResolvedValue(entries),
+    });
+    const resource = RESOURCE_DEFINITIONS.find((r) => r.uri === 'poll://leaderboard/top10')!;
+    const text = await resource.handler(client);
+    expect(text).toContain('Player 1');
+    expect(text).toContain('Player 10');
+    expect(text).not.toContain('Player 11');
+  });
+});

package/tests/unit/tools/bets.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../../src/tools/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return overrides as PollClient;
+}
+
+describe('Bet tool handlers', () => {
+  it('get_trending_bets returns formatted list', async () => {
+    const client = mockClient({
+      getTrendingBets: vi.fn().mockResolvedValue([
+        { question: 'Will BTC hit 100k?', totalVolume: 5000 },
+        { question: 'ETH above 5k?', totalVolume: 3000 },
+      ]),
+    });
+    const result = await TOOL_DEFINITIONS.get_trending_bets.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Trending Bets:');
+    expect(result.content[0].text).toContain('Will BTC hit 100k?');
+    expect(result.content[0].text).toContain('ETH above 5k?');
+  });
+
+  it('get_bet with valid ID returns formatted details', async () => {
+    const client = mockClient({
+      getBet: vi.fn().mockResolvedValue({
+        id: 'bet-123',
+        question: 'Will it rain tomorrow?',
+        status: 'OPEN',
+        options: ['Yes', 'No'],
+        totalVolume: 1000,
+        createdAt: '2026-01-01T00:00:00Z',
+        betAddress: 'addr123',
+      }),
+    });
+    const result = await TOOL_DEFINITIONS.get_bet.handler({ id: 'bet-123' }, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Will it rain tomorrow?');
+    expect(result.content[0].text).toContain('OPEN');
+    expect(result.content[0].text).toContain('Yes, No');
+    expect(result.content[0].text).toContain('addr123');
+  });
+
+  it('get_bet with missing ID returns error', async () => {
+    const client = mockClient();
+    const result = await TOOL_DEFINITIONS.get_bet.handler({}, client);
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Missing required parameter: id');
+  });
+
+  it('create_bet calls client correctly', async () => {
+    const createBetFn = vi.fn().mockResolvedValue({
+      id: 'new-bet-1',
+      question: 'Will SOL hit 200?',
+      options: ['Yes', 'No'],
+      status: 'DRAFT',
+    });
+    const client = mockClient({ createBet: createBetFn });
+    const result = await TOOL_DEFINITIONS.create_bet.handler(
+      {
+        question: 'Will SOL hit 200?',
+        options: ['Yes', 'No'],
+        amount: 10,
+      },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Bet created successfully');
+    expect(result.content[0].text).toContain('Will SOL hit 200?');
+    expect(createBetFn).toHaveBeenCalledWith({
+      question: 'Will SOL hit 200?',
+      options: ['Yes', 'No'],
+      type: 'USDC',
+      amount: 10,
+      expiresAt: undefined,
+    });
+  });
+
+  it('place_wager with valid params', async () => {
+    const placeWagerFn = vi.fn().mockResolvedValue({});
+    const client = mockClient({ placeWager: placeWagerFn });
+    const result = await TOOL_DEFINITIONS.place_wager.handler(
+      { betAddress: 'addr1', optionIndex: 0, amount: 50 },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Wager placed successfully');
+    expect(placeWagerFn).toHaveBeenCalledWith({
+      betAddress: 'addr1',
+      optionIndex: 0,
+      amount: 50,
+    });
+  });
+
+  it('place_wager with missing betAddress returns error', async () => {
+    const client = mockClient();
+    const result = await TOOL_DEFINITIONS.place_wager.handler(
+      { optionIndex: 0, amount: 50 },
+      client
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Missing required parameter: betAddress');
+  });
+
+  it('create_bet handles API error', async () => {
+    const client = mockClient({
+      createBet: vi.fn().mockRejectedValue(new Error('API Error 400: Invalid question')),
+    });
+    const result = await TOOL_DEFINITIONS.create_bet.handler(
+      { question: 'Bad bet?', options: ['A', 'B'] },
+      client
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('API Error 400: Invalid question');
+  });
+});

package/tests/unit/tools/leaderboard.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../../src/tools/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return overrides as PollClient;
+}
+
+describe('Leaderboard tool handlers', () => {
+  it('get_leaderboard caps at 25', async () => {
+    const entries = Array.from({ length: 30 }, (_, i) => ({
+      userId: i + 1,
+      uuid: `uuid-${i}`,
+      displayName: `User ${i + 1}`,
+      rank: i + 1,
+      points: 1000 - i * 10,
+    }));
+    const client = mockClient({
+      getLeaderboard: vi.fn().mockResolvedValue(entries),
+    });
+    const result = await TOOL_DEFINITIONS.get_leaderboard.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Leaderboard:');
+    expect(result.content[0].text).toContain('#1 User 1');
+    expect(result.content[0].text).toContain('#25 User 25');
+    expect(result.content[0].text).not.toContain('#26');
+    expect(result.content[0].text).toContain('Showing 25 of 30');
+  });
+
+  it('get_my_ranking returns formatted rank', async () => {
+    const client = mockClient({
+      getMyRanking: vi.fn().mockResolvedValue({
+        userId: 42,
+        uuid: 'uuid-me',
+        displayName: 'Me',
+        rank: 15,
+        points: 850,
+      }),
+    });
+    const result = await TOOL_DEFINITIONS.get_my_ranking.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Rank: #15');
+    expect(result.content[0].text).toContain('Points: 850');
+  });
+});

package/tests/unit/tools/social.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../../src/tools/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return overrides as PollClient;
+}
+
+describe('Social tool handlers', () => {
+  it('get_friends returns list', async () => {
+    const client = mockClient({
+      getFriends: vi.fn().mockResolvedValue([
+        { id: 1, uuid: 'friend-1', displayName: 'Alice' },
+        { id: 2, uuid: 'friend-2', displayName: 'Bob' },
+      ]),
+    });
+    const result = await TOOL_DEFINITIONS.get_friends.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Friends:');
+    expect(result.content[0].text).toContain('Alice');
+    expect(result.content[0].text).toContain('Bob');
+  });
+
+  it('favourite_bet calls client', async () => {
+    const favouriteFn = vi.fn().mockResolvedValue({});
+    const client = mockClient({ favouriteBet: favouriteFn });
+    const result = await TOOL_DEFINITIONS.favourite_bet.handler(
+      { betAddress: 'addr-fav' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Bet added to favourites: addr-fav');
+    expect(favouriteFn).toHaveBeenCalledWith('addr-fav');
+  });
+
+  it('send_friend_request calls client', async () => {
+    const sendFn = vi.fn().mockResolvedValue({});
+    const client = mockClient({ sendFriendRequest: sendFn });
+    const result = await TOOL_DEFINITIONS.send_friend_request.handler(
+      { uuid: 'target-uuid' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Friend request sent to: target-uuid');
+    expect(sendFn).toHaveBeenCalledWith('target-uuid');
+  });
+});

package/tests/unit/tools/user.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TOOL_DEFINITIONS } from '../../../src/tools/index.js';
+import type { PollClient } from 'poll-api-client';
+
+function mockClient(overrides: Partial<PollClient> = {}): PollClient {
+  return overrides as PollClient;
+}
+
+describe('User tool handlers', () => {
+  it('get_account returns formatted profile', async () => {
+    const client = mockClient({
+      getAccount: vi.fn().mockResolvedValue({
+        id: 42,
+        uuid: 'uuid-abc',
+        displayName: 'Alice',
+        email: 'alice@example.com',
+      }),
+    });
+    const result = await TOOL_DEFINITIONS.get_account.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Account Information:');
+    expect(result.content[0].text).toContain('Alice');
+    expect(result.content[0].text).toContain('uuid-abc');
+    expect(result.content[0].text).toContain('alice@example.com');
+  });
+
+  it('get_balance combines XP and USDC', async () => {
+    const client = mockClient({
+      getXpBalance: vi.fn().mockResolvedValue({ xp: 1500, error: null }),
+      getUsdcBalance: vi.fn().mockResolvedValue({ usdc: 75.5, error: null }),
+    });
+    const result = await TOOL_DEFINITIONS.get_balance.handler({}, client);
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('XP: 1500');
+    expect(result.content[0].text).toContain('USDC: 75.5');
+  });
+
+  it('update_display_name calls client', async () => {
+    const updateFn = vi.fn().mockResolvedValue(undefined);
+    const client = mockClient({ updateDisplayName: updateFn });
+    const result = await TOOL_DEFINITIONS.update_display_name.handler(
+      { name: 'NewName' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Display name updated to: NewName');
+    expect(updateFn).toHaveBeenCalledWith('NewName');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    testTimeout: 15000,
+  },
+});