@taiga-ai/mcp-server 0.2.3 → 0.3.0-dev.296

package/src/client.test.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { readFileSync } from 'node:fs';
 import { TaigaClient } from './client.js';
 
+// Read independently of src/version.ts, so the test checks the real file.
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version: string };
+
 // ---------------------------------------------------------------------------
 // Helpers -- thin wrappers to reduce boilerplate, not to obscure intent
 // ---------------------------------------------------------------------------
@@ -62,7 +66,7 @@ describe('TaigaClient', () => {
 
       await makeClient().listProjects();
 
-      expect(spy.mock.calls[0][1].headers['User-Agent']).toMatch(/^taiga-ai-mcp-server\//);
+      expect(spy.mock.calls[0][1].headers['User-Agent']).toBe(`taiga-ai-mcp-server/${pkg.version}`);
     });
   });
 
@@ -109,7 +113,7 @@ describe('TaigaClient', () => {
 
       await client.listProjects();
 
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects');
+      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products');
     });
 
     it('should omit query string when no optional params are provided', async () => {
@@ -117,7 +121,7 @@ describe('TaigaClient', () => {
 
       await makeClient().listProjects();
 
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects');
+      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products');
     });
 
     it('should include all optional filters as query params', async () => {
@@ -126,7 +130,7 @@ describe('TaigaClient', () => {
       await makeClient().listProjects({ teamId: 't1', status: 'active', limit: 10 });
 
       const url = spy.mock.calls[0][0] as string;
-      expect(url).toContain('teamId=t1');
+      expect(url).toContain('factoryId=t1');
       expect(url).toContain('status=active');
       expect(url).toContain('limit=10');
     });
@@ -137,7 +141,7 @@ describe('TaigaClient', () => {
       await makeClient().listBacklogItems('proj-1', { limit: 20 });
 
       const url = spy.mock.calls[0][0] as string;
-      expect(url).toContain('/v1/projects/proj-1/backlog');
+      expect(url).toContain('/v1/products/proj-1/backlog');
       expect(url).toContain('limit=20');
     });
 
@@ -146,7 +150,7 @@ describe('TaigaClient', () => {
 
       await makeClient().listEnvironments('proj-1');
 
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects/proj-1/environments');
+      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products/proj-1/environments');
     });
   });
 
@@ -207,7 +211,7 @@ describe('TaigaClient', () => {
 
       const result = await makeClient().getProject('p1');
 
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/projects/p1');
+      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/products/p1');
       expect(result.data).toEqual({ id: 'p1', name: 'Alpha' });
     });
 
@@ -231,25 +235,6 @@ describe('TaigaClient', () => {
       });
     });
 
-    it('should GET a single skill by id from agent-skills path', async () => {
-      const spy = stubFetch(200, { data: { id: 's1' } });
-
-      await makeClient().getSkill('s1');
-
-      expect(spy.mock.calls[0][0]).toBe('https://api.test.com/v1/agent-skills/s1');
-    });
-
-    it('should include scope filters when listing skills', async () => {
-      const spy = stubFetch(200, { data: [], nextCursor: null });
-
-      await makeClient().listSkills({ scope: 'team', scopeId: 't1', limit: 10 });
-
-      const url = spy.mock.calls[0][0] as string;
-      expect(url).toContain('/v1/agent-skills');
-      expect(url).toContain('scope=team');
-      expect(url).toContain('scopeId=t1');
-    });
-
     it('should GET a single backlog item by id (flat path)', async () => {
       const spy = stubFetch(200, { data: { id: 'item-1' } });
 
@@ -263,7 +248,7 @@ describe('TaigaClient', () => {
 
       await makeClient().listTeams({ limit: 50 });
 
-      expect(spy.mock.calls[0][0]).toContain('/v1/teams?limit=50');
+      expect(spy.mock.calls[0][0]).toContain('/v1/factories?limit=50');
     });
 
     it('should GET documents from tenant path with optional limit', async () => {

package/src/client.ts

@@ -1,4 +1,5 @@
 import type { ApiKeyIntrospection } from '@taiga/types';
+import { SERVER_VERSION } from './version.js';
 
 /**
  * HTTP client for the Taiga API.
@@ -19,7 +20,7 @@ export class TaigaClient {
     const headers: Record<string, string> = {
       Authorization: `Bearer ${this.apiKey}`,
       'Content-Type': 'application/json',
-      'User-Agent': 'taiga-ai-mcp-server/0.0.1',
+      'User-Agent': `taiga-ai-mcp-server/${SERVER_VERSION}`,
     };
 
     const response = await fetch(url, {
@@ -61,15 +62,15 @@ export class TaigaClient {
 
   async listProjects(opts?: { teamId?: string; status?: string; limit?: number }) {
     const params = new URLSearchParams();
-    if (opts?.teamId) params.set('teamId', opts.teamId);
+    if (opts?.teamId) params.set('factoryId', opts.teamId);
     if (opts?.status) params.set('status', opts.status);
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/projects${qs ? `?${qs}` : ''}`);
+    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/products${qs ? `?${qs}` : ''}`);
   }
 
   async getProject(id: string) {
-    return this.request<{ data: unknown }>('GET', `/projects/${id}`);
+    return this.request<{ data: unknown }>('GET', `/products/${id}`);
   }
 
   // ---------------------------------------------------------------------------
@@ -104,16 +105,16 @@ export class TaigaClient {
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/teams/${teamId}/documents${qs ? `?${qs}` : ''}`
+      `/factories/${teamId}/documents${qs ? `?${qs}` : ''}`
     );
   }
 
   async getTeamDocument(teamId: string, type: string) {
-    return this.request<{ data: unknown }>('GET', `/teams/${teamId}/documents/${type}`);
+    return this.request<{ data: unknown }>('GET', `/factories/${teamId}/documents/${type}`);
   }
 
   async saveTeamDocumentDraft(teamId: string, type: string, body: { data: Record<string, unknown> }) {
-    return this.request<{ data: unknown }>('PUT', `/teams/${teamId}/documents/${type}/draft`, body);
+    return this.request<{ data: unknown }>('PUT', `/factories/${teamId}/documents/${type}/draft`, body);
   }
 
   // ---------------------------------------------------------------------------
@@ -126,33 +127,12 @@ export class TaigaClient {
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/projects/${projectId}/documents${qs ? `?${qs}` : ''}`
+      `/products/${projectId}/documents${qs ? `?${qs}` : ''}`
     );
   }
 
   async getProjectDocument(projectId: string, type: string) {
-    return this.request<{ data: unknown }>('GET', `/projects/${projectId}/documents/${type}`);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Skills (agent skills)
-  // ---------------------------------------------------------------------------
-
-  async listSkills(opts?: { scope?: string; scopeId?: string; limit?: number }) {
-    const params = new URLSearchParams();
-    if (opts?.scope) params.set('scope', opts.scope);
-    if (opts?.scopeId) params.set('scopeId', opts.scopeId);
-    if (opts?.limit) params.set('limit', String(opts.limit));
-    const qs = params.toString();
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/agent-skills${qs ? `?${qs}` : ''}`);
-  }
-
-  async getSkill(id: string) {
-    return this.request<{ data: unknown }>('GET', `/agent-skills/${id}`);
-  }
-
-  async updateSkill(id: string, body: { name?: string; description?: string; content?: string }) {
-    return this.request<{ data: unknown }>('PATCH', `/agent-skills/${id}`, body);
+    return this.request<{ data: unknown }>('GET', `/products/${projectId}/documents/${type}`);
   }
 
   // ---------------------------------------------------------------------------
@@ -161,21 +141,20 @@ export class TaigaClient {
 
   /**
    * Fetch the full context for a project in parallel: project metadata,
-   * team documents, project documents, and team skills.
+   * team documents and project documents.
    * Returns a structured bundle optimized for coding agent consumption.
    */
   async getProjectContext(projectId: string): Promise<Record<string, unknown>> {
-    // First fetch the project to get the teamId
-    const project = await this.request<{ data: Record<string, unknown> }>('GET', `/projects/${projectId}`);
-    const teamId = project.data.teamId as string | undefined;
+    // First fetch the project to get its factory (the API's name for a team since PRO-1668)
+    const project = await this.request<{ data: Record<string, unknown> }>('GET', `/products/${projectId}`);
+    const teamId = project.data.factoryId as string | undefined;
 
-    // Fetch everything in parallel
-    const [projectDocs, teamDocs, skills] = await Promise.all([
+    // Fetch the document lists in parallel.
+    const [projectDocs, teamDocs] = await Promise.all([
       this.listProjectDocuments(projectId, { limit: 20 }).catch(() => ({ data: [] })),
       teamId
         ? this.listTeamDocuments(teamId, { limit: 20 }).catch(() => ({ data: [] }))
         : Promise.resolve({ data: [] }),
-      this.listSkills({ limit: 100 }).catch(() => ({ data: [] })),
     ]);
 
     // Fetch full content for key documents (in parallel)
@@ -233,9 +212,6 @@ export class TaigaClient {
           isDraft: d.isDraft,
         })),
       },
-      skills_summary: (skills.data as Record<string, unknown>[])
-        .filter((s) => !s.teamId || s.teamId === teamId)
-        .map((s) => ({ id: s.id, name: s.name, slug: s.slug, description: s.description })),
     };
 
     return context;
@@ -251,7 +227,7 @@ export class TaigaClient {
     const qs = params.toString();
     return this.request<{ data: unknown[]; nextCursor: string | null }>(
       'GET',
-      `/projects/${projectId}/backlog${qs ? `?${qs}` : ''}`
+      `/products/${projectId}/backlog${qs ? `?${qs}` : ''}`
     );
   }
 
@@ -264,7 +240,7 @@ export class TaigaClient {
   // ---------------------------------------------------------------------------
 
   async listEnvironments(projectId: string) {
-    return this.request<{ data: unknown[] }>('GET', `/projects/${projectId}/environments`);
+    return this.request<{ data: unknown[] }>('GET', `/products/${projectId}/environments`);
   }
 
   // ---------------------------------------------------------------------------
@@ -275,6 +251,6 @@ export class TaigaClient {
     const params = new URLSearchParams();
     if (opts?.limit) params.set('limit', String(opts.limit));
     const qs = params.toString();
-    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/teams${qs ? `?${qs}` : ''}`);
+    return this.request<{ data: unknown[]; nextCursor: string | null }>('GET', `/factories${qs ? `?${qs}` : ''}`);
   }
 }

package/src/index.ts

@@ -4,6 +4,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { TaigaClient } from './client.js';
 import { registerAllTools } from './tools/index.js';
+import { SERVER_VERSION } from './version.js';
 
 const DEFAULT_API_URL = 'https://api.taiga.app';
 
@@ -31,7 +32,7 @@ async function main() {
   const server = new McpServer(
     {
       name: 'taiga',
-      version: '0.0.1',
+      version: SERVER_VERSION,
     },
     {
       instructions: [
@@ -50,16 +51,12 @@ async function main() {
         "Specification (what to build), architecture (how it's designed), threat model (security risks),",
         'technology decisions, and data flow. Read these to understand the specific project context.',
         '',
-        '**Skills** (taiga_list_skills / taiga_get_skill):',
-        'Coding standards, security requirements, API design patterns, testing strategy, database patterns,',
-        'and more. These are detailed engineering guidelines with code examples.',
-        '',
         "Workflow: Start with taiga_list_teams to find your team, then read the team's domain_context",
         'and tech_preferences. For project-specific work, use taiga_list_projects to find the project,',
-        'then read its specification and architecture. Use skills for coding patterns.',
+        'then read its specification and architecture.',
         '',
-        'When you notice a policy, skill, or team document is outdated, use the update tools',
-        '(taiga_update_document, taiga_update_skill, taiga_update_team_document) to fix it.',
+        'When you notice a policy or team document is outdated, use the update tools',
+        '(taiga_update_document, taiga_update_team_document) to fix it.',
         'This keeps the knowledge base accurate for everyone.',
       ].join('\n'),
     }

package/src/server.integration.test.ts

@@ -18,20 +18,20 @@ const ALL_CAPABILITIES = [
   'backlog:read',
 ];
 
-/** All tool names the server can register (sorted for deterministic comparison). */
+/**
+ * Every tool name the server registers for a key with all capabilities,
+ * sorted for deterministic comparison.
+ */
 const ALL_TOOL_NAMES = [
   'taiga_get_document',
   'taiga_get_project_document',
-  'taiga_get_skill',
   'taiga_get_team_document',
   'taiga_list_documents',
   'taiga_list_project_documents',
   'taiga_list_projects',
-  'taiga_list_skills',
   'taiga_list_team_documents',
   'taiga_list_teams',
   'taiga_update_document',
-  'taiga_update_skill',
   'taiga_update_team_document',
 ];
 
@@ -129,7 +129,7 @@ describe('MCP server integration', () => {
   // -------------------------------------------------------------------------
 
   describe('tool discovery', () => {
-    it('should expose all 13 tools when API key has full capabilities', async () => {
+    it('should expose every tool when API key has full capabilities', async () => {
       const { client } = await bootMcpPair({ capabilities: ALL_CAPABILITIES });
 
       const { tools } = await client.listTools();
@@ -167,8 +167,6 @@ describe('MCP server integration', () => {
 
       expect(names).toContain('taiga_list_documents');
       expect(names).toContain('taiga_get_document');
-      expect(names).toContain('taiga_list_skills');
-      expect(names).toContain('taiga_get_skill');
       expect(names).not.toContain('taiga_update_document');
     });
 
@@ -181,7 +179,6 @@ describe('MCP server integration', () => {
       const names = toolNames(tools);
 
       expect(names).toContain('taiga_update_document');
-      expect(names).toContain('taiga_update_skill');
     });
 
     it('should expose team document write when both teams:read and documents:write are granted', async () => {
@@ -209,10 +206,8 @@ describe('MCP server integration', () => {
       expect(names).toContain('taiga_list_team_documents');
       // tenant:documents:read tools present
       expect(names).toContain('taiga_list_documents');
-      expect(names).toContain('taiga_list_skills');
       // write tools absent
       expect(names).not.toContain('taiga_update_document');
-      expect(names).not.toContain('taiga_update_skill');
     });
 
     it('should provide a description and input schema for every tool', async () => {
@@ -238,8 +233,8 @@ describe('MCP server integration', () => {
     const CONTRACT: Record<string, string[]> = {
       'projects:read': ['taiga_list_projects', 'taiga_list_project_documents', 'taiga_get_project_document'],
       'teams:read': ['taiga_list_teams', 'taiga_list_team_documents', 'taiga_get_team_document'],
-      'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document', 'taiga_list_skills', 'taiga_get_skill'],
-      'tenant:documents:write': ['taiga_update_document', 'taiga_update_skill'],
+      'tenant:documents:read': ['taiga_list_documents', 'taiga_get_document'],
+      'tenant:documents:write': ['taiga_update_document'],
     };
 
     for (const [capability, expectedTools] of Object.entries(CONTRACT)) {
@@ -271,7 +266,7 @@ describe('MCP server integration', () => {
 
       const { client } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/teams': { data: teams, nextCursor: null } },
+        routes: { 'GET /v1/factories': { data: teams, nextCursor: null } },
       });
 
       const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });
@@ -280,25 +275,6 @@ describe('MCP server integration', () => {
       expect(parseToolResult(result)).toEqual(teams);
     });
 
-    it('should send PATCH when updating a skill', async () => {
-      const skillId = '00000000-0000-0000-0000-000000000001';
-      const updated = { id: skillId, name: 'Updated Skill', content: '# Updated' };
-
-      const { client, fetchSpy } = await bootMcpPair({
-        capabilities: ALL_CAPABILITIES,
-        routes: { [`PATCH /v1/agent-skills/${skillId}`]: { data: updated } },
-      });
-
-      await client.callTool({
-        name: 'taiga_update_skill',
-        arguments: { id: skillId, content: '# Updated' },
-      });
-
-      const patchCall = fetchSpy.mock.calls.find((c: unknown[]) => (c[1] as RequestInit)?.method === 'PATCH');
-      expect(patchCall).toBeDefined();
-      expect(patchCall![0]).toContain(`/v1/agent-skills/${skillId}`);
-    });
-
     it('should return document content through MCP protocol', async () => {
       const docs = [{ id: 'd1', title: 'Security Policy' }];
 
@@ -332,13 +308,13 @@ describe('MCP server integration', () => {
     });
 
     it('should send PUT when updating a team document draft', async () => {
-      const teamId = '00000000-0000-0000-0000-000000000001';
+      const teamId = '0199a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b';
       const docType = 'domain_context';
       const updated = { type: docType, name: 'Domain Context' };
 
       const { client, fetchSpy } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { [`PUT /v1/teams/${teamId}/documents/${docType}/draft`]: { data: updated } },
+        routes: { [`PUT /v1/factories/${teamId}/documents/${docType}/draft`]: { data: updated } },
       });
 
       await client.callTool({
@@ -347,23 +323,10 @@ describe('MCP server integration', () => {
       });
 
       const putCall = fetchSpy.mock.calls.find(
-        (c: unknown[]) => (c[1] as RequestInit)?.method === 'PUT' && (c[0] as string).includes('/teams/')
+        (c: unknown[]) => (c[1] as RequestInit)?.method === 'PUT' && (c[0] as string).includes('/factories/')
       );
       expect(putCall).toBeDefined();
-      expect(putCall![0]).toContain(`/v1/teams/${teamId}/documents/${docType}/draft`);
-    });
-
-    it('should return skills through MCP protocol', async () => {
-      const skills = [{ id: 's1', name: 'React Standards' }];
-
-      const { client } = await bootMcpPair({
-        capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/agent-skills': { data: skills, nextCursor: null } },
-      });
-
-      const result = await client.callTool({ name: 'taiga_list_skills', arguments: {} });
-
-      expect(parseToolResult(result)).toEqual(skills);
+      expect(putCall![0]).toContain(`/v1/factories/${teamId}/documents/${docType}/draft`);
     });
 
     it('should return teams through MCP protocol', async () => {
@@ -371,7 +334,7 @@ describe('MCP server integration', () => {
 
       const { client } = await bootMcpPair({
         capabilities: ALL_CAPABILITIES,
-        routes: { 'GET /v1/teams': { data: teams, nextCursor: null } },
+        routes: { 'GET /v1/factories': { data: teams, nextCursor: null } },
       });
 
       const result = await client.callTool({ name: 'taiga_list_teams', arguments: {} });

package/src/tools/backlogs.ts

@@ -1,5 +1,5 @@
 // Backlog tools are reserved for post-beta.
-// The beta MCP server focuses on the knowledge base (policies, skills, team docs).
+// The beta MCP server focuses on the knowledge base (policies, team docs).
 
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TaigaClient } from '../client.js';

package/src/tools/documents.ts

@@ -32,7 +32,7 @@ export function registerDocumentTools(server: McpServer, client: TaigaClient) {
         'Use this when you need to understand security requirements, data handling rules, ' +
         'architecture standards, or compliance controls that apply to your code. ' +
         'Types: policy_security, policy_data, policy_sdlc, policy_ops, policy_tic, ' +
-        'policy_risk, policy_architecture, policy_supply_chain, policy_acceptable_use, policy_ip.',
+        'policy_risk, policy_architecture, policy_supply_chain, policy_cloud_governance, policy_acceptable_use, policy_ip.',
       {
         type: z
           .string()

package/src/tools/index.ts

@@ -3,19 +3,17 @@ import type { TaigaClient } from '../client.js';
 import { registerProjectTools } from './projects.js';
 import { registerDocumentTools } from './documents.js';
 import { registerBacklogTools } from './backlogs.js';
-import { registerSkillTools } from './skills.js';
 
 /**
  * Register all MCP tools based on the API key's effective capabilities.
  * Only tools matching the key's scopes are registered -- the AI assistant
  * never sees tools it can't use.
  *
- * Beta scope: Knowledge base access (policies, skills, team documents).
+ * Beta scope: Knowledge base access (policies and team documents).
  * Post-beta: Projects, backlog items, environments, composite tools.
  */
 export function registerAllTools(server: McpServer, client: TaigaClient): void {
   registerProjectTools(server, client);
   registerDocumentTools(server, client);
   registerBacklogTools(server, client);
-  registerSkillTools(server, client);
 }

package/src/tools/projects.ts

@@ -8,7 +8,7 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
     server.tool(
       'taiga_list_teams',
       'List all teams in the organization. Use this to find team IDs ' +
-        'for reading team documents, skills, and understanding team structure. ' +
+        'for reading team documents and understanding team structure. ' +
         'Teams own domain context, tech preferences, and architecture constraints.',
       {
         limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
@@ -28,13 +28,17 @@ export function registerProjectTools(server: McpServer, client: TaigaClient) {
       'taiga_list_projects',
       'List projects in the organization. Use this to find the project you are working on ' +
         'so you can read its specification, architecture, and threat model. ' +
-        'Can filter by team or status.',
+        'Can filter by team; a status filter also exists but no longer distinguishes anything (see its description).',
       {
         teamId: z.string().uuid().optional().describe('Filter by team ID -- get team IDs from taiga_list_teams'),
         status: z
           .enum(['draft', 'active', 'archived'])
           .optional()
-          .describe('Filter by status (draft = intake in progress, active = development)'),
+          .describe(
+            'Filter by status. Taiga no longer surfaces project status in its UI (PRO-543), so every ' +
+              'project is currently "draft" and filtering by "active" or "archived" returns nothing. ' +
+              'Omit this unless you are working with data set through the API directly.'
+          ),
         limit: z.number().min(1).max(100).optional().describe('Max results (default 25)'),
       },
       { readOnlyHint: true, openWorldHint: false },

package/src/version.test.ts

@@ -0,0 +1,10 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { SERVER_VERSION } from './version.js';
+
+describe('SERVER_VERSION', () => {
+  it('is the version in package.json, not a hand-kept copy', () => {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version: string };
+    expect(SERVER_VERSION).toBe(pkg.version);
+  });
+});

package/src/version.ts

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';
+
+/**
+ * This package's own version, read from package.json at runtime.
+ *
+ * Read at runtime rather than inlined at build: the publish workflow sets the
+ * final version (`0.3.0-dev.<run>`, `0.3.0-rc.<run>`) after the bundle is
+ * built, so only a runtime read reports what was actually published. Both
+ * `src/` and the bundled `dist/index.js` sit one level under the package root,
+ * and npm always ships package.json.
+ */
+const pkg = createRequire(import.meta.url)('../package.json') as { version: string };
+
+export const SERVER_VERSION: string = pkg.version;

package/tsconfig.json

@@ -10,7 +10,8 @@
     "outDir": "./dist",
     "rootDir": "./src",
     "esModuleInterop": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "types": ["node"]
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist"]