@daghis/teamcity-mcp 0.1.2

package/tests/unit/tools/agent-vcs-admin.test.ts

@@ -0,0 +1,121 @@
+// Full mode for write tools
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: agent admin & VCS', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('authorize_agent sets authorized field and returns JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const setAgentField = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ agents: { setAgentField } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('authorize_agent').handler({
+            agentId: 'A1',
+            authorize: true,
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'authorize_agent',
+            agentId: 'A1',
+            authorized: true,
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('assign_agent_to_pool sets pool and returns JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const setAgentPool = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ agents: { setAgentPool } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('assign_agent_to_pool').handler({
+            agentId: 'A1',
+            poolId: '2',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'assign_agent_to_pool',
+            agentId: 'A1',
+            poolId: '2',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('add_vcs_root_to_build attaches root and returns JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const addVcsRootToBuildType = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ buildTypes: { addVcsRootToBuildType } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('add_vcs_root_to_build').handler({
+            buildTypeId: 'BT1',
+            vcsRootId: 'VCS1',
+            checkoutRules: '+:.',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'add_vcs_root_to_build',
+            buildTypeId: 'BT1',
+            vcsRootId: 'VCS1',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('create_vcs_root creates root and returns JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const addVcsRoot = jest.fn(async () => ({ data: { id: 'VCS1' } }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ vcsRoots: { addVcsRoot } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('create_vcs_root').handler({
+            projectId: 'P1',
+            name: 'Root',
+            id: 'VCS1',
+            vcsName: 'jetbrains.git',
+            url: 'https://git',
+            branch: 'main',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({ success: true, action: 'create_vcs_root', id: 'VCS1' });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/availability-and-queue.test.ts

@@ -0,0 +1,118 @@
+// Ensure full mode for write tools
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: availability & queue structured tools', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('set_agent_enabled returns structured JSON', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const setEnabledInfo = jest.fn(async () => ({ data: { status: true } }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ agents: { setEnabledInfo } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getTool } = require('@/tools');
+          const tool = getTool('set_agent_enabled');
+          const res = await tool.handler({ agentId: 'A1', enabled: true });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'set_agent_enabled',
+            agentId: 'A1',
+            enabled: true,
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('bulk_set_agents_enabled aggregates results', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const getAllAgents = jest.fn(async () => ({
+            data: { agent: [{ id: '1' }, { id: '2' }] },
+          }));
+          const setEnabledInfo = jest.fn(async () => ({ data: { status: false } }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ agents: { getAllAgents, setEnabledInfo } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getTool } = require('@/tools');
+          const tool = getTool('bulk_set_agents_enabled');
+          const res = await tool.handler({ enabled: false, locator: 'enabled:true' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'bulk_set_agents_enabled',
+            total: 2,
+            succeeded: 2,
+            failed: 0,
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('get_build_status can include queue totals and reason', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          // Mock status manager to return a queued build with queuePosition
+          jest.doMock('@/teamcity/build-status-manager', () => ({
+            BuildStatusManager: class {
+              // eslint-disable-next-line class-methods-use-this
+              async getBuildStatus() {
+                return {
+                  buildId: 'b123',
+                  state: 'queued',
+                  status: 'UNKNOWN',
+                  percentageComplete: 0,
+                  queuePosition: 2,
+                };
+              }
+            },
+          }));
+          const getAllQueuedBuilds = jest.fn(async (_locator?: string, fields?: string) => {
+            if (fields === 'count') return { data: { count: 5 } };
+            return { data: { build: [] } };
+          });
+          const getQueuedBuild = jest.fn(async () => ({ data: { waitReason: 'No agent' } }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ buildQueue: { getAllQueuedBuilds, getQueuedBuild } }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getTool } = require('@/tools');
+          const tool = getTool('get_build_status');
+          const res = await tool.handler({
+            buildId: 'b123',
+            includeQueueTotals: true,
+            includeQueueReason: true,
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            buildId: 'b123',
+            state: 'queued',
+            totalQueued: 5,
+            waitReason: 'No agent',
+            canMoveToTop: true,
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/branches-vcs-agents.test.ts

@@ -0,0 +1,119 @@
+// getTool is required within isolateModules per test
+
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: branches, vcs, agents happy paths', () => {
+  it('list_branches by projectId aggregates unique branch names', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                listBuilds: async (_: string) => ({
+                  build: [
+                    { branchName: 'main' },
+                    { branchName: 'dev' },
+                    { branchName: 'main' },
+                    { branchName: null },
+                  ],
+                }),
+              }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_branches').handler({ projectId: 'P1' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.branches.sort()).toEqual(['dev', 'main']);
+          expect(payload.count).toBe(2);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_vcs_roots paginated first page', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const getAllVcsRoots = jest.fn(async (_?: string) => ({
+            data: { 'vcs-root': [{ id: 'v1' }, { id: 'v2' }], count: 3 },
+          }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ vcsRoots: { getAllVcsRoots } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('list_vcs_roots').handler({ pageSize: 2 });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.items).toHaveLength(2);
+          expect(payload.pagination.page).toBe(1);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('get_vcs_root returns details and properties', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const getAllVcsRoots = jest.fn(async () => ({
+            data: { vcsRoot: [{ id: 'v1', name: 'Root', href: '/v1' }] },
+          }));
+          const getAllVcsRootProperties = jest.fn(async () => ({
+            data: { property: [{ name: 'url', value: 'git@example' }] },
+          }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ vcsRoots: { getAllVcsRoots, getAllVcsRootProperties } }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('get_vcs_root').handler({ id: 'v1' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.id).toBe('v1');
+          expect(payload.properties.property[0].name).toBe('url');
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('list_agents and list_agent_pools basic page', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const getAllAgents = jest.fn(async (_?: string) => ({
+            data: { agent: [{ id: 1 }, { id: 2 }], count: 2 },
+          }));
+          const getAllAgentPools = jest.fn(async (_?: string) => ({
+            data: { agentPool: [{ id: 1 }], count: 1 },
+          }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({ agents: { getAllAgents }, agentPools: { getAllAgentPools } }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const agentsRes = await getRequiredTool('list_agents').handler({ pageSize: 2 });
+          const poolsRes = await getRequiredTool('list_agent_pools').handler({ pageSize: 1 });
+          expect(JSON.parse((agentsRes.content?.[0]?.text as string) ?? '{}').items.length).toBe(2);
+          expect(JSON.parse((poolsRes.content?.[0]?.text as string) ?? '{}').items.length).toBe(1);
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/build-actions-and-status.test.ts

@@ -0,0 +1,125 @@
+// getTool is required within isolateModules per test
+
+// Mock config to run tools in full mode for actions
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: build actions and status/basic info', () => {
+  it('get_build returns JSON build payload', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                getBuild: async (id: string) => ({
+                  id,
+                  number: '42',
+                  status: 'SUCCESS',
+                  state: 'finished',
+                  statusText: 'OK',
+                }),
+              }),
+            },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('get_build').handler({ buildId: 'b1' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload.id).toBe('b1');
+          expect(payload.number).toBe('42');
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('trigger_build uses API and returns structured JSON', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const triggerBuild = jest.fn(async () => ({
+            id: 777,
+            state: 'queued',
+            status: 'UNKNOWN',
+          }));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ triggerBuild }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('trigger_build').handler({
+            buildTypeId: 'bt1',
+            branchName: 'main',
+            comment: 'go',
+          });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({ success: true, action: 'trigger_build', buildId: '777' });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('cancel_queued_build calls deleteQueuedBuild and returns structured JSON', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const deleteQueuedBuild = jest.fn(async () => ({}));
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: { getInstance: () => ({ buildQueue: { deleteQueuedBuild } }) },
+          }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('cancel_queued_build').handler({ buildId: 'qb1' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({
+            success: true,
+            action: 'cancel_queued_build',
+            buildId: 'qb1',
+          });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+
+  it('get_build_status returns structured status JSON', async () => {
+    jest.resetModules();
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          // Mock BuildStatusManager to avoid hitting real adapter
+          jest.doMock('@/teamcity/build-status-manager', () => ({
+            BuildStatusManager: class {
+              // eslint-disable-next-line class-methods-use-this
+              async getBuildStatus() {
+                return {
+                  buildId: 'b9',
+                  buildNumber: '9',
+                  state: 'finished',
+                  status: 'SUCCESS',
+                  statusText: 'All good',
+                  percentageComplete: 100,
+                };
+              }
+            },
+          }));
+          jest.doMock('@/api-client', () => ({ TeamCityAPI: { getInstance: () => ({}) } }));
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getRequiredTool } = require('@/tools');
+          const res = await getRequiredTool('get_build_status').handler({ buildId: 'b9' });
+          const payload = JSON.parse((res.content?.[0]?.text as string) ?? '{}');
+          expect(payload).toMatchObject({ buildId: 'b9', state: 'finished', status: 'SUCCESS' });
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});

package/tests/unit/tools/bulk-surface-coverage.test.ts

@@ -0,0 +1,116 @@
+jest.mock('@/config', () => ({
+  getTeamCityUrl: () => 'https://example.test',
+  getTeamCityToken: () => 'token',
+  getMCPMode: () => 'full',
+}));
+
+describe('tools: bulk surface coverage for list & queue ops', () => {
+  afterEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  it('list tools accept fields/locator and queue ops execute', async () => {
+    await new Promise<void>((resolve, reject) => {
+      jest.isolateModules(() => {
+        (async () => {
+          const projects = {
+            getAllProjects: jest.fn(async () => ({ data: { project: [], count: 0 } })),
+          };
+          const buildTypes = {
+            getAllBuildTypes: jest.fn(async () => ({ data: { buildType: [], count: 0 } })),
+          };
+          const builds = { getAllBuilds: jest.fn(async () => ({ data: { build: [], count: 0 } })) };
+          const agents = {
+            getAllAgents: jest.fn(async () => ({ data: { agent: [], count: 0 } })),
+            setEnabledInfo: jest.fn(async () => ({ data: {} })),
+          } as unknown as {
+            getAllAgents: jest.Mock;
+            setEnabledInfo: jest.Mock;
+          };
+          const agentPools = {
+            getAllAgentPools: jest.fn(async () => ({ data: { agentPool: [], count: 0 } })),
+          };
+          const vcsRoots = {
+            getAllVcsRoots: jest.fn(async () => ({ data: { 'vcs-root': [], count: 0 } })),
+          };
+          const buildQueue = {
+            getAllQueuedBuilds: jest.fn(async () => ({ data: { build: [], count: 0 } })),
+            setQueuedBuildsOrder: jest.fn(async () => ({ data: {} })),
+            deleteQueuedBuild: jest.fn(async () => ({ data: {} })),
+          };
+          jest.doMock('@/api-client', () => ({
+            TeamCityAPI: {
+              getInstance: () => ({
+                projects,
+                buildTypes,
+                builds,
+                agents,
+                agentPools,
+                vcsRoots,
+                buildQueue,
+              }),
+            },
+          }));
+
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const { getTool } = require('@/tools');
+
+          // Exercise list tools with fields/locator
+          await getTool('list_projects').handler({
+            locator: 'archived:false',
+            pageSize: 1,
+            fields: '$short',
+          });
+          await getTool('list_build_configs').handler({
+            locator: 'paused:false',
+            pageSize: 1,
+            fields: 'id,name',
+          });
+          await getTool('list_builds').handler({
+            locator: 'state:running',
+            pageSize: 1,
+            fields: 'id,state',
+          });
+          await getTool('list_agents').handler({
+            locator: 'enabled:true',
+            pageSize: 1,
+            fields: 'id,name',
+          });
+          await getTool('list_agent_pools').handler({ pageSize: 1, fields: 'id,name' });
+          await getTool('list_vcs_roots').handler({ pageSize: 1, fields: 'id,name' });
+          await getTool('list_queued_builds').handler({
+            locator: 'project:(id:Root)',
+            pageSize: 1,
+            fields: 'id,waitReason',
+          });
+
+          // Exercise set_build_configs_paused with cancelQueued
+          await getTool('set_build_configs_paused').handler({
+            buildTypeIds: ['bt1', 'bt2'],
+            paused: true,
+            cancelQueued: true,
+          });
+
+          // Exercise pause/resume queue by pool
+          // Supply one agent to disable/enable to touch those branches
+          agents.getAllAgents.mockResolvedValueOnce({
+            data: { agent: [{ id: '123' }], count: 1 },
+          } as unknown as { data: { agent: Array<{ id: string }>; count: number } });
+          await getTool('pause_queue_for_pool').handler({
+            poolId: '1',
+            comment: 'maint',
+            until: '2025-01-01T00:00:00Z',
+          });
+          agents.getAllAgents.mockResolvedValueOnce({
+            data: { agent: [{ id: '123' }], count: 1 },
+          } as unknown as { data: { agent: Array<{ id: string }>; count: number } });
+          await getTool('resume_queue_for_pool').handler({ poolId: '1' });
+
+          // Behavior: no exceptions and handlers returned successfully
+          resolve();
+        })().catch(reject);
+      });
+    });
+  });
+});