// 日志级别
const LOG_LEVEL = process.env.LOG_LEVEL || "info";
const DEBUG = LOG_LEVEL === "debug";

// 天气API配置
interface WeatherConfig {
apiKey: string;
baseUrl: string;
units: "metric" | "imperial" | "standard";
}

// 主类
class WeatherMcpServer {
private config: WeatherConfig;
private server: Server;
private cache: NodeCache;

constructor() {
console.error("[Setup] Initializing Weather MCP server...");

// 获取API密钥
const apiKey = process.env.OPENWEATHERMAP_API_KEY;
if (!apiKey) {
console.error("[Error] Missing OPENWEATHERMAP_API_KEY environment variable");
process.exit(1);
}

// 初始化配置
this.config = {
apiKey,
baseUrl: "https://api.openweathermap.org/data/2.5",
units: (process.env.WEATHER_UNITS as any) || "metric"
};

// 初始化缓存
this.cache = new NodeCache({
stdTTL: CACHE_TTL.CURRENT_WEATHER,
checkperiod: 120
});

// 初始化MCP服务器
this.server = new Server();

// 注册处理程序
this.registerHandlers();

console.error("[Setup] Weather MCP server initialized successfully");
}

private registerHandlers(): void {
// 工具执行处理
this.server.setRequestHandler(ToolExecuteRequestSchema, async (request) => {
console.error([Tool] Executing tool: ${request.params.name});

try {
switch (request.params.name) {
case "get_current_weather":
return await this.getCurrentWeather(request.params.params);
case "get_weather_forecast":
return await this.getWeatherForecast(request.params.params);
default:
throw new McpError(ErrorCode.MethodNotFound, Unknown tool: ${request.params.name});
}
} catch (error) {
console.error([Error] Tool execution failed: ${error instanceof Error ? error.message : String(error)});

if (error instanceof McpError) {
throw error;
}

return {
content: [{
type: "text",
text: Error: ${error instanceof Error ? error.message : String(error)}
}],
isError: true
};
}
});

// 工具列表
this.server.setRequestHandler(ToolExecuteRequestSchema.definitions.toolsRequest, async () => {
console.error("[Tools] Getting tools list");

return {
tools: [
{
name: "get_current_weather",
description: "Get the current weather for a location",
parameters: {
type: "object",
properties: {
location: {
type: "string",
description: "City name (e.g., 'London'), or city name with country code (e.g., 'London,uk')"
}
},
required: ["location"]
}
},
{
name: "get_weather_forecast",
description: "Get a 5-day weather forecast for a location",
parameters: {
type: "object",
properties: {
location: {
type: "string",
description: "City name (e.g., 'London'), or city name with country code (e.g., 'London,uk')"
},
days: {
type: "number",
description: "Number of days to forecast (1-5)",
default: 3
}
},
required: ["location"]
}
}
]
};
});

// 资源列表
this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
console.error("[Resources] Getting resources list");

return {
resources: [
{
uri: "file:///weather-mcp/readme.md",
name: "Weather MCP Server README",
mimeType: "text/markdown"
}
]
};
});

// 资源读取
this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
console.error([Resources] Reading resource: ${request.params.uri});

if (request.params.uri === "file:///weather-mcp/readme.md") {
return {
contents: [{
uri: request.params.uri,
mimeType: "text/markdown",
text: this.getReadmeContent()
}]
};
}

throw new McpError(ErrorCode.ResourceNotFound, Resource not found: ${request.params.uri});
});
}

private async getCurrentWeather(params: any): Promise<Tool.ExecuteResponse> {
this.validateLocation(params.location);

const location = params.location;
const cacheKey = current:${location};

// 检查缓存
const cachedData = this.cache.get<any>(cacheKey);
if (cachedData) {
console.error([Cache] Using cached current weather for: ${location});
return cachedData;
}

try {
console.error([API] Getting current weather for: ${location});

const response = await axios.get(${this.config.baseUrl}/weather, {
params: {
q: location,
appid: this.config.apiKey,
units: this.config.units
}
});

const data = response.data;

// 格式化数据
const result = {
content: [{
type: "text",
text: this.formatCurrentWeather(data)
}]
};

// 存入缓存
this.cache.set(cacheKey, result, CACHE_TTL.CURRENT_WEATHER);

return result;
} catch (error) {
if (axios.isAxiosError(error) && error.response?.status === 404) {
throw new McpError(ErrorCode.InvalidParams, Location not found: ${location});
}
throw error;
}
}

private async getWeatherForecast(params: any): Promise<Tool.ExecuteResponse> {
this.validateLocation(params.location);

const location = params.location;
const days = Math.min(Math.max(parseInt(params.days || "3", 10), 1), 5);
const cacheKey = forecast:${location}:${days};

// 检查缓存
const cachedData = this.cache.get<any>(cacheKey);
if (cachedData) {
console.error([Cache] Using cached forecast for: ${location} (${days} days));
return cachedData;
}

try {
console.error([API] Getting ${days}-day forecast for: ${location});

const response = await axios.get(${this.config.baseUrl}/forecast, {
params: {
q: location,
appid: this.config.apiKey,
units: this.config.units
}
});

const data = response.data;

// 格式化数据
const result = {
content: [{
type: "text",
text: this.formatForecast(data, days)
}]
};

// 存入缓存
this.cache.set(cacheKey, result, CACHE_TTL.FORECAST);

return result;
} catch (error) {
if (axios.isAxiosError(error) && error.response?.status === 404) {
throw new McpError(ErrorCode.InvalidParams, Location not found: ${location});
}
throw error;
}
}

private validateLocation(location: unknown): asserts location is string {
if (typeof location !== "string" || location.trim() === "") {
throw new McpError(ErrorCode.InvalidParams, "A valid location is required");
}
}