@dpesch/mantisbt-mcp-server 1.0.0

package/tests/helpers/mock-server.ts

@@ -0,0 +1,32 @@
+// Typ für das Result-Objekt das die Tools zurückgeben
+export interface ToolResult {
+  content: Array<{ type: string; text: string }>;
+  isError?: boolean;
+}
+
+// Handler-Typ (args ist der Zod-geparste Input)
+type ToolHandler = (args: Record<string, unknown>) => Promise<ToolResult>;
+
+export class MockMcpServer {
+  private readonly handlers = new Map<string, ToolHandler>();
+
+  // Nachahmt McpServer.registerTool – fängt Handler ein
+  registerTool(name: string, _definition: unknown, handler: ToolHandler): void {
+    this.handlers.set(name, handler);
+  }
+
+  // Ruft den eingefangenen Handler auf
+  async callTool(name: string, args: Record<string, unknown> = {}): Promise<ToolResult> {
+    const handler = this.handlers.get(name);
+    if (!handler) throw new Error(`Tool not registered: ${name}`);
+    return handler(args);
+  }
+
+  hasToolRegistered(name: string): boolean {
+    return this.handlers.has(name);
+  }
+
+  registeredToolNames(): string[] {
+    return [...this.handlers.keys()];
+  }
+}

package/tests/tools/issues.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MantisClient } from '../../src/client.js';
+import { registerIssueTools } from '../../src/tools/issues.js';
+import { MockMcpServer } from '../helpers/mock-server.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, '..', 'fixtures');
+
+// ---------------------------------------------------------------------------
+// Fixtures laden (mit Inline-Fallback)
+// ---------------------------------------------------------------------------
+
+const getIssueFixturePath = join(fixturesDir, 'get_issue.json');
+const listIssuesFixturePath = join(fixturesDir, 'list_issues.json');
+
+const getIssueFixture = existsSync(getIssueFixturePath)
+  ? (JSON.parse(readFileSync(getIssueFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string }> })
+  : { issues: [{ id: 42, summary: 'Test Issue' }] };
+
+const listIssuesFixture = existsSync(listIssuesFixturePath)
+  ? (JSON.parse(readFileSync(listIssuesFixturePath, 'utf-8')) as { issues: Array<{ id: number; summary: string }>; total_count: number })
+  : { issues: [{ id: 42, summary: 'Test Issue' }], total_count: 1 };
+
+// ---------------------------------------------------------------------------
+// Helper: minimale Response nachbauen
+// ---------------------------------------------------------------------------
+
+function makeResponse(status: number, body: string): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: `Status ${status}`,
+    text: () => Promise.resolve(body),
+    headers: { get: (_key: string) => null },
+  } as unknown as Response;
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+let mockServer: MockMcpServer;
+let client: MantisClient;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  client = new MantisClient('https://mantis.example.com', 'test-token');
+  registerIssueTools(mockServer as never, client);
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+// ---------------------------------------------------------------------------
+// get_issue
+// ---------------------------------------------------------------------------
+
+describe('get_issue', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('get_issue')).toBe(true);
+  });
+
+  it('gibt issue-Daten aus der Fixture zurück', async () => {
+    const issueId = getIssueFixture.issues[0]!.id;
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
+
+    const result = await mockServer.callTool('get_issue', { id: issueId });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { id: number };
+    expect(parsed.id).toBe(issueId);
+  });
+
+  it('ruft den richtigen Endpoint auf', async () => {
+    const issueId = getIssueFixture.issues[0]!.id;
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getIssueFixture)));
+
+    await mockServer.callTool('get_issue', { id: issueId });
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    expect(calledUrl).toContain(`issues/${issueId}`);
+  });
+
+  it('gibt isError: true bei 404 zurück', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(404, JSON.stringify({ message: 'Issue not found' })),
+    );
+
+    const result = await mockServer.callTool('get_issue', { id: 9999 });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('Error:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list_issues
+// ---------------------------------------------------------------------------
+
+describe('list_issues', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('list_issues')).toBe(true);
+  });
+
+  it('gibt Issues-Array zurück', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
+
+    const result = await mockServer.callTool('list_issues', { page: 1, page_size: 3 });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { issues: unknown[] };
+    expect(Array.isArray(parsed.issues)).toBe(true);
+  });
+
+  it('übergibt project_id als Query-Parameter', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listIssuesFixture)));
+
+    await mockServer.callTool('list_issues', { project_id: 7, page: 1, page_size: 10 });
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    const url = new URL(calledUrl);
+    expect(url.searchParams.get('project_id')).toBe('7');
+  });
+});

package/tests/tools/projects.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MantisClient } from '../../src/client.js';
+import { registerProjectTools } from '../../src/tools/projects.js';
+import { MockMcpServer } from '../helpers/mock-server.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, '..', 'fixtures');
+
+// ---------------------------------------------------------------------------
+// Fixtures laden (mit Inline-Fallback)
+// ---------------------------------------------------------------------------
+
+const listProjectsFixturePath = join(fixturesDir, 'list_projects.json');
+
+const listProjectsFixture = existsSync(listProjectsFixturePath)
+  ? (JSON.parse(readFileSync(listProjectsFixturePath, 'utf-8')) as { projects: Array<{ id: number; name: string }> })
+  : { projects: [{ id: 1, name: 'Test Project' }] };
+
+const firstProjectId = listProjectsFixture.projects[0]?.id ?? 1;
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeResponse(status: number, body: string): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: `Status ${status}`,
+    text: () => Promise.resolve(body),
+    headers: { get: (_key: string) => null },
+  } as unknown as Response;
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+let mockServer: MockMcpServer;
+let client: MantisClient;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  client = new MantisClient('https://mantis.example.com', 'test-token');
+  registerProjectTools(mockServer as never, client);
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+// ---------------------------------------------------------------------------
+// list_projects
+// ---------------------------------------------------------------------------
+
+describe('list_projects', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('list_projects')).toBe(true);
+  });
+
+  it('gibt Projekte-Array zurück', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(listProjectsFixture)));
+
+    const result = await mockServer.callTool('list_projects', {});
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as unknown[];
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBeGreaterThan(0);
+  });
+
+  it('gibt isError: true bei 401 zurück', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(401, JSON.stringify({ message: 'Unauthorized' })),
+    );
+
+    const result = await mockServer.callTool('list_projects', {});
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('Error:');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get_project_versions
+// ---------------------------------------------------------------------------
+
+describe('get_project_versions', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('get_project_versions')).toBe(true);
+  });
+
+  it('ruft den richtigen Endpoint auf', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ versions: [] })));
+
+    await mockServer.callTool('get_project_versions', { project_id: firstProjectId });
+
+    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
+    expect(calledUrl).toContain(`projects/${firstProjectId}/versions`);
+  });
+
+  it('gibt leeres Array zurück wenn keine Versionen vorhanden', async () => {
+    const fixture = JSON.parse(readFileSync(join(fixturesDir, 'get_project_versions.json'), 'utf-8')) as { versions: unknown[] };
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(fixture)));
+
+    const result = await mockServer.callTool('get_project_versions', { project_id: firstProjectId });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as unknown[];
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(0);
+  });
+
+  it('gibt Versionen zurück wenn vorhanden', async () => {
+    const fixture = JSON.parse(readFileSync(join(fixturesDir, 'get_project_versions_with_data.json'), 'utf-8')) as { versions: Array<{ id: number; name: string; released: boolean }> };
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(fixture)));
+
+    const result = await mockServer.callTool('get_project_versions', { project_id: firstProjectId });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; name: string; released: boolean }>;
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed.length).toBeGreaterThan(0);
+    expect(parsed[0]).toHaveProperty('id');
+    expect(parsed[0]).toHaveProperty('name');
+    expect(parsed[0]).toHaveProperty('released');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// get_project_categories
+// ---------------------------------------------------------------------------
+
+describe('get_project_categories', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('get_project_categories')).toBe(true);
+  });
+
+  it('strippt den [All Projects] Prefix', async () => {
+    const categoriesFixture = {
+      projects: [{
+        id: firstProjectId,
+        name: 'Test Project',
+        categories: [
+          { id: 1, name: '[All Projects] General' },
+          { id: 2, name: 'Backend' },
+        ],
+      }],
+    };
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(categoriesFixture)));
+
+    const result = await mockServer.callTool('get_project_categories', { project_id: firstProjectId });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; name: string }>;
+    expect(Array.isArray(parsed)).toBe(true);
+    // Erstes Element soll den Prefix nicht mehr haben
+    const firstCategory = parsed.find((c) => c.id === 1);
+    expect(firstCategory?.name).toBe('General');
+    // Zweites Element ohne Prefix bleibt unverändert
+    const secondCategory = parsed.find((c) => c.id === 2);
+    expect(secondCategory?.name).toBe('Backend');
+  });
+});

package/tests/tools/users.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MantisClient } from '../../src/client.js';
+import { registerUserTools } from '../../src/tools/users.js';
+import { MockMcpServer } from '../helpers/mock-server.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, '..', 'fixtures');
+
+// ---------------------------------------------------------------------------
+// Fixtures laden (mit Inline-Fallback)
+// ---------------------------------------------------------------------------
+
+const getCurrentUserFixturePath = join(fixturesDir, 'get_current_user.json');
+
+const getCurrentUserFixture = existsSync(getCurrentUserFixturePath)
+  ? (JSON.parse(readFileSync(getCurrentUserFixturePath, 'utf-8')) as { id: number; name: string; real_name?: string; email?: string })
+  : { id: 5, name: 'testuser', real_name: 'Test User', email: 'test@example.com' };
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeResponse(status: number, body: string): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: `Status ${status}`,
+    text: () => Promise.resolve(body),
+    headers: { get: (_key: string) => null },
+  } as unknown as Response;
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+let mockServer: MockMcpServer;
+let client: MantisClient;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  client = new MantisClient('https://mantis.example.com', 'test-token');
+  registerUserTools(mockServer as never, client);
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+// ---------------------------------------------------------------------------
+// get_current_user
+// ---------------------------------------------------------------------------
+
+describe('get_current_user', () => {
+  it('ist registriert', () => {
+    expect(mockServer.hasToolRegistered('get_current_user')).toBe(true);
+  });
+
+  it('gibt User-Daten zurück mit id und name', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(getCurrentUserFixture)));
+
+    const result = await mockServer.callTool('get_current_user', {});
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { id: number; name: string };
+    expect(typeof parsed.id).toBe('number');
+    expect(typeof parsed.name).toBe('string');
+    expect(parsed.id).toBe(getCurrentUserFixture.id);
+    expect(parsed.name).toBe(getCurrentUserFixture.name);
+  });
+});

package/tests/version-hint.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseVersion, compareVersions, VersionHintService } from '../src/version-hint.js';
+
+// ---------------------------------------------------------------------------
+// parseVersion
+// ---------------------------------------------------------------------------
+
+describe('parseVersion()', () => {
+  it('parses a standard version string', () => {
+    expect(parseVersion('2.25.7')).toEqual([2, 25, 7]);
+  });
+
+  it('strips leading v prefix', () => {
+    expect(parseVersion('v1.2.3')).toEqual([1, 2, 3]);
+  });
+
+  it('returns null for invalid strings', () => {
+    expect(parseVersion('not-a-version')).toBeNull();
+    expect(parseVersion('')).toBeNull();
+    expect(parseVersion('1.2')).toBeNull();
+  });
+
+  it('ignores extra suffix after patch number', () => {
+    expect(parseVersion('2.25.7-beta')).toEqual([2, 25, 7]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// compareVersions
+// ---------------------------------------------------------------------------
+
+describe('compareVersions()', () => {
+  it('returns 0 for equal versions', () => {
+    expect(compareVersions([2, 25, 7], [2, 25, 7])).toBe(0);
+  });
+
+  it('returns -1 when first version is older (major)', () => {
+    expect(compareVersions([1, 0, 0], [2, 0, 0])).toBe(-1);
+  });
+
+  it('returns 1 when first version is newer (major)', () => {
+    expect(compareVersions([3, 0, 0], [2, 99, 99])).toBe(1);
+  });
+
+  it('compares minor version correctly', () => {
+    expect(compareVersions([2, 24, 0], [2, 25, 0])).toBe(-1);
+    expect(compareVersions([2, 26, 0], [2, 25, 0])).toBe(1);
+  });
+
+  it('compares patch version correctly', () => {
+    expect(compareVersions([2, 25, 6], [2, 25, 7])).toBe(-1);
+    expect(compareVersions([2, 25, 8], [2, 25, 7])).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VersionHintService – getUpdateHint()
+// ---------------------------------------------------------------------------
+
+describe('VersionHintService – getUpdateHint()', () => {
+  it('returns null when installedVersion is not set', () => {
+    const svc = new VersionHintService();
+    expect(svc.getUpdateHint()).toBeNull();
+  });
+
+  it('returns null when latestVersion is not set', () => {
+    const svc = new VersionHintService();
+    // Simulate installed version via onSuccessfulResponse
+    const mockResponse = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.6' : null },
+    } as unknown as Response;
+    svc.onSuccessfulResponse(mockResponse);
+    expect(svc.getUpdateHint()).toBeNull();
+  });
+
+  it('returns hint string when latestVersion > installedVersion', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([{ name: 'release-2.25.7' }]),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+
+    const mockResponse = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.6' : null },
+    } as unknown as Response;
+    svc.onSuccessfulResponse(mockResponse);
+
+    // Trigger fetch and wait for it to complete
+    svc.triggerLatestVersionFetch();
+    await svc.waitForLatestVersion(1000);
+
+    const hint = svc.getUpdateHint();
+    expect(hint).not.toBeNull();
+    expect(hint).toContain('2.25.7');
+    expect(hint).toContain('2.25.6');
+  });
+
+  it('returns null when installed version equals latest version', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([{ name: 'release-2.25.7' }]),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+
+    const mockResponse = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.7' : null },
+    } as unknown as Response;
+    svc.onSuccessfulResponse(mockResponse);
+
+    svc.triggerLatestVersionFetch();
+    await svc.waitForLatestVersion(1000);
+
+    expect(svc.getUpdateHint()).toBeNull();
+  });
+
+  it('returns null when installedVersion is newer than latestVersion', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([{ name: 'release-2.25.6' }]),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+
+    const mockResponse = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.7' : null },
+    } as unknown as Response;
+    svc.onSuccessfulResponse(mockResponse);
+
+    svc.triggerLatestVersionFetch();
+    await svc.waitForLatestVersion(1000);
+
+    expect(svc.getUpdateHint()).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VersionHintService – onSuccessfulResponse()
+// ---------------------------------------------------------------------------
+
+describe('VersionHintService – onSuccessfulResponse()', () => {
+  it('extracts X-Mantis-Version header from response', () => {
+    const svc = new VersionHintService();
+    const mockResponse = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.7' : null },
+    } as unknown as Response;
+
+    svc.onSuccessfulResponse(mockResponse);
+    expect(svc.getInstalledVersion()).toBe('2.25.7');
+  });
+
+  it('does not overwrite already set installedVersion', () => {
+    const svc = new VersionHintService();
+
+    const first = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.6' : null },
+    } as unknown as Response;
+    const second = {
+      headers: { get: (key: string) => key === 'X-Mantis-Version' ? '2.25.7' : null },
+    } as unknown as Response;
+
+    svc.onSuccessfulResponse(first);
+    svc.onSuccessfulResponse(second);
+
+    expect(svc.getInstalledVersion()).toBe('2.25.6');
+  });
+
+  it('ignores response without X-Mantis-Version header', () => {
+    const svc = new VersionHintService();
+    const mockResponse = {
+      headers: { get: (_key: string) => null },
+    } as unknown as Response;
+
+    svc.onSuccessfulResponse(mockResponse);
+    expect(svc.getInstalledVersion()).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// VersionHintService – triggerLatestVersionFetch()
+// ---------------------------------------------------------------------------
+
+describe('VersionHintService – triggerLatestVersionFetch()', () => {
+  beforeEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('only triggers fetch once even when called multiple times', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([{ name: 'release-2.25.7' }]),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+    svc.triggerLatestVersionFetch();
+    svc.triggerLatestVersionFetch();
+    svc.triggerLatestVersionFetch();
+    await svc.waitForLatestVersion(1000);
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
+
+  it('handles GitHub API errors gracefully (no crash, latestVersion stays null)', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: false });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+    svc.triggerLatestVersionFetch();
+    await svc.waitForLatestVersion(500);
+
+    expect(svc.getLatestVersion()).toBeNull();
+  });
+
+  it('handles fetch network errors gracefully', async () => {
+    const fetchMock = vi.fn().mockRejectedValue(new Error('Network error'));
+    vi.stubGlobal('fetch', fetchMock);
+
+    const svc = new VersionHintService();
+    svc.triggerLatestVersionFetch();
+    // Give async fire-and-forget time to complete
+    await new Promise(r => setTimeout(r, 100));
+
+    expect(svc.getLatestVersion()).toBeNull();
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "noEmit": false
+  },
+  "include": ["src/**/*"]
+}

package/vitest.config.ts

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