@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/src/tools/omada/getSsidDetail.ts

@@ -1,22 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-const ssidDetailSchema = z.object({
-    wlanId: z.string().min(1, 'wlanId is required. Use getWlanGroupList to get available WLAN group IDs.'),
-    ssidId: z.string().min(1, 'ssidId is required. Use getSsidList to get available SSID IDs.'),
-    siteId: z.string().min(1).optional(),
-});
-
-export function registerGetSsidDetailTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getSsidDetail',
-        {
-            description: 'Get detailed SSID configuration',
-            inputSchema: ssidDetailSchema,
-        },
-        wrapToolHandler('omada_getSsidDetail', async ({ wlanId, ssidId, siteId }) => toToolResult(await client.getSsidDetail(wlanId, ssidId, siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getSsidList.ts

@@ -1,21 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-const ssidListSchema = z.object({
-    wlanId: z.string().min(1, 'wlanId is required. Use getWlanGroupList to get available WLAN group IDs.'),
-    siteId: z.string().min(1).optional(),
-});
-
-export function registerGetSsidListTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getSsidList',
-        {
-            description: 'Get SSID list for a WLAN group',
-            inputSchema: ssidListSchema,
-        },
-        wrapToolHandler('omada_getSsidList', async ({ wlanId, siteId }) => toToolResult(await client.getSsidList(wlanId, siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getSwitchStackDetail.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { stackIdSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerGetSwitchStackDetailTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getSwitchStackDetail',
-        {
-            description: 'Get detailed information about a switch stack',
-            inputSchema: stackIdSchema,
-        },
-        wrapToolHandler('omada_getSwitchStackDetail', async ({ stackId, siteId }) => toToolResult(await client.getSwitchStackDetail(stackId, siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getThreatList.ts

@@ -1,42 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { createPaginationSchema } from '../utils/pagination-schema.js';
-
-const getThreatListSchema = z.object({
-    siteList: z.string().optional().describe('Comma-separated site IDs. If not provided, all sites are selected by default.'),
-    archived: z.boolean().describe('Whether to include archived threats'),
-    ...createPaginationSchema(10),
-    startTime: z.number().int().describe('Start timestamp in seconds (e.g., 1682000000)'),
-    endTime: z.number().int().describe('End timestamp in seconds (e.g., 1682000000)'),
-    severity: z.number().int().min(0).max(3).optional().describe('Threat severity: 0=Critical, 1=Major, 2=Concerning, 3=Minor'),
-    sortTime: z.enum(['asc', 'desc']).optional().describe('Sort by time: asc or desc'),
-    searchKey: z.string().optional().describe('Fuzzy search for Threat Description/Classification/Classification Description'),
-});
-
-export function registerGetThreatListTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getThreatList',
-        {
-            description: 'Get security threat management list',
-            inputSchema: getThreatListSchema,
-        },
-        wrapToolHandler('omada_getThreatList', async (args) => {
-            const options = {
-                siteList: args.siteList,
-                archived: args.archived,
-                page: args.page,
-                pageSize: args.pageSize,
-                startTime: args.startTime,
-                endTime: args.endTime,
-                severity: args.severity,
-                sortTime: args.sortTime,
-                searchKey: args.searchKey,
-            };
-
-            return toToolResult(await client.getThreatList(options));
-        }, Permission.ADMIN)
-    );
-}

package/src/tools/omada/getWlanGroupList.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { siteInputSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerGetWlanGroupListTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getWlanGroupList',
-        {
-            description: 'Get WLAN group configuration list',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getWlanGroupList', async ({ siteId }) => toToolResult(await client.getWlanGroupList(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/graph.ts

@@ -1,187 +0,0 @@
-/**
- * Omada resource-graph tools: `omada_browse` + `omada_read`.
- *
- * These two tools replace dozens of per-endpoint getters when
- * `MCP_TOOL_REGISTRATION_MODE=graph`. The model navigates a discoverable
- * namespace (browse → read) instead of selecting from a flat list of ~25 tool
- * schemas, which keeps the tool-schema budget small for low-context models while
- * still exposing every read endpoint.
- *
- * Authorization mirrors `wrapToolHandler`:
- *  - `omada_browse` requires QUERY to use, and additionally filters the children
- *    it advertises by the caller's mask (so sensitive subtrees stay invisible).
- *  - `omada_read` declares NO static tool permission; instead it enforces the
- *    per-path permission from the manifest, so each path can require a different
- *    bit. Unknown / container / under-privileged paths fail closed.
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { hasPermission, getPermissionNames } from '../../permissions/index.js';
-import { toToolResult, wrapToolHandler, getCallerPermissions, setToolVisibilityRule, Permission, type ToolExtra } from '../common.js';
-import { OMADA_RESOURCES, childrenOf, getResourceNode, normalizePath, type ReadArgs, type ResourceNode } from './namespace.js';
-
-/** Compact, model-friendly metadata for a node (used in browse output). */
-function nodeSummary(node: ResourceNode): Record<string, unknown> {
-  return {
-    path: node.path,
-    kind: node.kind,
-    permission: getPermissionNames(node.permission).join(',') || 'NONE',
-    description: node.description,
-    readable: node.fetch !== undefined,
-    ...(node.estimatedSize ? { estimatedSize: node.estimatedSize } : {}),
-    ...(node.paginated ? { supportsPagination: true, defaultPageSize: node.defaultPageSize ?? 50 } : {}),
-    ...(node.params && node.params.length > 0 ? { params: node.params } : {}),
-  };
-}
-
-export const browseSchema = z.object({
-  path: z
-    .string()
-    .default('/')
-    .describe('Resource path to explore (default "/"). e.g. "/", "/gateway", "/wifi", "/network".'),
-});
-
-export const readSchema = z.object({
-  path: z.string().describe('Resource path discovered via omada_browse, e.g. "/gateway/wan", "/clients", "/events".'),
-  siteId: z.string().min(1).optional().describe('Site ID (optional; uses the default site if not set).'),
-  id: z.string().min(1).optional().describe('Look up a single member of a collection by id/MAC (where supported).'),
-  params: z
-    .record(z.string(), z.string())
-    .optional()
-    .describe('Path parameters some resources require (see omada_browse "params"), e.g. {"gatewayMac":"AA-BB-CC-DD-EE-FF"}.'),
-  page: z.number().int().min(1).optional().describe('Page number for paginated resources (e.g. "/events").'),
-  pageSize: z.number().int().min(1).max(200).optional().describe('Page size for paginated resources (max 200).'),
-});
-
-/**
- * Shared `omada_browse` handler — used by both the MCP registration below and
- * the chat face (`POST /api/tools/omada_browse`), so validation, RBAC, and
- * behavior stay identical on both faces (v1.7 single-source-of-truth rule).
- */
-export function createBrowseHandler(client: OmadaClient) {
-  void client; // browse only walks the static manifest; client kept for signature symmetry
-  return wrapToolHandler(
-    'omada_browse',
-    async ({ path }: z.infer<typeof browseSchema>, extra: ToolExtra): Promise<ReturnType<typeof toToolResult>> => {
-      const norm = normalizePath(path);
-      const node = getResourceNode(norm);
-      if (!node) {
-        return toToolResult(
-          { error: 'Unknown path', message: `No Omada resource at '${norm}'. Start at '/' and browse downward.` },
-          true
-        );
-      }
-      const mask = getCallerPermissions(extra);
-      const children = childrenOf(norm)
-        .filter((child) => hasPermission(mask, child.permission))
-        .map(nodeSummary);
-      return toToolResult({
-        path: norm,
-        kind: node.kind,
-        description: node.description,
-        readable: node.fetch !== undefined,
-        ...(node.params && node.params.length > 0 ? { params: node.params } : {}),
-        ...(node.paginated ? { supportsPagination: true, defaultPageSize: node.defaultPageSize ?? 50 } : {}),
-        children,
-      });
-    },
-    Permission.QUERY
-  );
-}
-
-/**
- * `omada_read` is usable iff the caller holds the permission of at least one readable
- * (fetchable) resource node; otherwise it is hidden from `tools/list`. Kept next to the
- * handler so the rule cannot drift from the per-path check it summarises.
- */
-export function canReadAnyResource(callerPermissions: number): boolean {
-  return OMADA_RESOURCES.some((node) => node.fetch !== undefined && hasPermission(callerPermissions, node.permission));
-}
-
-/** Shared `omada_read` handler — same dual-face reuse as createBrowseHandler. */
-export function createReadHandler(client: OmadaClient) {
-  setToolVisibilityRule('omada_read', canReadAnyResource);
-  // No static permission: each path declares its own, enforced below (fail-closed).
-  return wrapToolHandler(
-    'omada_read',
-    async (args: z.infer<typeof readSchema>, extra: ToolExtra): Promise<ReturnType<typeof toToolResult>> => {
-      const norm = normalizePath(args.path);
-      const node = getResourceNode(norm);
-      if (!node) {
-        return toToolResult(
-          { error: 'Unknown path', message: `No Omada resource at '${norm}'. Use omada_browse to discover valid paths.` },
-          true
-        );
-      }
-      if (!node.fetch) {
-        return toToolResult(
-          { error: 'Not readable', message: `'${norm}' is a container. Use omada_browse to list its children.` },
-          true
-        );
-      }
-
-      const mask = getCallerPermissions(extra);
-      if (!hasPermission(mask, node.permission)) {
-        const required = getPermissionNames(node.permission);
-        const has = getPermissionNames(mask);
-        return toToolResult(
-          { error: 'Permission denied', message: `Reading '${norm}' requires permission: ${required.join(', ')}`, required, has },
-          true
-        );
-      }
-
-      // Validate required path parameters before touching the controller.
-      const missing = (node.params ?? [])
-        .filter((p) => p.required && !args.params?.[p.name])
-        .map((p) => p.name);
-      if (missing.length > 0) {
-        return toToolResult(
-          { error: 'Missing parameters', message: `'${norm}' requires: ${missing.join(', ')}. Pass them in "params".`, missing },
-          true
-        );
-      }
-
-      const readArgs: ReadArgs = {
-        siteId: args.siteId,
-        id: args.id,
-        params: args.params,
-        page: args.page,
-        pageSize: args.pageSize,
-      };
-      return toToolResult(await node.fetch(client, readArgs));
-    }
-  );
-}
-
-/**
- * Register the resource-graph tools. Returns the number of tools registered (2).
- */
-export function registerOmadaGraphTools(server: McpServer, client: OmadaClient): number {
-  server.registerTool(
-    'omada_browse',
-    {
-      description:
-        'Discover the Omada network resource graph. Returns the children and metadata at a path (resource TYPES, not ' +
-        'instances — no MAC enumeration), so navigate from "/" downward, then call omada_read at a readable node to fetch ' +
-        'data. This replaces dozens of individual getters with one discoverable namespace.',
-      inputSchema: browseSchema,
-    },
-    createBrowseHandler(client)
-  );
-
-  server.registerTool(
-    'omada_read',
-    {
-      description:
-        'Read data from an Omada resource path discovered via omada_browse. Handles single resources (e.g. "/gateway/wan"), ' +
-        'collections (e.g. "/clients", optionally id=<MAC> for one member), and paginated logs (e.g. "/events" with ' +
-        'page/pageSize). Authorization is enforced per-path.',
-      inputSchema: readSchema,
-    },
-    createReadHandler(client)
-  );
-
-  return 2;
-}

package/src/tools/omada/index.ts

@@ -1,153 +0,0 @@
-/**
- * Omada tools index - registers all Omada MCP tools
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { logger } from '../../utils/logger.js';
-
-import { registerBlockClientTool } from './blockClient.js';
-import { registerDeleteClientTool } from './deleteClient.js';
-import { registerListBlockedClientsTool } from './listBlockedClients.js';
-import { registerCyclePoePortTool } from './cyclePoePort.js';
-import { registerOmadaGraphTools } from './graph.js';
-import { registerSetSiteNtpServersTool } from './setSiteNtpServers.js';
-import { registerSetSsidEnabledTool } from './setSsidEnabled.js';
-import { registerDisableClientRateLimitTool } from './disableClientRateLimit.js';
-import { registerGetClientTool } from './getClient.js';
-import { registerGetDeviceTool } from './getDevice.js';
-import { registerGetFirewallSettingTool } from './getFirewallSetting.js';
-import { registerGetInternetInfoTool } from './getInternetInfo.js';
-import { registerGetLanNetworkListTool } from './getLanNetworkList.js';
-import { registerGetLanProfileListTool } from './getLanProfileList.js';
-import { registerGetPortForwardingStatusTool } from './getPortForwardingStatus.js';
-import { registerGetRateLimitProfilesTool } from './getRateLimitProfiles.js';
-import { registerGetSiteNtpStatusTool } from './getSiteNtpStatus.js';
-import { registerGetSsidDetailTool } from './getSsidDetail.js';
-import { registerGetSsidListTool } from './getSsidList.js';
-import { registerGetSwitchStackDetailTool } from './getSwitchStackDetail.js';
-import { registerGetThreatListTool } from './getThreatList.js';
-import { registerGetWlanGroupListTool } from './getWlanGroupList.js';
-import { registerListClientsTool } from './listClients.js';
-import { registerListClientsActivityTool } from './listClientsActivity.js';
-import { registerListClientsPastConnectionsTool } from './listClientsPastConnections.js';
-import { registerListDevicesTool } from './listDevices.js';
-import { registerListDevicesStatsTool } from './listDevicesStats.js';
-import { registerListMostActiveClientsTool } from './listMostActiveClients.js';
-import { registerListSitesTool } from './listSites.js';
-import { registerSearchDevicesTool } from './searchDevices.js';
-import { registerSetClientRateLimitTool } from './setClientRateLimit.js';
-import { registerSetClientRateLimitProfileTool } from './setClientRateLimitProfile.js';
-import { registerUnblockClientTool } from './unblockClient.js';
-
-/**
- * Tool registration strategy for the Omada plugin.
- *  - `eager` (default): register every typed Omada tool (~25). Backwards-compatible.
- *  - `graph`: register only the resource-graph reads (`omada_browse` + `omada_read`)
- *    plus the typed write/action tools. Keeps the tool-schema budget small for
- *    low-context models while still exposing every read endpoint via the namespace.
- */
-export type OmadaRegistrationMode = 'eager' | 'graph';
-
-export function registerOmadaTools(
-  server: McpServer,
-  client: OmadaClient,
-  mode: OmadaRegistrationMode = 'eager'
-): number {
-  if (mode === 'graph') {
-    return registerOmadaToolsGraph(server, client);
-  }
-
-  logger.debug('Registering Omada tools', { mode });
-  let toolCount = 0;
-
-  // Site tools
-  registerListSitesTool(server, client);
-  registerGetSiteNtpStatusTool(server, client);
-  registerSetSiteNtpServersTool(server, client);
-  toolCount += 3;
-
-  // Device tools
-  registerListDevicesTool(server, client);
-  registerGetDeviceTool(server, client);
-  registerSearchDevicesTool(server, client);
-  registerGetSwitchStackDetailTool(server, client);
-  registerListDevicesStatsTool(server, client);
-  toolCount += 5;
-
-  // Client tools
-  registerListClientsTool(server, client);
-  registerGetClientTool(server, client);
-  registerListMostActiveClientsTool(server, client);
-  registerListClientsActivityTool(server, client);
-  registerListClientsPastConnectionsTool(server, client);
-  toolCount += 5;
-
-  // Rate limit tools
-  registerGetRateLimitProfilesTool(server, client);
-  registerSetClientRateLimitTool(server, client);
-  registerSetClientRateLimitProfileTool(server, client);
-  registerDisableClientRateLimitTool(server, client);
-  toolCount += 4;
-
-  // Client block tools
-  registerBlockClientTool(server, client);
-  registerUnblockClientTool(server, client);
-  registerListBlockedClientsTool(server, client);
-  registerDeleteClientTool(server, client);
-  toolCount += 4;
-
-  // Device action tools
-  registerCyclePoePortTool(server, client);
-  toolCount += 1;
-
-  // Security tools
-  registerGetThreatListTool(server, client);
-  toolCount += 1;
-
-  // Network tools
-  registerGetInternetInfoTool(server, client);
-  registerGetPortForwardingStatusTool(server, client);
-  registerGetLanNetworkListTool(server, client);
-  registerGetLanProfileListTool(server, client);
-  registerGetWlanGroupListTool(server, client);
-  registerGetSsidListTool(server, client);
-  registerGetSsidDetailTool(server, client);
-  registerGetFirewallSettingTool(server, client);
-  registerSetSsidEnabledTool(server, client);
-  toolCount += 9;
-
-  logger.info('Omada tools registered', { mode, toolCount });
-  return toolCount;
-}
-
-/**
- * Graph mode: resource-graph reads + typed writes/actions only.
- *
- * Reads collapse into `omada_browse` + `omada_read` (see ./graph.ts and
- * ./namespace.ts). Writes stay as individual, explicitly permission-gated tools —
- * they mutate real network state, so each keeps its own narrow schema and RBAC
- * (CONTROL) rather than being funneled through a generic verb.
- */
-function registerOmadaToolsGraph(server: McpServer, client: OmadaClient): number {
-  logger.debug('Registering Omada tools', { mode: 'graph' });
-  let toolCount = 0;
-
-  // Resource-graph reads (browse + read)
-  toolCount += registerOmadaGraphTools(server, client);
-
-  // Typed write / action tools (unchanged, individually permission-gated)
-  registerSetClientRateLimitTool(server, client);
-  registerSetClientRateLimitProfileTool(server, client);
-  registerDisableClientRateLimitTool(server, client);
-  registerBlockClientTool(server, client);
-  registerUnblockClientTool(server, client);
-  registerDeleteClientTool(server, client);
-  registerCyclePoePortTool(server, client);
-  registerSetSsidEnabledTool(server, client);
-  registerSetSiteNtpServersTool(server, client);
-  toolCount += 9;
-
-  logger.info('Omada tools registered', { mode: 'graph', toolCount });
-  return toolCount;
-}

package/src/tools/omada/listBlockedClients.ts

@@ -1,17 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { siteInputSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerListBlockedClientsTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listBlockedClients',
-        {
-            description:
-                'List clients that are currently blocked, including offline ones (from the known-clients list). ' +
-                'Use it to check block state before or after omada_blockClient / omada_unblockClient.',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_listBlockedClients', async ({ siteId }) => toToolResult(await client.listBlockedClients(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/listClients.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { siteInputSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerListClientsTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listClients',
-        {
-            description: 'List all connected clients (devices/users) in a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_listClients', async ({ siteId }) => toToolResult(await client.listClients(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/listClientsActivity.ts

@@ -1,25 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-const clientActivityInputSchema = z.object({
-    siteId: z.string().optional().describe('Optional site ID. If not provided, uses the default site from configuration.'),
-    start: z.number().int().optional().describe('Optional start timestamp in seconds (e.g., 1682000000)'),
-    end: z.number().int().optional().describe('Optional end timestamp in seconds (e.g., 1682000000)'),
-});
-
-export function registerListClientsActivityTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listClientsActivity',
-        {
-            description: 'Get client activity statistics over time',
-            inputSchema: clientActivityInputSchema,
-        },
-        wrapToolHandler('omada_listClientsActivity', async ({ siteId, start, end }) =>
-            toToolResult(await client.listClientsActivity({ siteId, start, end })),
-            Permission.QUERY
-        )
-    );
-}

package/src/tools/omada/listClientsPastConnections.ts

@@ -1,44 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { createPaginationSchema } from '../utils/pagination-schema.js';
-
-const clientsPastConnectionsInputSchema = z.object({
-    siteId: z.string().optional().describe('Optional site ID. If not provided, uses the default site from configuration.'),
-    ...createPaginationSchema(50),
-    sortLastSeen: z
-        .enum(['asc', 'desc'])
-        .optional()
-        .describe('Sort by last seen time. Values: asc or desc. When multiple sorts exist, first one takes effect.'),
-    timeStart: z.number().int().optional().describe('Filter by time range start timestamp (milliseconds).'),
-    timeEnd: z.number().int().optional().describe('Filter by time range end timestamp (milliseconds).'),
-    guest: z.boolean().optional().describe('Filter by guest status (true/false).'),
-    searchKey: z.string().optional().describe('Fuzzy search by name, MAC address, or SSID.'),
-});
-
-export function registerListClientsPastConnectionsTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listClientsPastConnections',
-        {
-            description: 'Get historical client connection data',
-            inputSchema: clientsPastConnectionsInputSchema,
-        },
-        wrapToolHandler('omada_listClientsPastConnections', async (args) =>
-            toToolResult(
-                await client.listClientsPastConnections({
-                    siteId: args.siteId,
-                    page: args.page,
-                    pageSize: args.pageSize,
-                    sortLastSeen: args.sortLastSeen,
-                    timeStart: args.timeStart,
-                    timeEnd: args.timeEnd,
-                    guest: args.guest,
-                    searchKey: args.searchKey,
-                })
-            ),
-            Permission.QUERY
-        )
-    );
-}

package/src/tools/omada/listDevices.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { siteInputSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerListDevicesTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listDevices',
-        {
-            description: 'List all network devices (APs, switches, gateways) in a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_listDevices', async ({ siteId }) => toToolResult(await client.listDevices(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/listDevicesStats.ts

@@ -1,41 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { createPaginationSchema } from '../utils/pagination-schema.js';
-
-const listDevicesStatsSchema = z.object({
-    ...createPaginationSchema(100),
-    searchMacs: z.string().optional(),
-    searchNames: z.string().optional(),
-    searchModels: z.string().optional(),
-    searchSns: z.string().optional(),
-    filterTag: z.string().optional(),
-    filterDeviceSeriesType: z.string().optional(),
-});
-
-export function registerListDevicesStatsTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listDevicesStats',
-        {
-            description: 'Get statistics for global adopted devices with filtering',
-            inputSchema: listDevicesStatsSchema,
-        },
-        wrapToolHandler('omada_listDevicesStats', async (args) =>
-            toToolResult(
-                await client.listDevicesStats({
-                    page: args.page,
-                    pageSize: args.pageSize,
-                    searchMacs: args.searchMacs,
-                    searchNames: args.searchNames,
-                    searchModels: args.searchModels,
-                    searchSns: args.searchSns,
-                    filterTag: args.filterTag,
-                    filterDeviceSeriesType: args.filterDeviceSeriesType,
-                })
-            ),
-            Permission.QUERY
-        )
-    );
-}

package/src/tools/omada/listMostActiveClients.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { siteInputSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerListMostActiveClientsTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listMostActiveClients',
-        {
-            description: 'Get the most active clients sorted by total traffic',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_listMostActiveClients', async ({ siteId }) => toToolResult(await client.listMostActiveClients(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/listSites.ts

@@ -1,18 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-const emptySchema = z.object({});
-
-export function registerListSitesTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_listSites',
-        {
-            description: 'List all sites configured on the Omada controller',
-            inputSchema: emptySchema,
-        },
-        wrapToolHandler('omada_listSites', async () => toToolResult(await client.listSites()), Permission.QUERY)
-    );
-}