MCP Cloud Services Server

Instructions

Implementation Reference

• src/adapters/gcp-adapter.ts:57-97 (handler)

  Core handler implementation that lists GCP Compute Engine instances by fetching zones, listing VMs per zone, and extracting detailed instance information including IPs, status, machine type, etc.

  async listComputeInstances(): Promise<GCPComputeInstance[]> {
    await this.initializeClients();
    if (!this.compute) throw new Error('Compute client not initialized');
  
    try {
      const instances: GCPComputeInstance[] = [];
      const [zones] = await this.compute.getZones();
  
      for (const zone of zones) {
        const zoneName = zone.name || '';
        const vm = this.compute.zone(zoneName);
        const [vms] = await vm.getVMs();
  
        for (const instance of vms) {
          const networkInterfaces = instance.networkInterfaces || [];
          const privateIp = networkInterfaces[0]?.networkIP;
          const publicIp = networkInterfaces[0]?.accessConfigs?.[0]?.natIP;
  
          instances.push({
            id: instance.id?.toString() || instance.name || '',
            type: 'instance',
            name: instance.name || '',
            projectId: this.projectId,
            zone: zoneName,
            region: this.extractRegion(zoneName),
            status: this.mapInstanceStatus(instance.status),
            machineType: this.extractMachineType(instance.machineType || ''),
            image: this.extractImage(instance.disks?.[0]?.initializeParams?.sourceImage || ''),
            privateIp,
            publicIp,
            creationTimestamp: instance.creationTimestamp ? new Date(instance.creationTimestamp) : undefined,
            labels: instance.labels,
          });
        }
      }
  
      return instances;
    } catch (error) {
      throw new Error(`Failed to list compute instances: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/tools/gcp-tools.ts:68-83 (handler)

  Tool handler case within handleGCPTool function that invokes the GCPAdapter's listComputeInstances and formats the output for the MCP response.

  case 'gcp_list_compute_instances': {
    const instances = await adapter.listComputeInstances();
    return {
      total: instances.length,
      instances: instances.map((inst) => ({
        id: inst.id,
        name: inst.name,
        machineType: inst.machineType,
        zone: inst.zone,
        region: inst.region,
        status: inst.status,
        privateIp: inst.privateIp,
        publicIp: inst.publicIp,
      })),
    };
  }

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

  Input schema and metadata definition for the gcp_list_compute_instances tool, specifying parameters for projectId and optional region.

  {
    name: 'gcp_list_compute_instances',
    description: 'List all Compute Engine instances in GCP',
    inputSchema: {
      type: 'object',
      properties: {
        projectId: {
          type: 'string',
          description: 'GCP project ID',
        },
        region: {
          type: 'string',
          description: 'GCP region',
          default: 'us-central1',
        },
      },
    },
  },

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

  Registration of all tools including gcpTools (which contains gcp_list_compute_instances) into the MCP server's tool list.

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

• src/server.ts:68-69 (registration)

  Dispatch registration in the MCP server's CallToolRequest handler that routes calls to gcp_list_compute_instances to the specific GCP handler.

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