@daghis/teamcity-mcp 0.1.2

package/tests/e2e/index.ts

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { MCPTestClient } from './mcp-client';
+
+type Mode = 'dev' | 'full' | 'both';
+
+interface CLIArgs {
+  mode: Mode;
+  cmd: 'smoke' | 'tools' | 'call';
+  tool?: string;
+  json?: string;
+}
+
+function parseArgs(argv: string[]): CLIArgs {
+  const args = argv.slice(2);
+  let mode: Mode = 'both';
+  let cmd: CLIArgs['cmd'] = 'smoke';
+  let tool: string | undefined;
+  let json: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--mode' && i + 1 < args.length) {
+      const m = args[++i] as Mode;
+      mode = m;
+    } else if (a === 'smoke' || a === 'tools' || a === 'call') {
+      cmd = a;
+    } else if (!tool) {
+      tool = a;
+    } else if (!json) {
+      json = a;
+    }
+  }
+  return { mode, cmd, tool, json };
+}
+
+async function runTools(mode: Exclude<Mode, 'both'>): Promise<void> {
+  const client = new MCPTestClient({ mode });
+  await client.connect();
+  const tools = await client.listTools();
+  console.log(JSON.stringify({ mode, tools }));
+  await client.close();
+}
+
+async function runCall(mode: Exclude<Mode, 'both'>, tool: string, json?: string): Promise<void> {
+  const client = new MCPTestClient({ mode });
+  await client.connect();
+  let args: Record<string, unknown> = {};
+  if (json) {
+    try {
+      args = JSON.parse(json);
+    } catch (e) {
+      console.error('Invalid JSON for args:', e);
+      process.exit(2);
+    }
+  }
+  try {
+    const res = await client.callTool(tool, args);
+    console.log(JSON.stringify({ mode, tool, args, res }));
+  } catch (e) {
+    console.error(JSON.stringify({ mode, tool, args, error: String(e) }, null, 2));
+    throw e;
+  } finally {
+    await client.close();
+  }
+}
+
+async function runSmoke(mode: Exclude<Mode, 'both'>): Promise<void> {
+  const client = new MCPTestClient({ mode });
+  await client.connect();
+
+  const tools = await client.listTools();
+  const isDev = mode === 'dev';
+
+  const pong = await client.callTool<string>('ping', { message: 'e2e' });
+  console.log(JSON.stringify({ mode, step: 'ping', pong }));
+
+  if (isDev) {
+    const shouldNotExist = [
+      'create_project',
+      'update_project_settings',
+      'delete_project',
+      'create_build_config',
+      'clone_build_config',
+      'update_build_config',
+      'set_build_configs_paused',
+      'manage_build_steps',
+      'manage_build_triggers',
+      'add_parameter',
+      'update_parameter',
+      'delete_parameter',
+      'create_vcs_root',
+      'add_vcs_root_to_build',
+      'authorize_agent',
+      'assign_agent_to_pool',
+      'set_agent_enabled',
+      'bulk_set_agents_enabled',
+      'move_queued_build_to_top',
+      'reorder_queued_builds',
+      'cancel_queued_builds_for_build_type',
+      'cancel_queued_builds_by_locator',
+      'pause_queue_for_pool',
+      'resume_queue_for_pool',
+      'get_server_metrics',
+      'list_server_health_items',
+      'get_server_health_item',
+    ];
+    for (const name of shouldNotExist) {
+      const exists = tools.includes(name);
+      console.log(JSON.stringify({ mode, step: 'tool_visibility', tool: name, exists }));
+    }
+  } else {
+    const ts = Date.now();
+    const projectId = `MCP_E2E_${ts}`;
+    const projectName = `MCP E2E ${ts}`;
+    const created = await client.callTool('create_project', {
+      id: projectId,
+      name: projectName,
+      description: 'Temporary project for MCP e2e tests',
+    });
+    process.stdout.write(`${JSON.stringify({ mode, step: 'create_project', created })}\n`);
+
+    const listed = await client.callTool('list_projects', { locator: `id:${projectId}` });
+    const listedCount =
+      typeof listed === 'object' &&
+      listed !== null &&
+      'items' in (listed as Record<string, unknown>)
+        ? Array.isArray((listed as { items?: unknown[] }).items)
+          ? ((listed as { items?: unknown[] }).items as unknown[]).length
+          : 0
+        : 0;
+    process.stdout.write(`${JSON.stringify({ mode, step: 'list_projects', listedCount })}\n`);
+
+    const deleted = await client.callTool('delete_project', { projectId });
+    process.stdout.write(`${JSON.stringify({ mode, step: 'delete_project', deleted })}\n`);
+  }
+
+  await client.close();
+}
+
+async function main(): Promise<void> {
+  const { mode, cmd, tool, json } = parseArgs(process.argv);
+
+  const runFor = async (m: Exclude<Mode, 'both'>) => {
+    if (cmd === 'tools') return runTools(m);
+    if (cmd === 'call') {
+      if (!tool) {
+        console.error('Usage: e2e call <toolName> <jsonArgs> [--mode dev|full]');
+        process.exit(2);
+      }
+      return runCall(m, tool, json);
+    }
+    return runSmoke(m);
+  };
+
+  if (mode === 'both') {
+    await runFor('dev');
+    await runFor('full');
+  } else {
+    await runFor(mode);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/tests/e2e/mcp-client.ts

@@ -0,0 +1,73 @@
+import path from 'node:path';
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+type Mode = 'dev' | 'full';
+
+export interface MCPClientOptions {
+  mode: Mode;
+  command?: string;
+  args?: string[];
+  env?: NodeJS.ProcessEnv;
+}
+
+export class MCPTestClient {
+  private client: Client;
+  private transport: StdioClientTransport;
+  private mode: Mode;
+
+  constructor(options: MCPClientOptions) {
+    this.mode = options.mode;
+    const command = options.command ?? process.execPath; // node executable
+    const tsxCli = path.resolve(process.cwd(), 'node_modules/tsx/dist/cli.cjs');
+    const serverEntry = path.resolve(process.cwd(), 'src/index.ts');
+    const args = options.args ?? [tsxCli, serverEntry];
+    const baseEnv: Record<string, string> = {};
+    for (const [k, v] of Object.entries({ ...process.env, ...options.env })) {
+      if (typeof v === 'string') baseEnv[k] = v;
+    }
+    baseEnv['MCP_MODE'] = options.mode;
+
+    this.transport = new StdioClientTransport({ command, args, env: baseEnv });
+    this.client = new Client(
+      { name: 'mcp-e2e-client', version: '0.1.0' },
+      {
+        capabilities: { tools: {} },
+      }
+    );
+  }
+
+  async connect(): Promise<void> {
+    await this.client.connect(this.transport);
+  }
+
+  async listTools(): Promise<string[]> {
+    const res = await this.client.listTools({});
+    return (res.tools ?? []).map((t) => t.name);
+  }
+
+  async callTool<T = unknown>(name: string, args: Record<string, unknown> = {}): Promise<T> {
+    const res: { content?: Array<{ type: string; text?: string }> } = (await this.client.callTool({
+      name,
+      arguments: args,
+    })) as { content?: Array<{ type: string; text?: string }> };
+    const first = res.content?.[0];
+    if (first != null && first.type === 'text' && typeof first.text === 'string') {
+      try {
+        return JSON.parse(first.text) as T;
+      } catch {
+        return first.text as unknown as T;
+      }
+    }
+    return {} as T;
+  }
+
+  async close(): Promise<void> {
+    await this.transport.close();
+  }
+
+  getMode(): Mode {
+    return this.mode;
+  }
+}

package/tests/e2e/setup-playground.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { MCPTestClient } from './mcp-client';
+
+function updateEnvFile(updates: Record<string, string>): void {
+  const envPath = path.resolve(process.cwd(), '.env');
+  let content = '';
+  try {
+    content = fs.readFileSync(envPath, 'utf8');
+  } catch {
+    content = '';
+  }
+  const lines = content.split(/\r?\n/);
+  const map = new Map<string, string>();
+  for (const line of lines) {
+    if (!line || line.trim().startsWith('#') || !line.includes('=')) continue;
+    const idx = line.indexOf('=');
+    const k = line.slice(0, idx).trim();
+    const v = line.slice(idx + 1);
+    map.set(k, v);
+  }
+  for (const [k, v] of Object.entries(updates)) {
+    map.set(k, v);
+  }
+  const out = Array.from(map.entries())
+    .map(([k, v]) => `${k}=${v}`)
+    .join('\n');
+  fs.writeFileSync(envPath, `${out}\n`, 'utf8');
+}
+
+async function main(): Promise<void> {
+  const existingId = process.env['E2E_PROJECT_ID'];
+  if (existingId) {
+    process.stdout.write(`E2E_PROJECT_ID already set (${existingId}); skipping creation.\n`);
+    return;
+  }
+
+  const ts = Date.now();
+  const id = `E2E_MCP_${ts}`;
+  const name = `E2E MCP ${ts}`;
+
+  const client = new MCPTestClient({ mode: 'full' });
+  await client.connect();
+  try {
+    await client.callTool('create_project', {
+      id,
+      name,
+      description: 'Playground for MCP E2E tests (safe to modify)',
+    });
+    process.stdout.write(`Created playground project: ${id}\n`);
+    updateEnvFile({ E2E_PROJECT_ID: id, E2E_PROJECT_NAME: name });
+    const proj = await client.callTool('get_project', { projectId: id });
+    process.stdout.write(`Verified project exists: ${JSON.stringify(proj).slice(0, 120)}...\n`);
+  } catch (e) {
+    process.stderr.write(`Failed to create playground: ${String(e)}\n`);
+    throw e;
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch((e) => {
+  process.stderr.write(String(e));
+  process.exit(1);
+});

package/tests/integration/branches-and-queue-scenario.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type {
+  ActionResult,
+  BranchList,
+  QueuedBuildList,
+  TriggerBuildResult,
+} from '../types/tool-results';
+import { callTool } from './lib/mcp-runner';
+
+const hasTeamCityEnv = Boolean(
+  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
+    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
+);
+
+const ts = Date.now();
+const PROJECT_ID = `E2E_BRANCH_${ts}`;
+const PROJECT_NAME = `E2E Branch ${ts}`;
+const BT_ID = `E2E_BRANCH_BT_${ts}`;
+const BT_NAME = `E2E Branch BuildType ${ts}`;
+const BRANCH_NAME = 'feature/e2e';
+
+let queuedId: string | undefined;
+
+describe('Branches and queue operations', () => {
+  afterAll(async () => {
+    try {
+      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    } catch (_err) {
+      expect(true).toBe(true);
+    }
+  });
+  it('creates project and build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const cproj = await callTool<ActionResult>('full', 'create_project', {
+      id: PROJECT_ID,
+      name: PROJECT_NAME,
+    });
+    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
+    const cbt = await callTool<ActionResult>('full', 'create_build_config', {
+      projectId: PROJECT_ID,
+      id: BT_ID,
+      name: BT_NAME,
+    });
+    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
+  }, 60000);
+
+  it('adds step and triggers a build on non-default branch (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const step = await callTool<ActionResult>('full', 'manage_build_steps', {
+      buildTypeId: BT_ID,
+      action: 'add',
+      name: 'echo-step',
+      type: 'simpleRunner',
+      properties: { 'script.content': 'echo "branches scenario"' },
+    });
+    expect(step).toMatchObject({ success: true, action: 'add_build_step' });
+    const trig = await callTool<TriggerBuildResult>('dev', 'trigger_build', {
+      buildTypeId: BT_ID,
+      branchName: BRANCH_NAME,
+    });
+    expect(trig).toMatchObject({ success: true, action: 'trigger_build' });
+  }, 90000);
+
+  it('lists branches for project and build type (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    try {
+      const projBranches = await callTool<BranchList>('dev', 'list_branches', {
+        projectId: PROJECT_ID,
+      });
+      expect(projBranches).toHaveProperty('branches');
+    } catch (e) {
+      // list_branches may not be available on some servers; non-fatal
+      expect(true).toBe(true);
+    }
+    try {
+      const btBranches = await callTool<BranchList>('dev', 'list_branches', { buildTypeId: BT_ID });
+      expect(btBranches).toHaveProperty('branches');
+    } catch (e) {
+      expect(true).toBe(true);
+    }
+  }, 60000);
+
+  it('lists queued builds and cancels one if present (dev cancel)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const queued = await callTool<QueuedBuildList>('dev', 'list_queued_builds', { pageSize: 10 });
+    expect(queued).toHaveProperty('items');
+    const first = (queued.items ?? [])[0];
+    if (first?.id != null) {
+      queuedId = String(first.id);
+      try {
+        const canceled = await callTool('dev', 'cancel_queued_build', { buildId: queuedId });
+        expect(canceled).toMatchObject({ success: true, action: 'cancel_queued_build' });
+      } catch (_err) {
+        // If build already started or permission denied, non-fatal
+        expect(true).toBe(true);
+      }
+    } else {
+      expect(true).toBe(true);
+    }
+  }, 60000);
+
+  it('deletes project (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const res = await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    expect(res).toMatchObject({ success: true, action: 'delete_project' });
+  }, 60000);
+});

package/tests/integration/build-config-clone-update-scenario.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type { ActionResult, BuildTypeSummary, ListResult } from '../types/tool-results';
+import { callTool } from './lib/mcp-runner';
+
+const hasTeamCityEnv = Boolean(
+  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
+    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
+);
+
+const ts = Date.now();
+const PROJECT_ID = `E2E_CLONE_${ts}`;
+const PROJECT_NAME = `E2E Clone ${ts}`;
+const BT_ID = `E2E_CLONE_BT_${ts}`;
+const BT_NAME = `E2E Clone BuildType ${ts}`;
+const CLONE_ID = `E2E_CLONE_BT2_${ts}`;
+const CLONE_NAME = `E2E Clone Copy ${ts}`;
+
+describe('Build configuration clone and update (full) with dev verification', () => {
+  it('creates project and build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const cproj = await callTool<ActionResult>('full', 'create_project', {
+      id: PROJECT_ID,
+      name: PROJECT_NAME,
+    });
+    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
+    const cbt = await callTool<ActionResult>('full', 'create_build_config', {
+      projectId: PROJECT_ID,
+      id: BT_ID,
+      name: BT_NAME,
+      description: 'Original configuration',
+    });
+    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
+  }, 60000);
+
+  it('updates build config name/description/paused (full), verifies via dev', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    try {
+      const upd = await callTool<ActionResult>('full', 'update_build_config', {
+        buildTypeId: BT_ID,
+        name: `${BT_NAME} Updated`,
+        description: 'Updated description',
+        paused: true,
+      });
+      expect(upd).toMatchObject({ success: true, action: 'update_build_config' });
+    } catch (e) {
+      // non-fatal on policy restrictions
+      expect(true).toBe(true);
+    }
+    const cfg = await callTool<BuildTypeSummary>('dev', 'get_build_config', { buildTypeId: BT_ID });
+    expect(cfg).toHaveProperty('id');
+  }, 60000);
+
+  it('clones build config (full) and verifies via dev', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    try {
+      const clone = await callTool<ActionResult>('full', 'clone_build_config', {
+        sourceBuildTypeId: BT_ID,
+        id: CLONE_ID,
+        name: CLONE_NAME,
+        projectId: PROJECT_ID,
+      });
+      expect(clone).toMatchObject({ success: true, action: 'clone_build_config' });
+      const list = await callTool<ListResult<BuildTypeSummary>>('dev', 'list_build_configs', {
+        projectId: PROJECT_ID,
+      });
+      const hasClone = (list.items ?? []).some((b) => b.id === CLONE_ID);
+      expect(hasClone).toBe(true);
+    } catch (e) {
+      // Some servers may restrict clone; non-fatal
+      expect(true).toBe(true);
+    }
+  }, 60000);
+
+  it('deletes project (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const res = await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    expect(res).toMatchObject({ success: true, action: 'delete_project' });
+  }, 60000);
+});

package/tests/integration/build-results-and-logs-scenario.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from '@jest/globals';
+
+import type {
+  ActionResult,
+  BuildLogChunk,
+  BuildRef,
+  TriggerBuildResult,
+} from '../types/tool-results';
+import { callTool } from './lib/mcp-runner';
+
+const hasTeamCityEnv = Boolean(
+  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
+    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
+);
+
+const ts = Date.now();
+const PROJECT_ID = `E2E_RESULTS_${ts}`;
+const PROJECT_NAME = `E2E Results ${ts}`;
+const BT_ID = `E2E_RESULTS_BT_${ts}`;
+const BT_NAME = `E2E Results BuildType ${ts}`;
+
+let buildId: string | undefined;
+let buildNumber: string | undefined;
+
+describe('Build results and logs: full writes + dev reads', () => {
+  afterAll(async () => {
+    try {
+      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    } catch (_e) {
+      expect(true).toBe(true);
+    }
+  });
+  it('creates project and build config (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const cproj = await callTool<ActionResult>('full', 'create_project', {
+      id: PROJECT_ID,
+      name: PROJECT_NAME,
+    });
+    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
+    const cbt = await callTool<ActionResult>('full', 'create_build_config', {
+      projectId: PROJECT_ID,
+      id: BT_ID,
+      name: BT_NAME,
+      description: 'Build results/logs scenario',
+    });
+    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
+  }, 60000);
+
+  it('adds a step and triggers a build (full add, dev trigger)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const step = await callTool('full', 'manage_build_steps', {
+      buildTypeId: BT_ID,
+      action: 'add',
+      name: 'log-output',
+      type: 'simpleRunner',
+      properties: { 'script.content': 'echo "line1" && echo "line2" && echo "line3"' },
+    });
+    expect(step).toMatchObject({ success: true, action: 'add_build_step' });
+    const trig = await callTool<TriggerBuildResult>('dev', 'trigger_build', {
+      buildTypeId: BT_ID,
+      comment: 'e2e-results',
+    });
+    expect(trig).toMatchObject({ success: true, action: 'trigger_build' });
+    buildId = trig.buildId;
+    expect(typeof buildId).toBe('string');
+  }, 90000);
+
+  it('reads build status and number (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    if (!buildId) return expect(true).toBe(true);
+    const b = await callTool<BuildRef>('dev', 'get_build', { buildId });
+    buildNumber = String(b.number ?? '');
+    expect(typeof buildNumber).toBe('string');
+  }, 60000);
+
+  it('get_build_results with flags (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    if (!buildId) return expect(true).toBe(true);
+    const res = await callTool<Record<string, unknown>>('dev', 'get_build_results', {
+      buildId,
+      includeArtifacts: true,
+      includeStatistics: true,
+      includeChanges: true,
+      includeDependencies: true,
+      artifactFilter: '*',
+      maxArtifactSize: 1024,
+    });
+    expect(res).toBeDefined();
+  }, 60000);
+
+  it('fetch_build_log with paging and tail (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    if (!buildId) return expect(true).toBe(true);
+    const page1 = await callTool<BuildLogChunk>('dev', 'fetch_build_log', {
+      buildId,
+      page: 1,
+      pageSize: 200,
+    });
+    expect(page1).toHaveProperty('lines');
+    const range = await callTool<BuildLogChunk>('dev', 'fetch_build_log', {
+      buildId,
+      startLine: 0,
+      lineCount: 2,
+    });
+    expect(range).toHaveProperty('lines');
+    const tail = await callTool<BuildLogChunk>('dev', 'fetch_build_log', {
+      buildId,
+      tail: true,
+      lineCount: 1,
+    });
+    expect(tail).toHaveProperty('lines');
+  }, 60000);
+
+  it('fetch_build_log by buildNumber + buildTypeId (dev)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    if (!buildNumber) return expect(true).toBe(true);
+    try {
+      const byNumber = await callTool<BuildLogChunk>('dev', 'fetch_build_log', {
+        buildNumber,
+        buildTypeId: BT_ID,
+        page: 1,
+        pageSize: 50,
+      });
+      expect(byNumber).toHaveProperty('lines');
+    } catch (e) {
+      // Build number resolution may not be stable across branches; non-fatal
+      expect(true).toBe(true);
+    }
+  }, 60000);
+
+  it('deletes project (full)', async () => {
+    if (!hasTeamCityEnv) return expect(true).toBe(true);
+    const res = await callTool('full', 'delete_project', { projectId: PROJECT_ID });
+    expect(res).toMatchObject({ success: true, action: 'delete_project' });
+  }, 60000);
+});