azure_list_virtual_machines

Instructions

Implementation Reference

• src/tools/azure-tools.ts:5-22 (schema)

  Tool definition with name, description, and input schema for azure_list_virtual_machines

  {
    name: 'azure_list_virtual_machines',
    description: 'List all Virtual Machines in Azure',
    inputSchema: {
      type: 'object',
      properties: {
        subscriptionId: {
          type: 'string',
          description: 'Azure subscription ID',
        },
        location: {
          type: 'string',
          description: 'Azure location/region',
          default: 'eastus',
        },
      },
    },
  },

• src/tools/azure-tools.ts:50-66 (handler)

  Tool handler switch case: initializes AzureAdapter, calls listVirtualMachines, maps and returns VM list with total count

  case 'azure_list_virtual_machines': {
    const vms = await adapter.listVirtualMachines();
    return {
      total: vms.length,
      virtualMachines: vms.map((vm) => ({
        id: vm.id,
        name: vm.name,
        resourceGroup: vm.resourceGroup,
        location: vm.location,
        vmSize: vm.vmSize,
        osType: vm.osType,
        status: vm.status,
        privateIp: vm.privateIp,
        publicIp: vm.publicIp,
      })),
    };
  }

• src/adapters/azure-adapter.ts:76-123 (handler)

  Core implementation: initializes clients, lists resource groups, fetches VMs per group with status and details using Azure ComputeManagementClient

  async listVirtualMachines(): Promise<AzureVM[]> {
    await this.initializeClients();
    if (!this.computeClient) throw new Error('Compute client not initialized');
  
    try {
      const vms: AzureVM[] = [];
      const resourceGroups = await this.listResourceGroups();
  
      for (const rg of resourceGroups) {
        const vmList = this.computeClient.virtualMachines.list(rg);
        for await (const vm of vmList) {
          if (vm.id && vm.name) {
            // Get VM status
            const instanceView = await this.computeClient.virtualMachines.instanceView(rg, vm.name);
            const status = this.mapVMStatus(instanceView.statuses);
  
            // Get network info
            const networkInterfaces = vm.networkProfile?.networkInterfaces || [];
            let privateIp: string | undefined;
            let publicIp: string | undefined;
  
            if (networkInterfaces.length > 0 && this.resourceClient) {
              // Simplified - would need to fetch actual IPs from network interfaces
            }
  
            vms.push({
              id: vm.id,
              type: 'instance',
              name: vm.name,
              resourceGroup: rg,
              location: vm.location || this.location,
              status,
              vmSize: vm.hardwareProfile?.vmSize || '',
              osType: vm.storageProfile?.osDisk?.osType || 'Unknown',
              privateIp,
              publicIp,
              provisioningState: vm.provisioningState,
              tags: vm.tags,
            });
          }
        }
      }
  
      return vms;
    } catch (error) {
      throw new Error(`Failed to list VMs: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/server.ts:19-27 (registration)

  Registers azure_list_virtual_machines by including azureTools in the allTools list provided to MCP listTools handler

  const allTools = [
    ...awsTools,
    ...azureTools,
    ...gcpTools,
    ...resourceManagementTools,
    ...costAnalysisTools,
    ...monitoringTools,
    ...securityTools,
  ];

• src/server.ts:66-67 (registration)

  Routes calls to azure_list_virtual_machines to the handleAzureTool function in MCP callTool handler

  } else if (azureTools.some((t) => t.name === name)) {
    result = await handleAzureTool(name, args || {});