837 lines
35 KiB
Python
837 lines
35 KiB
Python
#!/usr/bin/env python3
|
|
import os
|
|
import json
|
|
import asyncio
|
|
from datetime import datetime
|
|
from typing import Any, Dict, List, Optional
|
|
from mcp.server.stdio import stdio_server
|
|
from mcp.server import Server
|
|
from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
|
|
from dotenv import load_dotenv
|
|
|
|
# Import our helper from update_data
|
|
from update_data import gather_all_info, fetch_data, post_data, save_data, get_base_url
|
|
|
|
load_dotenv()
|
|
|
|
# Configuration
|
|
DEVICES_FILE = "/home/wartana/myApp/mikrotik-mcp/devices.json"
|
|
BILLING_CONFIG_FILE = "/home/wartana/myApp/billing-mcp/config.json"
|
|
DATA_DIR = "/home/wartana/myApp/mikrotik-mcp/data"
|
|
SNAPSHOTS_DIR = os.path.join(DATA_DIR, "snapshots")
|
|
|
|
# Create the MCP server
|
|
server = Server("mikrotik")
|
|
|
|
def load_devices() -> List[Dict]:
|
|
"""Load list of routers from devices.json"""
|
|
try:
|
|
if os.path.exists(DEVICES_FILE):
|
|
with open(DEVICES_FILE, 'r') as f:
|
|
return json.load(f)
|
|
return []
|
|
except Exception as e:
|
|
print(f"Error loading devices: {e}")
|
|
return []
|
|
|
|
def load_billing_routers() -> List[Dict]:
|
|
"""Load routers from billing-mcp config.json as fallback"""
|
|
try:
|
|
if os.path.exists(BILLING_CONFIG_FILE):
|
|
with open(BILLING_CONFIG_FILE, 'r') as f:
|
|
config = json.load(f)
|
|
|
|
routers = []
|
|
for isp_key, isp_data in config.get("isps", {}).items():
|
|
for router_name, router_config in isp_data.get("routers", {}).items():
|
|
routers.append({
|
|
"name": router_name,
|
|
"host": router_config.get("host"),
|
|
"port": router_config.get("port", 80),
|
|
"user": router_config.get("user"),
|
|
"pass": router_config.get("pass"),
|
|
"isp": isp_key
|
|
})
|
|
return routers
|
|
return []
|
|
except Exception as e:
|
|
print(f"Error loading billing config: {e}")
|
|
return []
|
|
|
|
def get_router(router_name: str | None) -> Dict | None:
|
|
"""Get router config by name, with fallback to billing config"""
|
|
devices = load_devices()
|
|
|
|
# Try devices.json first
|
|
if devices:
|
|
if not router_name:
|
|
return devices[0]
|
|
for d in devices:
|
|
if d.get("name").lower() == router_name.lower():
|
|
return d
|
|
|
|
# Fallback to billing config
|
|
billing_routers = load_billing_routers()
|
|
if billing_routers:
|
|
if not router_name and not devices:
|
|
return billing_routers[0]
|
|
for r in billing_routers:
|
|
if r.get("name").lower() == router_name.lower():
|
|
return r
|
|
|
|
return None
|
|
|
|
def get_router_data_path(router_name: str) -> str:
|
|
"""Get path to the snapshot data file for a specific router"""
|
|
safe_name = router_name.replace(" ", "_").lower()
|
|
return os.path.join(DATA_DIR, f"{safe_name}.json")
|
|
|
|
def save_snapshot(router_name: str, endpoint: str, data: Any) -> str:
|
|
"""Save raw data to a timestamped snapshot file and return the path"""
|
|
os.makedirs(SNAPSHOTS_DIR, exist_ok=True)
|
|
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
safe_router = router_name.replace(" ", "_").lower()
|
|
endpoint_part = endpoint.replace("/", "_")
|
|
filename = f"{safe_router}_{endpoint_part}_{timestamp}.json"
|
|
filepath = os.path.join(SNAPSHOTS_DIR, filename)
|
|
|
|
with open(filepath, 'w') as f:
|
|
json.dump(data, f, indent=2)
|
|
|
|
return filepath
|
|
|
|
def ensure_first_item(data: Any) -> Dict:
|
|
"""Helper to ensure we get a dictionary, even if MikroTik returns a list or a single object."""
|
|
if isinstance(data, list):
|
|
return data[0] if len(data) > 0 else {}
|
|
if isinstance(data, dict):
|
|
return data
|
|
return {}
|
|
|
|
@server.list_tools()
|
|
async def handle_list_tools() -> list[Tool]:
|
|
"""List available MikroTik tools."""
|
|
return [
|
|
Tool(
|
|
name="list_routers",
|
|
description="Melihat daftar router MikroTik yang terdaftar di konfigurasi.",
|
|
inputSchema={"type": "object", "properties": {}},
|
|
),
|
|
Tool(
|
|
name="get_status",
|
|
description="Mendapatkan informasi dasar router (CPU, Memori, Uptime).",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router (lihat list_routers). Opsional, default ke router pertama."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_interfaces",
|
|
description="Mendapatkan daftar interface network dan status traffic.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
"running_only": {"type": "boolean", "description": "Hanya tampilkan interface yang aktif."},
|
|
"full_data": {"type": "boolean", "description": "Tampilkan semua field data (Hati-hati: bisa menyebabkan error context length jika data sangat besar)."},
|
|
"limit": {"type": "integer", "description": "Batas jumlah interface yang ditampilkan (Default 50, Max 200)."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_hotspot_active",
|
|
description="Mendapatkan daftar pengguna hotspot yang sedang aktif.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_logs",
|
|
description="Mendapatkan baris log terakhir dari router.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
"limit": {"type": "integer", "description": "Jumlah log (default 20)."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="refresh_data",
|
|
description="Sinkronisasi data terbaru langsung dari router ke snapshot file.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="test_permissions",
|
|
description="Mengecek izin akses user MikroTik ke berbagai menu API (Diagnostik).",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="add_router",
|
|
description="Menambahkan router MikroTik baru ke dalam daftar konfigurasi.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {"type": "string", "description": "Nama unik untuk router (misal: Batuaji)."},
|
|
"host": {"type": "string", "description": "IP atau Hostname router."},
|
|
"port": {"type": "integer", "description": "Port REST API (default 80)."},
|
|
"user": {"type": "string", "description": "Username admin."},
|
|
"pass": {"type": "string", "description": "Password admin."},
|
|
},
|
|
"required": ["name", "host", "user", "pass"],
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_ppp_active",
|
|
description="Mendapatkan daftar sesi PPP (PPPoE/L2TP/VPN) yang saat ini aktif.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_ppp_secrets",
|
|
description="Mendapatkan daftar user/secrets yang terdaftar di layanan PPP.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_queues",
|
|
description="Mendapatkan daftar Simple Queues untuk melihat limitasi bandwidth user.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_queue_tree",
|
|
description="Mendapatkan daftar Queue Tree untuk melihat manajemen bandwidth yang lebih kompleks.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="remove_router",
|
|
description="Menghapus router dari daftar konfigurasi.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"name": {"type": "string", "description": "Nama router yang ingin dihapus."},
|
|
},
|
|
"required": ["name"],
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_vlans",
|
|
description="Mendapatkan daftar interface VLAN (filter by type=vlan).",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_gateway_interfaces",
|
|
description="Mendapatkan daftar interface yang berfungsi sebagai gateway (dari routing table).",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
"active_only": {"type": "boolean", "description": "Hanya tampilkan gateway yang aktif (default: true)."},
|
|
},
|
|
},
|
|
),
|
|
Tool(
|
|
name="get_interface_traffic",
|
|
description="Mendapatkan traffic rate (tx/rx) interface dalam format Mbps yang mudah dibaca.",
|
|
inputSchema={
|
|
"type": "object",
|
|
"properties": {
|
|
"router_name": {"type": "string", "description": "Nama router."},
|
|
"interface_name": {"type": "string", "description": "Nama interface spesifik (opsional, jika kosong tampilkan semua yang running)."},
|
|
"running_only": {"type": "boolean", "description": "Hanya tampilkan interface yang aktif (default: true)."},
|
|
},
|
|
},
|
|
)
|
|
]
|
|
|
|
@server.call_tool()
|
|
async def handle_call_tool(name: str, arguments: dict | None) -> list[TextContent | ImageContent | EmbeddedResource]:
|
|
"""Handle tool execution requests."""
|
|
|
|
try:
|
|
# 1. Handle list_routers (no router connection needed)
|
|
if name == "list_routers":
|
|
devices = load_devices()
|
|
billing_routers = load_billing_routers()
|
|
|
|
summary = []
|
|
seen_names = set()
|
|
|
|
# Add devices from devices.json
|
|
for d in devices:
|
|
summary.append({"name": d["name"], "host": d["host"], "source": "devices.json"})
|
|
seen_names.add(d["name"].lower())
|
|
|
|
# Add devices from billing config if not duplicate
|
|
for r in billing_routers:
|
|
if r["name"].lower() not in seen_names:
|
|
summary.append({"name": r["name"], "host": r["host"], "source": "billing-mcp"})
|
|
|
|
return [TextContent(type="text", text=json.dumps(summary, indent=2))]
|
|
|
|
# 2. Get target router
|
|
router_name = arguments.get("router_name") if arguments else None
|
|
router = get_router(router_name)
|
|
|
|
if not router:
|
|
return [TextContent(type="text", text=f"❌ Router '{router_name or 'Default'}' tidak ditemukan.")]
|
|
|
|
# Prepare connection info
|
|
auth = (router["user"], router["pass"])
|
|
base_url = get_base_url(router["host"], router["port"])
|
|
actual_name = router["name"]
|
|
|
|
if name == "get_status":
|
|
try:
|
|
resource_raw = fetch_data("system/resource", auth, base_url)
|
|
identity_raw = fetch_data("system/identity", auth, base_url)
|
|
|
|
resource_data = ensure_first_item(resource_raw)
|
|
identity_data = ensure_first_item(identity_raw)
|
|
|
|
identity_name = identity_data.get("name", "Unknown")
|
|
|
|
data = {
|
|
"router_name": actual_name,
|
|
"identity": identity_name,
|
|
"resource": resource_data
|
|
}
|
|
return [TextContent(type="text", text=json.dumps(data, indent=2))]
|
|
except Exception as e:
|
|
return [TextContent(type="text", text=f"❌ Gagal mengambil status router: {str(e)}\n\nTips: Pastikan user memiliki izin untuk '/system/resource' dan '/system/identity'.")]
|
|
|
|
elif name == "get_interfaces":
|
|
# Parsing arguments
|
|
running_only = arguments.get("running_only", False) if arguments else False
|
|
full_data = arguments.get("full_data", False) if arguments else False
|
|
user_limit = arguments.get("limit", 50) if arguments else 50
|
|
if user_limit > 200: user_limit = 200
|
|
|
|
# Optimizing fetch with server-side filtering and field selection
|
|
endpoint = "interface/print"
|
|
payload = {}
|
|
|
|
# 1. Server-side Query/Filter
|
|
query = []
|
|
if running_only:
|
|
query.append("running=true")
|
|
|
|
if query:
|
|
payload[".query"] = query
|
|
|
|
# 2. Server-side Field Selection (Proplist)
|
|
# If full_data is False, request only specific fields to save bandwidth
|
|
if not full_data:
|
|
payload[".proplist"] = [".id", "name", "type", "running", "disabled", "comment", "default-name", "actual-mtu", "mac-address"]
|
|
|
|
try:
|
|
# Use POST for query/proplist support
|
|
interfaces = post_data(endpoint, payload, auth, base_url)
|
|
except Exception as e:
|
|
# Fallback to standard GET if POST fails (compatibility)
|
|
print(f"POST interface/print failed: {e}. Falling back to GET.")
|
|
interfaces = fetch_data("interface", auth, base_url)
|
|
# Apply client-side filtering since server-side failed
|
|
if running_only:
|
|
interfaces = [i for i in interfaces if i.get("running") == "true" or i.get("running") is True]
|
|
|
|
total_found = len(interfaces)
|
|
interfaces = interfaces[:user_limit]
|
|
|
|
# 3. Handle Field Filtering (Default: Minimal fields)
|
|
full_data = arguments.get("full_data", False) if arguments else False
|
|
|
|
# SAVE FULL DATA SNAPSHOT ALWAYS
|
|
snapshot_path = save_snapshot(actual_name, "interface", interfaces)
|
|
|
|
if not full_data:
|
|
# Essential fields only to save context/tokens
|
|
essential_fields = ["name", "type", "running", "disabled", "comment", "default-name"]
|
|
optimized_interfaces = []
|
|
for iface in interfaces:
|
|
optimized_interfaces.append({k: iface.get(k) for k in essential_fields if k in iface})
|
|
interfaces = optimized_interfaces
|
|
|
|
# LIMIT RESPONSE SIZE FOR LLM
|
|
display_limit = 15
|
|
is_truncated = total_found > display_limit
|
|
preview_interfaces = interfaces[:display_limit]
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"count": total_found,
|
|
"showing": len(preview_interfaces),
|
|
"snapshot_file": snapshot_path,
|
|
"status": "Truncated for readability." if is_truncated else "Full list.",
|
|
"interfaces": preview_interfaces
|
|
}
|
|
|
|
msg = json.dumps(result, indent=2)
|
|
if is_truncated:
|
|
msg += f"\n\n⚠️ DATA TRUNCATED ({total_found} items). Only showing {display_limit} to save context."
|
|
msg += f"\n📂 Full snapshot: {snapshot_path}"
|
|
|
|
# FINAL SAFETY CAP (30KB)
|
|
if len(msg) > 30000:
|
|
msg = msg[:30000] + "\n\n... [TRUNCATED DUE TO EXTREME SIZE] ..."
|
|
|
|
return [TextContent(type="text", text=msg)]
|
|
|
|
elif name == "get_hotspot_active":
|
|
hotspot = fetch_data("ip/hotspot/active", auth, base_url)
|
|
total = len(hotspot) if isinstance(hotspot, list) else 0
|
|
|
|
snapshot_path = save_snapshot(actual_name, "ip_hotspot_active", hotspot)
|
|
|
|
# Summarize for LLM
|
|
display_limit = 10
|
|
preview = hotspot[:display_limit] if isinstance(hotspot, list) else hotspot
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_active": total,
|
|
"snapshot_file": snapshot_path,
|
|
"sample_users": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} user aktif.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "get_logs":
|
|
limit = arguments.get("limit", 20) if arguments else 20
|
|
logs = fetch_data("log", auth, base_url)
|
|
|
|
snapshot_path = save_snapshot(actual_name, "log", logs)
|
|
|
|
recent_logs = logs[-limit:] if logs else []
|
|
|
|
summary = {
|
|
"router": actual_name,
|
|
"total_logs_available": len(logs) if logs else 0,
|
|
"snapshot_file": snapshot_path,
|
|
"recent_entries": recent_logs
|
|
}
|
|
|
|
msg = json.dumps(summary, indent=2)
|
|
msg += f"\n\n📂 Log lengkap disimpan di: {snapshot_path}"
|
|
|
|
# FINAL SAFETY CAP (30KB)
|
|
if len(msg) > 30000:
|
|
msg = msg[:30000] + "\n\n... [TRUNCATED DUE TO EXTREME SIZE] ..."
|
|
|
|
return [TextContent(type="text", text=msg)]
|
|
|
|
elif name == "get_ppp_active":
|
|
ppp_active = fetch_data("ppp/active", auth, base_url)
|
|
total = len(ppp_active) if isinstance(ppp_active, list) else 0
|
|
|
|
snapshot_path = save_snapshot(actual_name, "ppp_active", ppp_active)
|
|
|
|
# Summarize for LLM
|
|
display_limit = 10
|
|
preview = ppp_active[:display_limit] if isinstance(ppp_active, list) else ppp_active
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_active_ppp": total,
|
|
"snapshot_file": snapshot_path,
|
|
"sample_active": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} PPP active.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "get_ppp_secrets":
|
|
ppp_secrets = fetch_data("ppp/secret", auth, base_url)
|
|
total = len(ppp_secrets) if isinstance(ppp_secrets, list) else 0
|
|
|
|
snapshot_path = save_snapshot(actual_name, "ppp_secret", ppp_secrets)
|
|
|
|
# Summarize for LLM
|
|
display_limit = 10
|
|
preview = ppp_secrets[:display_limit] if isinstance(ppp_secrets, list) else ppp_secrets
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_secrets": total,
|
|
"snapshot_file": snapshot_path,
|
|
"sample_secrets": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} PPP secrets.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "get_queues":
|
|
queues = fetch_data("queue/simple", auth, base_url)
|
|
total = len(queues) if isinstance(queues, list) else 0
|
|
|
|
snapshot_path = save_snapshot(actual_name, "queue_simple", queues)
|
|
|
|
# Summarize for LLM
|
|
display_limit = 15
|
|
preview = queues[:display_limit] if isinstance(queues, list) else queues
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_queues": total,
|
|
"snapshot_file": snapshot_path,
|
|
"sample_queues": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} simple queues.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "get_queue_tree":
|
|
qtree = fetch_data("queue/tree", auth, base_url)
|
|
total = len(qtree) if isinstance(qtree, list) else 0
|
|
|
|
snapshot_path = save_snapshot(actual_name, "queue_tree", qtree)
|
|
|
|
# Summarize for LLM
|
|
display_limit = 15
|
|
preview = qtree[:display_limit] if isinstance(qtree, list) else qtree
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_queue_tree": total,
|
|
"snapshot_file": snapshot_path,
|
|
"sample_queue_tree": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} entries di queue tree.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "refresh_data":
|
|
new_data = gather_all_info(router["host"], router["port"], router["user"], router["pass"])
|
|
if new_data:
|
|
data_path = get_router_data_path(actual_name)
|
|
save_data(new_data, data_path)
|
|
return [TextContent(type="text", text=f"✅ Data for router '{actual_name}' successfully updated in {data_path}.")]
|
|
else:
|
|
return [TextContent(type="text", text=f"❌ Failed to refresh data for '{actual_name}'.")]
|
|
|
|
elif name == "test_permissions":
|
|
endpoints = [
|
|
"system/resource", "system/identity", "interface",
|
|
"ip/address", "ip/hotspot/active", "log", "user", "ppp/secret"
|
|
]
|
|
results = {}
|
|
failures = []
|
|
for ep in endpoints:
|
|
try:
|
|
fetch_data(ep, auth, base_url)
|
|
results[ep] = "✅ OK"
|
|
except Exception as e:
|
|
results[ep] = f"❌ {str(e)}"
|
|
failures.append(f"{ep}: {str(e)}")
|
|
|
|
troubleshooting = ""
|
|
if failures:
|
|
troubleshooting = "\n\n🔍 ANALISIS & SOLUSI:\n"
|
|
if any("system/resource" in f for f in failures):
|
|
troubleshooting += "- Endpoint 'system/resource' gagal. Jika user memiliki akses FULL, coba cek apakah service 'www' (port 80) di router memiliki filter IP atau jika ada firewall yang memblokir request besar.\n"
|
|
if any("HTTP 403" in f for f in failures):
|
|
troubleshooting += "- Beberapa menu memerlukan izin spesifik. Walaupun user group-nya 'full', pastikan tidak ada kebijakan 'skin' yang membatasi API.\n"
|
|
if any("Connection Error" in f or "Timeout" in f for f in failures):
|
|
troubleshooting += "- Masalah konektivitas. Pastikan IP Router dapat dijangkau dari server ini dan service API MikroTik aktif.\n"
|
|
|
|
summary = {
|
|
"router": actual_name,
|
|
"host": router["host"],
|
|
"results": results,
|
|
"troubleshooting": troubleshooting
|
|
}
|
|
return [TextContent(type="text", text=json.dumps(summary, indent=2) + troubleshooting)]
|
|
|
|
elif name == "add_router":
|
|
devices = load_devices()
|
|
new_device = {
|
|
"name": arguments["name"],
|
|
"host": arguments["host"],
|
|
"port": arguments.get("port", 80),
|
|
"user": arguments["user"],
|
|
"pass": arguments["pass"]
|
|
}
|
|
# Check if name already exists
|
|
if any(d["name"].lower() == new_device["name"].lower() for d in devices):
|
|
return [TextContent(type="text", text=f"❌ Router dengan nama '{new_device['name']}' sudah ada.")]
|
|
|
|
devices.append(new_device)
|
|
with open(DEVICES_FILE, 'w') as f:
|
|
json.dump(devices, f, indent=2)
|
|
return [TextContent(type="text", text=f"✅ Router '{new_device['name']}' berhasil ditambahkan.")]
|
|
|
|
elif name == "remove_router":
|
|
devices = load_devices()
|
|
name_to_remove = arguments["name"].lower()
|
|
new_devices = [d for d in devices if d["name"].lower() != name_to_remove]
|
|
|
|
if len(new_devices) == len(devices):
|
|
return [TextContent(type="text", text=f"❌ Router '{arguments['name']}' tidak ditemukan.")]
|
|
|
|
with open(DEVICES_FILE, 'w') as f:
|
|
json.dump(new_devices, f, indent=2)
|
|
return [TextContent(type="text", text=f"✅ Router '{arguments['name']}' berhasil dihapus.")]
|
|
|
|
elif name == "get_vlans":
|
|
interfaces = fetch_data("interface", auth, base_url)
|
|
|
|
# Filter VLAN only
|
|
vlans = [i for i in interfaces if i.get("type") == "vlan"]
|
|
total = len(vlans)
|
|
|
|
snapshot_path = save_snapshot(actual_name, "interface_vlan", vlans)
|
|
|
|
# Display limit for LLM
|
|
display_limit = 30
|
|
preview = vlans[:display_limit]
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"total_vlan_interfaces": total,
|
|
"snapshot_file": snapshot_path,
|
|
"vlans": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if total > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {total} VLAN interfaces.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
elif name == "get_gateway_interfaces":
|
|
routes = fetch_data("ip/route", auth, base_url)
|
|
|
|
active_only = arguments.get("active_only", True) if arguments else True
|
|
|
|
# Extract gateway interfaces from immediate-gw field (format: IP%interface)
|
|
gateway_interfaces = {}
|
|
for r in routes:
|
|
immediate_gw = r.get("immediate-gw", "")
|
|
if "%" in immediate_gw:
|
|
parts = immediate_gw.split("%")
|
|
gw_ip = parts[0]
|
|
iface = parts[1]
|
|
|
|
# Filter active only
|
|
if active_only and r.get("active") != "true":
|
|
continue
|
|
|
|
if iface not in gateway_interfaces:
|
|
gateway_interfaces[iface] = {
|
|
"interface": iface,
|
|
"gateway_ips": [],
|
|
"routes": []
|
|
}
|
|
|
|
gateway_interfaces[iface]["gateway_ips"].append(gw_ip)
|
|
gateway_interfaces[iface]["routes"].append({
|
|
"dst": r.get("dst-address"),
|
|
"gateway": r.get("gateway"),
|
|
"distance": r.get("distance"),
|
|
"routing_table": r.get("routing-table"),
|
|
"active": r.get("active") == "true"
|
|
})
|
|
|
|
# Deduplicate gateway IPs
|
|
for iface in gateway_interfaces:
|
|
gateway_interfaces[iface]["gateway_ips"] = list(set(gateway_interfaces[iface]["gateway_ips"]))
|
|
|
|
snapshot_path = save_snapshot(actual_name, "gateway_interfaces", list(gateway_interfaces.values()))
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"filter": "active_only" if active_only else "all",
|
|
"total_gateway_interfaces": len(gateway_interfaces),
|
|
"snapshot_file": snapshot_path,
|
|
"gateway_interfaces": list(gateway_interfaces.values())
|
|
}
|
|
|
|
return [TextContent(type="text", text=json.dumps(result, indent=2))]
|
|
|
|
elif name == "get_interface_traffic":
|
|
# 1. Get List of Interfaces (to know names)
|
|
interfaces = fetch_data("interface", auth, base_url)
|
|
|
|
# Filter by running only (default true)
|
|
running_only = arguments.get("running_only", True) if arguments else True
|
|
if running_only:
|
|
interfaces = [i for i in interfaces if i.get("running") == "true" or i.get("running") is True]
|
|
|
|
# Filter by specific interface name if provided
|
|
interface_name = arguments.get("interface_name") if arguments else None
|
|
if interface_name:
|
|
interfaces = [i for i in interfaces if i.get("name", "").lower() == interface_name.lower()]
|
|
|
|
# If no interfaces found, return early
|
|
if not interfaces:
|
|
return [TextContent(type="text", text=f"⚠️ No interfaces found matching criteria.")]
|
|
|
|
# 2. Monitor Traffic (Real-time Stats)
|
|
target_names = [i.get("name") for i in interfaces]
|
|
target_str = ",".join(target_names)
|
|
|
|
# Mikrotik monitor-traffic can be heavy if many interfaces.
|
|
# If > 10 interfaces, we might want to batch or limit?
|
|
# REST API usually handles handle comma separated list fine.
|
|
|
|
monitor_data = {}
|
|
try:
|
|
# Use monitor-traffic command via POST
|
|
# Payload: interface=name1,name2&once=true
|
|
payload = {
|
|
"interface": target_str,
|
|
"once": "true"
|
|
}
|
|
|
|
mon_result = post_data("interface/monitor-traffic", payload, auth, base_url)
|
|
|
|
# Map results by name
|
|
if isinstance(mon_result, list):
|
|
for m in mon_result:
|
|
monitor_data[m.get("name")] = m
|
|
elif isinstance(mon_result, dict) and mon_result.get("name"):
|
|
monitor_data[mon_result.get("name")] = mon_result
|
|
|
|
except Exception as e:
|
|
# Fallback or log error
|
|
# If monitor-traffic fails (e.g. some interface type doesn't support it),
|
|
# we might get partial data or error.
|
|
# Let's try to continue with basic stats if available, or just report error.
|
|
print(f"Monitor traffic error: {e}")
|
|
# We will just use empty stats if monitor fails
|
|
|
|
def format_rate(bps_val):
|
|
"""Format bits per second to human readable Mbps/Kbps"""
|
|
try:
|
|
bps = float(bps_val)
|
|
if bps >= 1_000_000:
|
|
return f"{bps / 1_000_000:.2f} Mbps"
|
|
elif bps >= 1_000:
|
|
return f"{bps / 1_000:.2f} Kbps"
|
|
else:
|
|
return f"{bps:.0f} bps"
|
|
except (ValueError, TypeError):
|
|
return "0 bps"
|
|
|
|
# Extract traffic info combining config + monitor data
|
|
traffic_data = []
|
|
for iface in interfaces:
|
|
name = iface.get("name")
|
|
mon = monitor_data.get(name, {})
|
|
|
|
# Get stats from monitor data (preferred) or interface data (fallback)
|
|
tx_bps = mon.get("tx-bits-per-second", iface.get("tx-bit", 0))
|
|
rx_bps = mon.get("rx-bits-per-second", iface.get("rx-bit", 0))
|
|
|
|
traffic_data.append({
|
|
"name": name,
|
|
"type": iface.get("type"),
|
|
"tx_rate": format_rate(tx_bps),
|
|
"rx_rate": format_rate(rx_bps),
|
|
"tx_rate_raw_bps": tx_bps,
|
|
"rx_rate_raw_bps": rx_bps,
|
|
"running": iface.get("running"),
|
|
"disabled": iface.get("disabled")
|
|
})
|
|
|
|
# Sort by tx_rate descending (highest traffic first)
|
|
traffic_data.sort(key=lambda x: float(x.get("tx_rate_raw_bps", 0) or 0), reverse=True)
|
|
|
|
snapshot_path = save_snapshot(actual_name, "interface_traffic", traffic_data)
|
|
|
|
# Limit display
|
|
display_limit = 20
|
|
preview = traffic_data[:display_limit]
|
|
|
|
result = {
|
|
"router": actual_name,
|
|
"filter": "running_only" if running_only else "all",
|
|
"total_interfaces": len(traffic_data),
|
|
"snapshot_file": snapshot_path,
|
|
"interfaces": preview
|
|
}
|
|
|
|
text_res = json.dumps(result, indent=2)
|
|
if len(traffic_data) > display_limit:
|
|
text_res += f"\n\n⚠️ Hanya menampilkan {display_limit} dari {len(traffic_data)} interfaces.\n"
|
|
text_res += f"📂 Data lengkap: {snapshot_path}"
|
|
|
|
return [TextContent(type="text", text=text_res)]
|
|
|
|
else:
|
|
raise ValueError(f"Unknown tool: {name}")
|
|
|
|
except Exception as e:
|
|
return [TextContent(type="text", text=f"Error executing tool {name}: {str(e)}")]
|
|
|
|
async def main():
|
|
async with stdio_server() as (read_stream, write_stream):
|
|
await server.run(
|
|
read_stream,
|
|
write_stream,
|
|
server.create_initialization_options()
|
|
)
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())
|