@cablate/mcp-google-map 0.0.1 → 0.0.3

package/README.md

@@ -6,9 +6,24 @@ A powerful Model Context Protocol (MCP) server providing comprehensive Google Ma
 
 ### Google Maps Features
 
-- Location search and information retrieval
-- Geocoding and reverse geocoding
-- Detailed place information
+- **Location Search**
+
+  - Search for places near a specific location with customizable radius and filters
+  - Get detailed place information including ratings, opening hours, and contact details
+
+- **Geocoding Services**
+
+  - Convert addresses to coordinates (geocoding)
+  - Convert coordinates to addresses (reverse geocoding)
+
+- **Distance & Directions**
+
+  - Calculate distances and travel times between multiple origins and destinations
+  - Get detailed directions between two points with step-by-step instructions
+  - Support for different travel modes (driving, walking, bicycling, transit)
+
+- **Elevation Data**
+  - Retrieve elevation data for specific locations
 
 ## Installation
 
@@ -48,6 +63,18 @@ mcp-google-map
 
 3. Click "Save" to complete the installation
 
+## Available Tools
+
+The server provides the following tools:
+
+1. **search_nearby** - Search for places near a specific location
+2. **get_place_details** - Get detailed information about a specific place
+3. **maps_geocode** - Convert an address to coordinates
+4. **maps_reverse_geocode** - Convert coordinates to an address
+5. **maps_distance_matrix** - Calculate distances and times between multiple origins and destinations
+6. **maps_directions** - Get directions between two points
+7. **maps_elevation** - Get elevation data for specific locations
+
 ## Google Maps API Setup
 
 To use this service, you need to:

package/dist/index.cjs

@@ -17127,13 +17127,13 @@ var require_common = __commonJS({
       Language3["zh_CN"] = "zh-CN";
       Language3["zh_TW"] = "zh-TW";
     })(Language2 || (exports2.Language = Language2 = {}));
-    var TravelMode;
-    (function(TravelMode2) {
-      TravelMode2["driving"] = "driving";
-      TravelMode2["walking"] = "walking";
-      TravelMode2["bicycling"] = "bicycling";
-      TravelMode2["transit"] = "transit";
-    })(TravelMode || (exports2.TravelMode = TravelMode = {}));
+    var TravelMode2;
+    (function(TravelMode3) {
+      TravelMode3["driving"] = "driving";
+      TravelMode3["walking"] = "walking";
+      TravelMode3["bicycling"] = "bicycling";
+      TravelMode3["transit"] = "transit";
+    })(TravelMode2 || (exports2.TravelMode = TravelMode2 = {}));
     var TravelRestriction;
     (function(TravelRestriction2) {
       TravelRestriction2["tolls"] = "tolls";
@@ -23407,6 +23407,129 @@ var SEARCH_NEARBY_TOOL = {
     required: ["center"]
   }
 };
+var GEOCODE_TOOL = {
+  name: "maps_geocode",
+  description: "\u5C07\u5730\u5740\u8F49\u63DB\u70BA\u5EA7\u6A19",
+  inputSchema: {
+    type: "object",
+    properties: {
+      address: {
+        type: "string",
+        description: "\u8981\u8F49\u63DB\u7684\u5730\u5740\u6216\u5730\u6A19\u540D\u7A31"
+      }
+    },
+    required: ["address"]
+  }
+};
+var REVERSE_GEOCODE_TOOL = {
+  name: "maps_reverse_geocode",
+  description: "\u5C07\u5EA7\u6A19\u8F49\u63DB\u70BA\u5730\u5740",
+  inputSchema: {
+    type: "object",
+    properties: {
+      latitude: {
+        type: "number",
+        description: "\u7DEF\u5EA6"
+      },
+      longitude: {
+        type: "number",
+        description: "\u7D93\u5EA6"
+      }
+    },
+    required: ["latitude", "longitude"]
+  }
+};
+var DISTANCE_MATRIX_TOOL = {
+  name: "maps_distance_matrix",
+  description: "\u8A08\u7B97\u591A\u500B\u8D77\u9EDE\u548C\u7D42\u9EDE\u4E4B\u9593\u7684\u8DDD\u96E2\u548C\u6642\u9593",
+  inputSchema: {
+    type: "object",
+    properties: {
+      origins: {
+        type: "array",
+        items: {
+          type: "string"
+        },
+        description: "\u8D77\u9EDE\u5730\u5740\u6216\u5EA7\u6A19\u5217\u8868"
+      },
+      destinations: {
+        type: "array",
+        items: {
+          type: "string"
+        },
+        description: "\u7D42\u9EDE\u5730\u5740\u6216\u5EA7\u6A19\u5217\u8868"
+      },
+      mode: {
+        type: "string",
+        enum: ["driving", "walking", "bicycling", "transit"],
+        description: "\u4EA4\u901A\u6A21\u5F0F",
+        default: "driving"
+      }
+    },
+    required: ["origins", "destinations"]
+  }
+};
+var DIRECTIONS_TOOL = {
+  name: "maps_directions",
+  description: "\u7372\u53D6\u5169\u9EDE\u4E4B\u9593\u7684\u8A73\u7D30\u5C0E\u822A\u8DEF\u7DDA",
+  inputSchema: {
+    type: "object",
+    properties: {
+      origin: {
+        type: "string",
+        description: "\u8D77\u9EDE\u5730\u5740\u6216\u5EA7\u6A19"
+      },
+      destination: {
+        type: "string",
+        description: "\u7D42\u9EDE\u5730\u5740\u6216\u5EA7\u6A19"
+      },
+      mode: {
+        type: "string",
+        enum: ["driving", "walking", "bicycling", "transit"],
+        description: "\u4EA4\u901A\u6A21\u5F0F",
+        default: "driving"
+      },
+      departure_time: {
+        type: "string",
+        description: "\u51FA\u767C\u6642\u9593",
+        default: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      arrival_time: {
+        type: "string",
+        description: "\u62B5\u9054\u6642\u9593"
+      }
+    },
+    required: ["origin", "destination"]
+  }
+};
+var ELEVATION_TOOL = {
+  name: "maps_elevation",
+  description: "\u7372\u53D6\u4F4D\u7F6E\u7684\u6D77\u62D4\u6578\u64DA",
+  inputSchema: {
+    type: "object",
+    properties: {
+      locations: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            latitude: {
+              type: "number",
+              description: "\u7DEF\u5EA6"
+            },
+            longitude: {
+              type: "number",
+              description: "\u7D93\u5EA6"
+            }
+          },
+          required: ["latitude", "longitude"]
+        },
+        description: "\u8981\u7372\u53D6\u6D77\u62D4\u6578\u64DA\u7684\u4F4D\u7F6E\u5217\u8868"
+      }
+    },
+    required: ["locations"]
+  }
+};
 var GET_PLACE_DETAILS_TOOL = {
   name: "get_place_details",
   description: "\u7372\u53D6\u7279\u5B9A\u5730\u9EDE\u7684\u8A73\u7D30\u8CC7\u8A0A",
@@ -23485,10 +23608,13 @@ var GoogleMapsTools = class {
       if (response.data.results.length === 0) {
         throw new Error("\u627E\u4E0D\u5230\u8A72\u5730\u5740\u7684\u4F4D\u7F6E");
       }
-      const location = response.data.results[0].geometry.location;
+      const result = response.data.results[0];
+      const location = result.geometry.location;
       return {
         lat: location.lat,
-        lng: location.lng
+        lng: location.lng,
+        formatted_address: result.formatted_address,
+        place_id: result.place_id
       };
     } catch (error) {
       console.error("Error in geocodeAddress:", error);
@@ -23508,6 +23634,190 @@ var GoogleMapsTools = class {
     }
     return this.geocodeAddress(center.value);
   }
+  // 新增公開方法用於地址轉座標
+  async geocode(address) {
+    try {
+      const result = await this.geocodeAddress(address);
+      return {
+        location: { lat: result.lat, lng: result.lng },
+        formatted_address: result.formatted_address || "",
+        place_id: result.place_id || ""
+      };
+    } catch (error) {
+      console.error("Error in geocode:", error);
+      throw new Error("\u5730\u5740\u8F49\u63DB\u5EA7\u6A19\u6642\u767C\u751F\u932F\u8AA4");
+    }
+  }
+  async reverseGeocode(latitude, longitude) {
+    try {
+      const response = await this.client.reverseGeocode({
+        params: {
+          latlng: { lat: latitude, lng: longitude },
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || ""
+        }
+      });
+      if (response.data.results.length === 0) {
+        throw new Error("\u627E\u4E0D\u5230\u8A72\u5EA7\u6A19\u7684\u5730\u5740");
+      }
+      const result = response.data.results[0];
+      return {
+        formatted_address: result.formatted_address,
+        place_id: result.place_id,
+        address_components: result.address_components
+      };
+    } catch (error) {
+      console.error("Error in reverseGeocode:", error);
+      throw new Error("\u5EA7\u6A19\u8F49\u63DB\u5730\u5740\u6642\u767C\u751F\u932F\u8AA4");
+    }
+  }
+  async calculateDistanceMatrix(origins, destinations, mode = "driving") {
+    try {
+      const response = await this.client.distancematrix({
+        params: {
+          origins,
+          destinations,
+          mode,
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || ""
+        }
+      });
+      const result = response.data;
+      if (result.status !== "OK") {
+        throw new Error(`\u8DDD\u96E2\u77E9\u9663\u8A08\u7B97\u5931\u6557: ${result.status}`);
+      }
+      const distances = [];
+      const durations = [];
+      result.rows.forEach((row) => {
+        const distanceRow = [];
+        const durationRow = [];
+        row.elements.forEach((element) => {
+          if (element.status === "OK") {
+            distanceRow.push({
+              value: element.distance.value,
+              text: element.distance.text
+            });
+            durationRow.push({
+              value: element.duration.value,
+              text: element.duration.text
+            });
+          } else {
+            distanceRow.push(null);
+            durationRow.push(null);
+          }
+        });
+        distances.push(distanceRow);
+        durations.push(durationRow);
+      });
+      return {
+        distances,
+        durations,
+        origin_addresses: result.origin_addresses,
+        destination_addresses: result.destination_addresses
+      };
+    } catch (error) {
+      console.error("Error in calculateDistanceMatrix:", error);
+      throw new Error("\u8A08\u7B97\u8DDD\u96E2\u77E9\u9663\u6642\u767C\u751F\u932F\u8AA4");
+    }
+  }
+  async getDirections(origin, destination, mode = "driving", departure_time, arrival_time) {
+    try {
+      let apiArrivalTime = void 0;
+      if (arrival_time) {
+        apiArrivalTime = Math.floor(arrival_time.getTime() / 1e3);
+      }
+      let apiDepartureTime = void 0;
+      if (!apiArrivalTime) {
+        if (departure_time instanceof Date) {
+          apiDepartureTime = Math.floor(departure_time.getTime() / 1e3);
+        } else if (departure_time) {
+          apiDepartureTime = departure_time;
+        } else {
+          apiDepartureTime = "now";
+        }
+      }
+      const response = await this.client.directions({
+        params: {
+          origin,
+          destination,
+          mode,
+          language: this.defaultLanguage,
+          key: process.env.GOOGLE_MAPS_API_KEY || "",
+          arrival_time: apiArrivalTime,
+          departure_time: apiDepartureTime
+        }
+      });
+      const result = response.data;
+      if (result.status !== "OK") {
+        throw new Error(`\u8DEF\u7DDA\u6307\u5F15\u7372\u53D6\u5931\u6557: ${result.status} (arrival_time: ${apiArrivalTime}, departure_time: ${apiDepartureTime})`);
+      }
+      if (result.routes.length === 0) {
+        throw new Error("\u627E\u4E0D\u5230\u8DEF\u7DDA");
+      }
+      const route = result.routes[0];
+      const legs = route.legs[0];
+      const formatTime = (timeInfo) => {
+        if (!timeInfo || typeof timeInfo.value !== "number") return "";
+        const date = new Date(timeInfo.value * 1e3);
+        const options = {
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit",
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit",
+          hour12: false
+          // Use 24-hour format
+        };
+        if (timeInfo.time_zone && typeof timeInfo.time_zone === "string") {
+          options.timeZone = timeInfo.time_zone;
+        }
+        return date.toLocaleString(this.defaultLanguage.toString(), options);
+      };
+      return {
+        routes: result.routes,
+        summary: route.summary,
+        total_distance: {
+          value: legs.distance.value,
+          text: legs.distance.text
+        },
+        total_duration: {
+          value: legs.duration.value,
+          text: legs.duration.text
+        },
+        arrival_time: formatTime(legs.arrival_time),
+        departure_time: formatTime(legs.departure_time)
+      };
+    } catch (error) {
+      console.error("Error in getDirections:", error);
+      throw new Error("\u7372\u53D6\u8DEF\u7DDA\u6307\u5F15\u6642\u767C\u751F\u932F\u8AA4" + error);
+    }
+  }
+  async getElevation(locations) {
+    try {
+      const formattedLocations = locations.map((loc) => ({
+        lat: loc.latitude,
+        lng: loc.longitude
+      }));
+      const response = await this.client.elevation({
+        params: {
+          locations: formattedLocations,
+          key: process.env.GOOGLE_MAPS_API_KEY || ""
+        }
+      });
+      const result = response.data;
+      if (result.status !== "OK") {
+        throw new Error(`\u6D77\u62D4\u6578\u64DA\u7372\u53D6\u5931\u6557: ${result.status}`);
+      }
+      return result.results.map((item, index) => ({
+        elevation: item.elevation,
+        location: formattedLocations[index]
+      }));
+    } catch (error) {
+      console.error("Error in getElevation:", error);
+      throw new Error("\u7372\u53D6\u6D77\u62D4\u6578\u64DA\u6642\u767C\u751F\u932F\u8AA4");
+    }
+  }
 };
 
 // src/maps-tools/searchPlaces.ts
@@ -23576,10 +23886,82 @@ var PlacesSearcher = class {
       };
     }
   }
+  async geocode(address) {
+    try {
+      const result = await this.mapsTools.geocode(address);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "\u5730\u5740\u8F49\u63DB\u5EA7\u6A19\u6642\u767C\u751F\u932F\u8AA4"
+      };
+    }
+  }
+  async reverseGeocode(latitude, longitude) {
+    try {
+      const result = await this.mapsTools.reverseGeocode(latitude, longitude);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "\u5EA7\u6A19\u8F49\u63DB\u5730\u5740\u6642\u767C\u751F\u932F\u8AA4"
+      };
+    }
+  }
+  async calculateDistanceMatrix(origins, destinations, mode = "driving") {
+    try {
+      const result = await this.mapsTools.calculateDistanceMatrix(origins, destinations, mode);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "\u8A08\u7B97\u8DDD\u96E2\u77E9\u9663\u6642\u767C\u751F\u932F\u8AA4"
+      };
+    }
+  }
+  async getDirections(origin, destination, mode = "driving", departure_time, arrival_time) {
+    try {
+      const departureTime = departure_time ? new Date(departure_time) : /* @__PURE__ */ new Date();
+      const arrivalTime = arrival_time ? new Date(arrival_time) : void 0;
+      const result = await this.mapsTools.getDirections(origin, destination, mode, departureTime, arrivalTime);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "\u7372\u53D6\u8DEF\u7DDA\u6307\u5F15\u6642\u767C\u751F\u932F\u8AA4"
+      };
+    }
+  }
+  async getElevation(locations) {
+    try {
+      const result = await this.mapsTools.getElevation(locations);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "\u7372\u53D6\u6D77\u62D4\u6578\u64DA\u6642\u767C\u751F\u932F\u8AA4"
+      };
+    }
+  }
 };
 
 // src/index.ts
-var tools = [SEARCH_NEARBY_TOOL, GET_PLACE_DETAILS_TOOL];
+var tools = [SEARCH_NEARBY_TOOL, GET_PLACE_DETAILS_TOOL, GEOCODE_TOOL, REVERSE_GEOCODE_TOOL, DISTANCE_MATRIX_TOOL, DIRECTIONS_TOOL, ELEVATION_TOOL];
 var placesSearcher = new PlacesSearcher();
 var server = new Server(
   {
@@ -23647,6 +24029,101 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         isError: false
       };
     }
+    if (name === "maps_geocode") {
+      const { address } = args;
+      const result = await placesSearcher.geocode(address);
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "\u5730\u5740\u8F49\u63DB\u5EA7\u6A19\u5931\u6557" }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ],
+        isError: false
+      };
+    }
+    if (name === "maps_reverse_geocode") {
+      const { latitude, longitude } = args;
+      const result = await placesSearcher.reverseGeocode(latitude, longitude);
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "\u5EA7\u6A19\u8F49\u63DB\u5730\u5740\u5931\u6557" }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ],
+        isError: false
+      };
+    }
+    if (name === "maps_distance_matrix") {
+      const { origins, destinations, mode } = args;
+      const result = await placesSearcher.calculateDistanceMatrix(origins, destinations, mode || "driving");
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "\u8A08\u7B97\u8DDD\u96E2\u77E9\u9663\u5931\u6557" }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ],
+        isError: false
+      };
+    }
+    if (name === "maps_directions") {
+      const { origin, destination, mode, arrival_time, departure_time } = args;
+      const result = await placesSearcher.getDirections(origin, destination, mode, departure_time, arrival_time);
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "\u7372\u53D6\u8DEF\u7DDA\u6307\u5F15\u5931\u6557" }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ],
+        isError: false
+      };
+    }
+    if (name === "maps_elevation") {
+      const { locations } = args;
+      const result = await placesSearcher.getElevation(locations);
+      if (!result.success) {
+        return {
+          content: [{ type: "text", text: result.error || "\u7372\u53D6\u6D77\u62D4\u6578\u64DA\u5931\u6557" }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result.data, null, 2)
+          }
+        ],
+        isError: false
+      };
+    }
     return {
       content: [{ type: "text", text: `\u932F\u8AA4\uFF1A\u672A\u77E5\u7684\u5DE5\u5177 ${name}` }],
       isError: true

package/dist/index.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { DIRECTIONS_TOOL, DISTANCE_MATRIX_TOOL, ELEVATION_TOOL, GEOCODE_TOOL, GET_PLACE_DETAILS_TOOL, REVERSE_GEOCODE_TOOL, SEARCH_NEARBY_TOOL } from "./maps-tools/mapsTools.js";
+import { PlacesSearcher } from "./maps-tools/searchPlaces.js";
+const tools = [SEARCH_NEARBY_TOOL, GET_PLACE_DETAILS_TOOL, GEOCODE_TOOL, REVERSE_GEOCODE_TOOL, DISTANCE_MATRIX_TOOL, DIRECTIONS_TOOL, ELEVATION_TOOL];
+const placesSearcher = new PlacesSearcher();
+const server = new Server({
+    name: "mcp-server/maps_executor",
+    version: "0.0.1",
+}, {
+    capabilities: {
+        description: "An MCP server providing Google Maps integration!",
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args } = request.params;
+        if (!args) {
+            throw new Error("No parameters provided");
+        }
+        if (name === "search_nearby") {
+            const { center, keyword, radius, openNow, minRating } = args;
+            const result = await placesSearcher.searchNearby({
+                center,
+                keyword,
+                radius,
+                openNow,
+                minRating,
+            });
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "搜尋失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `location: ${JSON.stringify(result.location, null, 2)}\n` + JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "get_place_details") {
+            const { placeId } = args;
+            const result = await placesSearcher.getPlaceDetails(placeId);
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "獲取詳細資訊失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "maps_geocode") {
+            const { address } = args;
+            const result = await placesSearcher.geocode(address);
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "地址轉換座標失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "maps_reverse_geocode") {
+            const { latitude, longitude } = args;
+            const result = await placesSearcher.reverseGeocode(latitude, longitude);
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "座標轉換地址失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "maps_distance_matrix") {
+            const { origins, destinations, mode } = args;
+            const result = await placesSearcher.calculateDistanceMatrix(origins, destinations, mode || "driving");
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "計算距離矩陣失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "maps_directions") {
+            const { origin, destination, mode } = args;
+            const result = await placesSearcher.getDirections(origin, destination, mode || "driving");
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "獲取路線指引失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        if (name === "maps_elevation") {
+            const { locations } = args;
+            const result = await placesSearcher.getElevation(locations);
+            if (!result.success) {
+                return {
+                    content: [{ type: "text", text: result.error || "獲取海拔數據失敗" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result.data, null, 2),
+                    },
+                ],
+                isError: false,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `錯誤：未知的工具 ${name}` }],
+            isError: true,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `錯誤：${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function runServer() {
+    try {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.log("MCP Maps Server started");
+    }
+    catch (error) {
+        console.error("Server startup failed:", error);
+        process.exit(1);
+    }
+}
+runServer().catch((error) => {
+    console.error("Server encountered a critical error:", error);
+    process.exit(1);
+});

package/dist/maps-tools/mapsTools.js

@@ -0,0 +1,167 @@
+export const SEARCH_NEARBY_TOOL = {
+    name: "search_nearby",
+    description: "搜尋附近的地點",
+    inputSchema: {
+        type: "object",
+        properties: {
+            center: {
+                type: "object",
+                properties: {
+                    value: { type: "string", description: "地址、地標名稱或經緯度座標(經緯度座標格式: lat,lng)" },
+                    isCoordinates: { type: "boolean", description: "是否為經緯度座標", default: false },
+                },
+                required: ["value"],
+                description: "搜尋中心點",
+            },
+            keyword: {
+                type: "string",
+                description: "搜尋關鍵字（例如：餐廳、咖啡廳）",
+            },
+            radius: {
+                type: "number",
+                description: "搜尋半徑（公尺）",
+                default: 1000,
+            },
+            openNow: {
+                type: "boolean",
+                description: "是否只顯示營業中的地點",
+                default: false,
+            },
+            minRating: {
+                type: "number",
+                description: "最低評分要求（0-5）",
+                minimum: 0,
+                maximum: 5,
+            },
+        },
+        required: ["center"],
+    },
+};
+export const GEOCODE_TOOL = {
+    name: "maps_geocode",
+    description: "將地址轉換為座標",
+    inputSchema: {
+        type: "object",
+        properties: {
+            address: {
+                type: "string",
+                description: "要轉換的地址或地標名稱",
+            },
+        },
+        required: ["address"],
+    },
+};
+export const REVERSE_GEOCODE_TOOL = {
+    name: "maps_reverse_geocode",
+    description: "將座標轉換為地址",
+    inputSchema: {
+        type: "object",
+        properties: {
+            latitude: {
+                type: "number",
+                description: "緯度",
+            },
+            longitude: {
+                type: "number",
+                description: "經度",
+            },
+        },
+        required: ["latitude", "longitude"],
+    },
+};
+export const DISTANCE_MATRIX_TOOL = {
+    name: "maps_distance_matrix",
+    description: "計算多個起點和終點之間的距離和時間",
+    inputSchema: {
+        type: "object",
+        properties: {
+            origins: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "起點地址或座標列表",
+            },
+            destinations: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "終點地址或座標列表",
+            },
+            mode: {
+                type: "string",
+                enum: ["driving", "walking", "bicycling", "transit"],
+                description: "交通模式",
+                default: "driving",
+            },
+        },
+        required: ["origins", "destinations"],
+    },
+};
+export const DIRECTIONS_TOOL = {
+    name: "maps_directions",
+    description: "獲取兩點之間的路線指引",
+    inputSchema: {
+        type: "object",
+        properties: {
+            origin: {
+                type: "string",
+                description: "起點地址或座標",
+            },
+            destination: {
+                type: "string",
+                description: "終點地址或座標",
+            },
+            mode: {
+                type: "string",
+                enum: ["driving", "walking", "bicycling", "transit"],
+                description: "交通模式",
+                default: "driving",
+            },
+        },
+        required: ["origin", "destination"],
+    },
+};
+export const ELEVATION_TOOL = {
+    name: "maps_elevation",
+    description: "獲取位置的海拔數據",
+    inputSchema: {
+        type: "object",
+        properties: {
+            locations: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        latitude: {
+                            type: "number",
+                            description: "緯度",
+                        },
+                        longitude: {
+                            type: "number",
+                            description: "經度",
+                        },
+                    },
+                    required: ["latitude", "longitude"],
+                },
+                description: "要獲取海拔數據的位置列表",
+            },
+        },
+        required: ["locations"],
+    },
+};
+export const GET_PLACE_DETAILS_TOOL = {
+    name: "get_place_details",
+    description: "獲取特定地點的詳細資訊",
+    inputSchema: {
+        type: "object",
+        properties: {
+            placeId: {
+                type: "string",
+                description: "Google Maps 地點 ID",
+            },
+        },
+        required: ["placeId"],
+    },
+};

package/dist/maps-tools/searchPlaces.js

@@ -0,0 +1,144 @@
+import { GoogleMapsTools } from "./toolclass.js";
+export class PlacesSearcher {
+    constructor() {
+        this.mapsTools = new GoogleMapsTools();
+    }
+    async searchNearby(params) {
+        try {
+            const location = await this.mapsTools.getLocation(params.center);
+            console.error(location);
+            const places = await this.mapsTools.searchNearbyPlaces({
+                location,
+                keyword: params.keyword,
+                radius: params.radius,
+                openNow: params.openNow,
+                minRating: params.minRating,
+            });
+            return {
+                location: location,
+                success: true,
+                data: places.map((place) => ({
+                    name: place.name,
+                    place_id: place.place_id,
+                    address: place.formatted_address,
+                    location: place.geometry.location,
+                    rating: place.rating,
+                    total_ratings: place.user_ratings_total,
+                    open_now: place.opening_hours?.open_now,
+                })),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "搜尋時發生錯誤",
+            };
+        }
+    }
+    async getPlaceDetails(placeId) {
+        try {
+            const details = await this.mapsTools.getPlaceDetails(placeId);
+            return {
+                success: true,
+                data: {
+                    name: details.name,
+                    address: details.formatted_address,
+                    location: details.geometry?.location,
+                    rating: details.rating,
+                    total_ratings: details.user_ratings_total,
+                    open_now: details.opening_hours?.open_now,
+                    phone: details.formatted_phone_number,
+                    website: details.website,
+                    price_level: details.price_level,
+                    reviews: details.reviews?.map((review) => ({
+                        rating: review.rating,
+                        text: review.text,
+                        time: review.time,
+                        author_name: review.author_name,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "獲取詳細資訊時發生錯誤",
+            };
+        }
+    }
+    async geocode(address) {
+        try {
+            const result = await this.mapsTools.geocode(address);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "地址轉換座標時發生錯誤",
+            };
+        }
+    }
+    async reverseGeocode(latitude, longitude) {
+        try {
+            const result = await this.mapsTools.reverseGeocode(latitude, longitude);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "座標轉換地址時發生錯誤",
+            };
+        }
+    }
+    async calculateDistanceMatrix(origins, destinations, mode = "driving") {
+        try {
+            const result = await this.mapsTools.calculateDistanceMatrix(origins, destinations, mode);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "計算距離矩陣時發生錯誤",
+            };
+        }
+    }
+    async getDirections(origin, destination, mode = "driving") {
+        try {
+            const result = await this.mapsTools.getDirections(origin, destination, mode);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "獲取路線指引時發生錯誤",
+            };
+        }
+    }
+    async getElevation(locations) {
+        try {
+            const result = await this.mapsTools.getElevation(locations);
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "獲取海拔數據時發生錯誤",
+            };
+        }
+    }
+}

package/dist/maps-tools/toolclass.js

@@ -0,0 +1,248 @@
+import { Client, Language } from "@googlemaps/google-maps-services-js";
+import dotenv from "dotenv";
+// 確保環境變數被載入
+dotenv.config();
+export class GoogleMapsTools {
+    constructor() {
+        this.defaultLanguage = Language.zh_TW;
+        this.client = new Client({});
+        if (!process.env.GOOGLE_MAPS_API_KEY) {
+            throw new Error("Google Maps API Key is required");
+        }
+    }
+    async searchNearbyPlaces(params) {
+        const searchParams = {
+            location: params.location,
+            radius: params.radius || 1000,
+            keyword: params.keyword,
+            opennow: params.openNow,
+            language: this.defaultLanguage,
+            key: process.env.GOOGLE_MAPS_API_KEY || "",
+        };
+        try {
+            const response = await this.client.placesNearby({
+                params: searchParams,
+            });
+            let results = response.data.results;
+            // 如果有最低評分要求，進行過濾
+            if (params.minRating) {
+                results = results.filter((place) => (place.rating || 0) >= (params.minRating || 0));
+            }
+            return results;
+        }
+        catch (error) {
+            console.error("Error in searchNearbyPlaces:", error);
+            throw new Error("搜尋附近地點時發生錯誤");
+        }
+    }
+    async getPlaceDetails(placeId) {
+        try {
+            const response = await this.client.placeDetails({
+                params: {
+                    place_id: placeId,
+                    fields: ["name", "rating", "formatted_address", "opening_hours", "reviews", "geometry", "formatted_phone_number", "website", "price_level", "photos"],
+                    language: this.defaultLanguage,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                },
+            });
+            return response.data.result;
+        }
+        catch (error) {
+            console.error("Error in getPlaceDetails:", error);
+            throw new Error("獲取地點詳細資訊時發生錯誤");
+        }
+    }
+    async geocodeAddress(address) {
+        try {
+            const response = await this.client.geocode({
+                params: {
+                    address: address,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                    language: this.defaultLanguage,
+                },
+            });
+            if (response.data.results.length === 0) {
+                throw new Error("找不到該地址的位置");
+            }
+            const result = response.data.results[0];
+            const location = result.geometry.location;
+            return {
+                lat: location.lat,
+                lng: location.lng,
+                formatted_address: result.formatted_address,
+                place_id: result.place_id,
+            };
+        }
+        catch (error) {
+            console.error("Error in geocodeAddress:", error);
+            throw new Error("地址轉換座標時發生錯誤");
+        }
+    }
+    parseCoordinates(coordString) {
+        const coords = coordString.split(",").map((c) => parseFloat(c.trim()));
+        if (coords.length !== 2 || isNaN(coords[0]) || isNaN(coords[1])) {
+            throw new Error("無效的座標格式，請使用「緯度,經度」格式");
+        }
+        return { lat: coords[0], lng: coords[1] };
+    }
+    async getLocation(center) {
+        if (center.isCoordinates) {
+            return this.parseCoordinates(center.value);
+        }
+        return this.geocodeAddress(center.value);
+    }
+    // 新增公開方法用於地址轉座標
+    async geocode(address) {
+        try {
+            const result = await this.geocodeAddress(address);
+            return {
+                location: { lat: result.lat, lng: result.lng },
+                formatted_address: result.formatted_address || "",
+                place_id: result.place_id || "",
+            };
+        }
+        catch (error) {
+            console.error("Error in geocode:", error);
+            throw new Error("地址轉換座標時發生錯誤");
+        }
+    }
+    async reverseGeocode(latitude, longitude) {
+        try {
+            const response = await this.client.reverseGeocode({
+                params: {
+                    latlng: { lat: latitude, lng: longitude },
+                    language: this.defaultLanguage,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                },
+            });
+            if (response.data.results.length === 0) {
+                throw new Error("找不到該座標的地址");
+            }
+            const result = response.data.results[0];
+            return {
+                formatted_address: result.formatted_address,
+                place_id: result.place_id,
+                address_components: result.address_components,
+            };
+        }
+        catch (error) {
+            console.error("Error in reverseGeocode:", error);
+            throw new Error("座標轉換地址時發生錯誤");
+        }
+    }
+    async calculateDistanceMatrix(origins, destinations, mode = "driving") {
+        try {
+            const response = await this.client.distancematrix({
+                params: {
+                    origins: origins,
+                    destinations: destinations,
+                    mode: mode,
+                    language: this.defaultLanguage,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                },
+            });
+            const result = response.data;
+            if (result.status !== "OK") {
+                throw new Error(`距離矩陣計算失敗: ${result.status}`);
+            }
+            const distances = [];
+            const durations = [];
+            result.rows.forEach((row) => {
+                const distanceRow = [];
+                const durationRow = [];
+                row.elements.forEach((element) => {
+                    if (element.status === "OK") {
+                        distanceRow.push({
+                            value: element.distance.value,
+                            text: element.distance.text,
+                        });
+                        durationRow.push({
+                            value: element.duration.value,
+                            text: element.duration.text,
+                        });
+                    }
+                    else {
+                        distanceRow.push(null);
+                        durationRow.push(null);
+                    }
+                });
+                distances.push(distanceRow);
+                durations.push(durationRow);
+            });
+            return {
+                distances: distances,
+                durations: durations,
+                origin_addresses: result.origin_addresses,
+                destination_addresses: result.destination_addresses,
+            };
+        }
+        catch (error) {
+            console.error("Error in calculateDistanceMatrix:", error);
+            throw new Error("計算距離矩陣時發生錯誤");
+        }
+    }
+    async getDirections(origin, destination, mode = "driving") {
+        try {
+            const response = await this.client.directions({
+                params: {
+                    origin: origin,
+                    destination: destination,
+                    mode: mode,
+                    language: this.defaultLanguage,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                },
+            });
+            const result = response.data;
+            if (result.status !== "OK") {
+                throw new Error(`路線指引獲取失敗: ${result.status}`);
+            }
+            if (result.routes.length === 0) {
+                throw new Error("找不到路線");
+            }
+            const route = result.routes[0];
+            const legs = route.legs[0];
+            return {
+                routes: result.routes,
+                summary: route.summary,
+                total_distance: {
+                    value: legs.distance.value,
+                    text: legs.distance.text,
+                },
+                total_duration: {
+                    value: legs.duration.value,
+                    text: legs.duration.text,
+                },
+            };
+        }
+        catch (error) {
+            console.error("Error in getDirections:", error);
+            throw new Error("獲取路線指引時發生錯誤");
+        }
+    }
+    async getElevation(locations) {
+        try {
+            const formattedLocations = locations.map((loc) => ({
+                lat: loc.latitude,
+                lng: loc.longitude,
+            }));
+            const response = await this.client.elevation({
+                params: {
+                    locations: formattedLocations,
+                    key: process.env.GOOGLE_MAPS_API_KEY || "",
+                },
+            });
+            const result = response.data;
+            if (result.status !== "OK") {
+                throw new Error(`海拔數據獲取失敗: ${result.status}`);
+            }
+            return result.results.map((item, index) => ({
+                elevation: item.elevation,
+                location: formattedLocations[index],
+            }));
+        }
+        catch (error) {
+            console.error("Error in getElevation:", error);
+            throw new Error("獲取海拔數據時發生錯誤");
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cablate/mcp-google-map",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.cjs --external:pdfreader --external:jsdom --external:mammoth --external:csv-parse --external:libreoffice-convert && shx chmod +x dist/index.cjs",