@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/e2e/index.ts

@@ -1,166 +0,0 @@
-#!/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

@@ -1,73 +0,0 @@
-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

@@ -1,67 +0,0 @@
-#!/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

@@ -1,108 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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);
-});