@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/tests/integration/dev-tools-list.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { spawn } from 'child_process';
-import path from 'path';
-
-const hasTeamCityEnv = Boolean(
-  (process.env['TEAMCITY_URL'] ?? process.env['TEAMCITY_SERVER_URL']) &&
-    (process.env['TEAMCITY_TOKEN'] ?? process.env['TEAMCITY_API_TOKEN'])
-);
-
-// Expected dev-mode tools as per docs/mcp-tools-mode-matrix.md
-const EXPECTED_DEV_TOOLS = new Set([
-  'ping',
-  // Projects
-  'list_projects',
-  'get_project',
-  'list_project_hierarchy',
-  // Builds
-  'list_builds',
-  'get_build',
-  'trigger_build',
-  'cancel_queued_build',
-  'get_build_status',
-  'fetch_build_log',
-  'get_build_results',
-  'analyze_build_problems',
-  // Build Configs
-  'list_build_configs',
-  'get_build_config',
-  // Tests
-  'list_test_failures',
-  'get_test_details',
-  // VCS
-  'list_vcs_roots',
-  'get_vcs_root',
-  // Queue
-  'list_queued_builds',
-  // Server
-  'get_server_info',
-  'check_teamcity_connection',
-  'check_availability_guard',
-  // Agents (read-only)
-  'list_agents',
-  'list_agent_pools',
-  'get_agent_enabled_info',
-  // Compatibility (read-only)
-  'get_compatible_build_types_for_agent',
-  'get_incompatible_build_types_for_agent',
-  'get_compatible_agents_for_build_type',
-  'count_compatible_agents_for_build_type',
-  'get_compatible_agents_for_queued_build',
-  // Branches & Params
-  'list_branches',
-  'list_parameters',
-]);
-
-describe('Dev mode tool surface', () => {
-  it('matches the expected dev-mode tool set exactly', async () => {
-    if (!hasTeamCityEnv) {
-      return expect(true).toBe(true);
-    }
-    // Invoke the e2e CLI directly via tsx to avoid ESM import issues in tests
-    const tsx = path.resolve(process.cwd(), 'node_modules/tsx/dist/cli.cjs');
-    const entry = path.resolve(process.cwd(), 'tests/e2e/index.ts');
-    const child = spawn(process.execPath, [tsx, entry, 'tools', '--mode', 'dev'], {
-      env: { ...process.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    const chunks: Buffer[] = [];
-    await new Promise<void>((resolve, reject) => {
-      child.stdout.on('data', (c: Buffer) => chunks.push(c));
-      const errs: Buffer[] = [];
-      child.stderr.on('data', (c: Buffer) => errs.push(c));
-      child.on('error', reject);
-      child.on('close', (code) => {
-        if (code !== 0) {
-          // eslint-disable-next-line no-console
-          console.error(Buffer.concat(errs).toString('utf8'));
-          reject(new Error(`Process exited with code ${code}`));
-        } else resolve();
-      });
-    });
-    // Output is multiple JSON objects; take the last complete JSON block
-    const out = Buffer.concat(chunks).toString('utf8');
-    const matches = out.match(/\{[\s\S]*\}/g) ?? [];
-    const last = matches[matches.length - 1] ?? '{}';
-    const parsed = JSON.parse(last) as { tools?: string[] };
-    const tools = parsed.tools ?? [];
-    const actual = new Set(tools);
-    // Compare symmetric difference for helpful diff on failure
-    const missing = [...EXPECTED_DEV_TOOLS].filter((t) => !actual.has(t));
-    const extra = [...actual].filter((t) => !EXPECTED_DEV_TOOLS.has(t));
-
-    if (missing.length || extra.length) {
-      // Provide readable assertion output
-      // eslint-disable-next-line no-console
-      console.error('Dev tools mismatch', { missing, extra, actual: tools });
-    }
-
-    expect(missing).toEqual([]);
-    expect(extra).toEqual([]);
-  }, 120000);
-});

package/tests/integration/e2e-scenario.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-import type {
-  ActionResult,
-  BuildLogChunk,
-  BuildTypeSummary,
-  ListResult,
-  ProjectRef,
-  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'])
-);
-
-// Ephemeral ids for this suite
-const ts = Date.now();
-const PROJECT_ID = `E2E_TMP_${ts}`;
-const PROJECT_NAME = `E2E TMP ${ts}`;
-const BT_ID = `E2E_TMP_BT_${ts}`;
-const BT_NAME = `E2E TMP BuildType ${ts}`;
-
-let created = false;
-let createdBuildType = false;
-let triggeredBuildId: string | undefined;
-
-describe('E2E scenario: full setup → dev reads → full teardown', () => {
-  afterAll(async () => {
-    try {
-      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
-    } catch (_e) {
-      expect(true).toBe(true);
-    }
-  });
-  it('creates a temporary project (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const res = await callTool('full', 'create_project', {
-      id: PROJECT_ID,
-      name: PROJECT_NAME,
-      description: 'Ephemeral project for e2e scenario',
-    });
-    expect(res).toMatchObject({ success: true, action: 'create_project' });
-    created = true;
-  }, 60000);
-
-  it('lists and gets project (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const list = await callTool<ListResult<ProjectRef>>('dev', 'list_projects', {
-      locator: `id:${PROJECT_ID}`,
-    });
-    expect(Array.isArray(list.items)).toBe(true);
-    const foundProj = (list.items ?? []).find((p) => p.id === PROJECT_ID);
-    expect(Boolean(foundProj)).toBe(true);
-    const proj = await callTool<ProjectRef>('dev', 'get_project', { projectId: PROJECT_ID });
-    expect(proj.id).toBe(PROJECT_ID);
-  }, 60000);
-
-  it('creates a build configuration (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const res = await callTool('full', 'create_build_config', {
-      projectId: PROJECT_ID,
-      id: BT_ID,
-      name: BT_NAME,
-      description: 'Ephemeral build config',
-    });
-    expect(res).toMatchObject({ success: true, action: 'create_build_config' });
-    createdBuildType = true;
-  }, 60000);
-
-  it('lists and gets build configuration (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const list = await callTool<ListResult<BuildTypeSummary>>('dev', 'list_build_configs', {
-      projectId: PROJECT_ID,
-    });
-    expect(Array.isArray(list.items)).toBe(true);
-    const hasBt = (list.items ?? []).some((b) => b.id === BT_ID);
-    expect(hasBt).toBe(true);
-    const cfg = await callTool<BuildTypeSummary>('dev', 'get_build_config', { buildTypeId: BT_ID });
-    expect(cfg.id).toBe(BT_ID);
-  }, 60000);
-
-  it('adds a simpleRunner step (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const res = await callTool('full', 'manage_build_steps', {
-      buildTypeId: BT_ID,
-      action: 'add',
-      name: 'echo-step',
-      type: 'simpleRunner',
-      properties: { 'script.content': 'echo "hello from e2e"' },
-    });
-    expect(res).toMatchObject({ success: true, action: 'add_build_step' });
-  }, 60000);
-
-  it('triggers a build (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const res = await callTool<TriggerBuildResult>('dev', 'trigger_build', {
-      buildTypeId: BT_ID,
-      comment: 'e2e',
-    });
-    expect(res).toMatchObject({ success: true, action: 'trigger_build' } as ActionResult);
-    triggeredBuildId = res.buildId;
-    expect(typeof triggeredBuildId).toBe('string');
-  }, 60000);
-
-  it('gets build status and fetches logs (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    if (!triggeredBuildId) return expect(true).toBe(true);
-    const status = await callTool<Record<string, unknown>>('dev', 'get_build_status', {
-      buildId: triggeredBuildId,
-    });
-    expect(status).toHaveProperty('state');
-    try {
-      const log = await callTool<BuildLogChunk>('dev', 'fetch_build_log', {
-        buildId: triggeredBuildId,
-        page: 1,
-        pageSize: 200,
-      });
-      expect(log).toHaveProperty('lines');
-    } catch (e) {
-      // Non-fatal if logs are temporarily unavailable
-      expect(true).toBe(true);
-    }
-  }, 90000);
-
-  it('lists agents and compatibility (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const agents = await callTool<Record<string, unknown>>('dev', 'list_agents', { pageSize: 10 });
-    expect(agents).toHaveProperty('items');
-    if (createdBuildType) {
-      await callTool<Record<string, unknown>>('dev', 'get_compatible_agents_for_build_type', {
-        buildTypeId: BT_ID,
-      });
-      await callTool<Record<string, unknown>>('dev', 'count_compatible_agents_for_build_type', {
-        buildTypeId: BT_ID,
-      });
-    }
-  }, 60000);
-
-  it('deletes the temporary project (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    if (!created) 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/lib/mcp-runner.ts

@@ -1,59 +0,0 @@
-import { spawn } from 'child_process';
-import path from 'path';
-
-export type Mode = 'dev' | 'full';
-
-export async function listTools(mode: Mode): Promise<string[]> {
-  const res = (await runE2E(['tools', '--mode', mode])) as { tools?: string[] };
-  return res.tools ?? [];
-}
-
-export async function callTool<T = unknown>(
-  mode: Mode,
-  name: string,
-  args: Record<string, unknown> = {}
-): Promise<T> {
-  const res = (await runE2E(['call', name, JSON.stringify(args), '--mode', mode])) as {
-    res: T;
-  };
-  return res.res;
-}
-
-async function runE2E(args: string[]): Promise<unknown> {
-  const tsx = path.resolve(process.cwd(), 'node_modules/tsx/dist/cli.cjs');
-  const entry = path.resolve(process.cwd(), 'tests/e2e/index.ts');
-  const child = spawn(process.execPath, [tsx, entry, ...args], {
-    env: { ...process.env },
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  const out: Buffer[] = [];
-  const err: Buffer[] = [];
-  await new Promise<void>((resolve, reject) => {
-    child.stdout.on('data', (c) => out.push(c));
-    child.stderr.on('data', (c) => err.push(c));
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code !== 0) {
-        // eslint-disable-next-line no-console
-        console.error(Buffer.concat(err).toString('utf8'));
-        reject(new Error(`E2E CLI exited with ${code}`));
-      } else resolve();
-    });
-  });
-  const outStr = Buffer.concat(out).toString('utf8');
-  // Attempt robust parse: walk lines from bottom up and parse the first valid JSON line
-  const lines = outStr
-    .split(/\r?\n/)
-    .map((l) => l.trim())
-    .filter(Boolean);
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i] ?? '';
-    if (!line.startsWith('{') || !line.endsWith('}')) continue;
-    try {
-      return JSON.parse(line as string) as unknown;
-    } catch {
-      // continue
-    }
-  }
-  throw new Error(`Failed to parse E2E output as JSON. Output:\n${outStr}`);
-}

package/tests/integration/parameters-scenario.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-import type { ActionResult } 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_PARAM_${ts}`;
-const PROJECT_NAME = `E2E Param ${ts}`;
-const BT_ID = `E2E_PARAM_BT_${ts}`;
-const BT_NAME = `E2E Param BuildType ${ts}`;
-
-describe('Parameters lifecycle: 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,
-    });
-    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
-  }, 60000);
-
-  it('lists parameters (dev) → smoke shape', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const list = await callTool<Record<string, unknown>>('dev', 'list_parameters', {
-      buildTypeId: BT_ID,
-    });
-    expect(list).toHaveProperty('parameters');
-  }, 30000);
-
-  it('add and delete parameter (full) and smoke read (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    try {
-      const add = await callTool<ActionResult>('full', 'add_parameter', {
-        buildTypeId: BT_ID,
-        name: 'env.E2E_PARAM',
-        value: 'one',
-      });
-      expect(add).toMatchObject({ success: true, action: 'add_parameter' });
-    } catch (e) {
-      // Some servers may restrict parameter APIs; treat as non-fatal for this smoke
-      // eslint-disable-next-line no-console
-      console.warn('add_parameter failed (non-fatal):', e);
-      return expect(true).toBe(true);
-    }
-
-    await callTool<Record<string, unknown>>('dev', 'list_parameters', { buildTypeId: BT_ID });
-
-    try {
-      const del = await callTool<ActionResult>('full', 'delete_parameter', {
-        buildTypeId: BT_ID,
-        name: 'env.E2E_PARAM',
-      });
-      expect(del).toMatchObject({ success: true, action: 'delete_parameter' });
-    } catch (e) {
-      // eslint-disable-next-line no-console
-      console.warn('delete_parameter failed (non-fatal):', e);
-    }
-
-    await callTool<Record<string, unknown>>('dev', 'list_parameters', { buildTypeId: BT_ID });
-  }, 90000);
-
-  it('deletes the 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/pause-configs-scenario.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-import type { ActionResult } 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_PAUSE_${ts}`;
-const PROJECT_NAME = `E2E Pause ${ts}`;
-const BT1_ID = `E2E_PAUSE_BT1_${ts}`;
-const BT2_ID = `E2E_PAUSE_BT2_${ts}`;
-
-describe('Pause/unpause build configs (full) with dev verification', () => {
-  afterAll(async () => {
-    try {
-      await callTool('full', 'delete_project', { projectId: PROJECT_ID });
-    } catch (_e) {
-      expect(true).toBe(true);
-    }
-  });
-  it('creates project and two build configs (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const cproj = await callTool('full', 'create_project', { id: PROJECT_ID, name: PROJECT_NAME });
-    expect(cproj).toMatchObject({ success: true, action: 'create_project' });
-    const cbt1 = await callTool('full', 'create_build_config', {
-      projectId: PROJECT_ID,
-      id: BT1_ID,
-      name: 'E2E Pause BT1',
-    });
-    const cbt2 = await callTool('full', 'create_build_config', {
-      projectId: PROJECT_ID,
-      id: BT2_ID,
-      name: 'E2E Pause BT2',
-    });
-    expect(cbt1).toMatchObject({ success: true, action: 'create_build_config' });
-    expect(cbt2).toMatchObject({ success: true, action: 'create_build_config' });
-  }, 60000);
-
-  it('pauses and unpauses both (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    try {
-      const pause = await callTool<ActionResult>('full', 'set_build_configs_paused', {
-        buildTypeIds: [BT1_ID, BT2_ID],
-        paused: true,
-      });
-      expect(pause).toHaveProperty('action');
-    } catch (e) {
-      // eslint-disable-next-line no-console
-      console.warn('set_build_configs_paused (pause) failed (non-fatal):', e);
-      return expect(true).toBe(true);
-    }
-
-    try {
-      const unpause = await callTool<ActionResult>('full', 'set_build_configs_paused', {
-        buildTypeIds: [BT1_ID, BT2_ID],
-        paused: false,
-      });
-      expect(unpause).toHaveProperty('action');
-    } catch (e) {
-      // eslint-disable-next-line no-console
-      console.warn('set_build_configs_paused (unpause) failed (non-fatal):', e);
-    }
-  }, 90000);
-
-  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/queue-maintenance-scenario.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-import type { ActionResult, 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_QUEUE_${ts}`;
-const PROJECT_NAME = `E2E Queue ${ts}`;
-const BT_ID = `E2E_QUEUE_BT_${ts}`;
-const BT_NAME = `E2E Queue BuildType ${ts}`;
-
-describe('Queue maintenance (full)', () => {
-  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,
-    });
-    expect(cbt).toMatchObject({ success: true, action: 'create_build_config' });
-  }, 60000);
-
-  it('adds a simple step, triggers multiple builds to create queued work (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const step = await callTool<ActionResult>('full', 'manage_build_steps', {
-      buildTypeId: BT_ID,
-      action: 'add',
-      name: 'quick-step',
-      type: 'simpleRunner',
-      properties: { 'script.content': 'echo queue-test' },
-    });
-    expect(step).toMatchObject({ success: true, action: 'add_build_step' });
-    // Trigger a few builds — some environments may not queue if ample agents exist; tests below are tolerant
-    await callTool('dev', 'trigger_build', { buildTypeId: BT_ID, comment: 'q1' });
-    await callTool('dev', 'trigger_build', { buildTypeId: BT_ID, comment: 'q2' });
-    await callTool('dev', 'trigger_build', { buildTypeId: BT_ID, comment: 'q3' });
-    expect(true).toBe(true);
-  }, 90000);
-
-  it('reorders queued builds when available (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const queued = await callTool<ListResult<{ id?: string | number }>>(
-      'dev',
-      'list_queued_builds',
-      {
-        locator: `project:(id:${PROJECT_ID})`,
-      }
-    );
-    const ids = (queued.items ?? [])
-      .map((b) => (b.id != null ? String(b.id) : ''))
-      .filter((s) => s.length > 0);
-    if (ids.length >= 2) {
-      const desired = [ids[1], ids[0], ...ids.slice(2)];
-      try {
-        const res = await callTool('full', 'reorder_queued_builds', { buildIds: desired });
-        expect(res).toMatchObject({ success: true, action: 'reorder_queued_builds' });
-      } catch (e) {
-        // Non-fatal if server disallows
-        expect(true).toBe(true);
-      }
-    } else {
-      expect(true).toBe(true);
-    }
-  }, 60000);
-
-  it('moves a queued build to top when available (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const queued = await callTool<ListResult<{ id?: string | number }>>(
-      'dev',
-      'list_queued_builds',
-      {
-        locator: `project:(id:${PROJECT_ID})`,
-      }
-    );
-    const first = (queued.items ?? [])[0];
-    if (first?.id != null) {
-      try {
-        const res = await callTool('full', 'move_queued_build_to_top', {
-          buildId: String(first.id),
-        });
-        expect(res).toMatchObject({ success: true, action: 'move_queued_build_to_top' });
-      } catch (e) {
-        expect(true).toBe(true);
-      }
-    } else {
-      expect(true).toBe(true);
-    }
-  }, 60000);
-
-  it('cancels queued builds for build type and by locator (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    try {
-      const byBt = await callTool('full', 'cancel_queued_builds_for_build_type', {
-        buildTypeId: BT_ID,
-      });
-      expect(byBt).toHaveProperty('canceled');
-    } catch (e) {
-      expect(true).toBe(true);
-    }
-    try {
-      const byLoc = await callTool('full', 'cancel_queued_builds_by_locator', {
-        locator: `project:(id:${PROJECT_ID})`,
-      });
-      expect(byLoc).toHaveProperty('canceled');
-    } catch (e) {
-      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/server-health-scenario.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-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'])
-);
-
-describe('Server env and health checks', () => {
-  it('get_server_info and check_teamcity_connection (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const info = await callTool<Record<string, unknown>>('dev', 'get_server_info', {});
-    expect(info).toBeDefined();
-    const conn = await callTool<Record<string, unknown>>('dev', 'check_teamcity_connection', {});
-    expect(conn).toHaveProperty('ok');
-  }, 30000);
-
-  it('check_availability_guard (dev)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    const guard = await callTool<Record<string, unknown>>('dev', 'check_availability_guard', {});
-    expect(guard).toHaveProperty('ok');
-    const guardStrict = await callTool<Record<string, unknown>>('dev', 'check_availability_guard', {
-      failOnWarning: true,
-    });
-    expect(guardStrict).toHaveProperty('ok');
-  }, 30000);
-
-  it('server metrics and health items (full)', async () => {
-    if (!hasTeamCityEnv) return expect(true).toBe(true);
-    try {
-      const metrics = await callTool<Record<string, unknown>>('full', 'get_server_metrics', {});
-      expect(metrics).toBeDefined();
-    } catch (e) {
-      // Not all servers expose metrics; tolerate
-      expect(true).toBe(true);
-    }
-    try {
-      const items = await callTool<Record<string, unknown>>('full', 'list_server_health_items', {});
-      expect(items).toBeDefined();
-      const healthItems = (items as Record<string, unknown>)['healthItem'] as
-        | Array<{ href?: string }>
-        | undefined;
-      const firstHref = healthItems?.[0]?.href;
-      if (firstHref) {
-        const locator = firstHref.split('/').pop();
-        if (locator) {
-          const item = await callTool<Record<string, unknown>>('full', 'get_server_health_item', {
-            locator,
-          });
-          expect(item).toBeDefined();
-        }
-      }
-    } catch (e) {
-      // Health items may require permissions; tolerate
-      expect(true).toBe(true);
-    }
-  }, 60000);
-});