@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/src/tools/homeassistant/systemTools.ts

@@ -1,52 +0,0 @@
-/**
- * System tools - Restart, logs, updates
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { emptySchema, systemLogSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import type { z } from 'zod';
-
-type SystemLogArgs = z.infer<typeof systemLogSchema>;
-
-export function registerRestartHomeAssistantTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'restartHomeAssistant',
-    {
-      description: 'Restart the Home Assistant server. Use with caution.',
-      inputSchema: emptySchema,
-    },
-    wrapToolHandler('restartHomeAssistant', async () => {
-      await client.restartServer();
-      return toToolResult({ success: true, message: 'Home Assistant restart initiated' });
-    }, Permission.ADMIN)
-  );
-}
-
-export function registerGetSystemLogTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getSystemLog',
-    {
-      description: 'Get system log entries from the Home Assistant logbook. Shows recent events and state changes. Default: last 24h, 100 entries.',
-      inputSchema: systemLogSchema,
-    },
-    wrapToolHandler('getSystemLog', async ({ hours = 24, entity_id, limit = 100 }: SystemLogArgs) => {
-      const log = await client.getSystemLog({ hours, entity_id, limit });
-      return toToolResult({ hours, limit, entity_id: entity_id || null, entries: log });
-    }, Permission.ADMIN)
-  );
-}
-
-export function registerCheckUpdatesTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'checkUpdates',
-    {
-      description: 'Check for available updates for Home Assistant Core, Supervisor, and OS. Requires Home Assistant OS or Supervised installation.',
-      inputSchema: emptySchema,
-    },
-    wrapToolHandler('checkUpdates', async () => {
-      const updates = await client.getAvailableUpdates();
-      return toToolResult(updates);
-    }, Permission.ADMIN)
-  );
-}

package/src/tools/homeassistant/triggerAutomation.ts

@@ -1,24 +0,0 @@
-/**
- * triggerAutomation tool - Manually trigger an automation
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { triggerAutomationSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import type { z } from 'zod';
-
-type TriggerAutomationArgs = z.infer<typeof triggerAutomationSchema>;
-
-export function registerTriggerAutomationTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'triggerAutomation',
-    {
-      description: 'Manually trigger a Home Assistant automation. Can optionally pass variables to the automation.',
-      inputSchema: triggerAutomationSchema,
-    },
-    wrapToolHandler('triggerAutomation', async ({ entity_id, variables }: TriggerAutomationArgs) => {
-      const result = await client.triggerAutomation(entity_id, variables as Record<string, unknown> | undefined);
-      return toToolResult({ success: true, entity_id, message: 'Automation triggered successfully', context: result.context });
-    }, Permission.CONFIGURE)
-  );
-}

package/src/tools/index.ts

@@ -1,78 +0,0 @@
-/**
- * Tools index - registers all MCP tools organized by domain
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../haClient/index.js';
-import type { LocalAIClient } from '../localAI/index.js';
-import type { OmadaClient } from '../omadaClient/index.js';
-import { logger } from '../utils/logger.js';
-
-// Tool registration functions by domain
-import { registerHomeAssistantTools } from './homeassistant/index.js';
-import { registerOmadaTools, type OmadaRegistrationMode } from './omada/index.js';
-import { registerAITools } from './ai/index.js';
-import { registerInfraTools, type RestAction } from './infra/index.js';
-import { registerOwnerQuestionTools } from './homeassistant/askOwner.js';
-import type { OwnerQuestionService } from '../ownerQuestions/service.js';
-
-export interface RegisterToolsOptions {
-  server: McpServer;
-  haClient?: HaClient;
-  omadaClient?: OmadaClient;
-  aiClient?: LocalAIClient;
-  /** Pre-registered REST actions for invokeAction (empty/undefined = tool not registered). */
-  restActions?: Record<string, RestAction>;
-  /** Tool registration strategy for the Omada plugin (default 'eager'). */
-  toolRegistrationMode?: OmadaRegistrationMode;
-  /** Owner questions (askOwner & co.); registered only when the service is running. */
-  ownerQuestions?: OwnerQuestionService;
-}
-
-/**
- * Register all available tools based on configured clients
- */
-export function registerAllTools(options: RegisterToolsOptions): void {
-  const { server, haClient, omadaClient, aiClient, restActions, toolRegistrationMode, ownerQuestions } = options;
-  logger.debug('Registering all tools');
-
-  let totalTools = 0;
-
-  // Home Assistant tools (if client provided)
-  if (haClient) {
-    const haToolCount = registerHomeAssistantTools(server, haClient);
-    totalTools += haToolCount;
-    if (ownerQuestions) {
-      totalTools += registerOwnerQuestionTools(server, ownerQuestions);
-    }
-  }
-
-  // Omada tools (if client provided)
-  if (omadaClient) {
-    const omadaToolCount = registerOmadaTools(server, omadaClient, toolRegistrationMode);
-    totalTools += omadaToolCount;
-  }
-
-  // AI tools (always register, but may be disabled if no aiClient)
-  const aiToolCount = registerAITools(server, aiClient);
-  totalTools += aiToolCount;
-
-  // Infra tools (only when REST actions are configured)
-  totalTools += registerInfraTools(server, restActions ?? {});
-
-  logger.info('All tools registered successfully', {
-    totalTools,
-    haEnabled: !!haClient,
-    omadaEnabled: !!omadaClient,
-    aiEnabled: !!aiClient,
-    infraEnabled: Object.keys(restActions ?? {}).length > 0,
-  });
-}
-
-// Re-export common utilities
-export { toToolResult, wrapToolHandler, Permission } from './common.js';
-
-// Re-export domain-specific registration functions for selective use
-export { registerHomeAssistantTools } from './homeassistant/index.js';
-export { registerOmadaTools } from './omada/index.js';
-export { registerAITools } from './ai/index.js';

package/src/tools/infra/actions.ts

@@ -1,95 +0,0 @@
-import { z } from 'zod';
-
-/**
- * A pre-registered REST action the `invokeAction` tool may fire.
- *
- * SECURITY MODEL: the LLM caller supplies ONE thing — an action NAME — which is
- * exact-match looked up here. Method, URL, auth, and timeout all come from this
- * operator-controlled config; no model-supplied string is ever interpolated into
- * any part of the request. A malformed/hostile name can only fail the lookup.
- */
-export interface RestAction {
-    /** Human hint surfaced in the tool description so the agent picks well. */
-    description?: string;
-    method: 'GET' | 'POST';
-    url: string;
-    /** Optional Authorization: Bearer <token> (e.g. watchtower's HTTP-API token). */
-    bearerToken?: string;
-    /** Per-action timeout; some actions (watchtower update = image pulls) run long. */
-    timeoutMs?: number;
-    /**
-     * Minimum interval between firings of THIS action (rate limit). Defaults to
-     * 60s when unset; 0 disables. Caps the blast radius of a prompt-injected
-     * model looping a legitimate action (deploy storms / endpoint DoS) — the
-     * name-only lookup already stops forged actions; this stops repeated real ones.
-     */
-    cooldownMs?: number;
-}
-
-/**
- * Action names are deliberately boring: lowercase alnum with -/_ separators,
- * 1–64 chars, must start alphanumeric. This rejects prototype-pollution shaped
- * keys (`__proto__`), path/URL fragments, and whitespace tricks at CONFIG time,
- * so the runtime lookup only ever sees tame identifiers.
- */
-const ACTION_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
-
-const actionSchema = z.object({
-    description: z.string().max(200).optional(),
-    method: z.enum(['GET', 'POST']).default('POST'),
-    url: z.string().url({ message: 'each action needs a valid http(s) url' }),
-    bearerToken: z.string().min(1).optional(),
-    timeoutMs: z.number().int().min(1000).max(300_000).optional(),
-    // 0 = explicitly disabled; capped at 24h so a config typo can't brick an action.
-    cooldownMs: z.number().int().min(0).max(86_400_000).optional(),
-});
-
-/**
- * Parse MCP_REST_ACTIONS (JSON):
- *   {"update-node-u2":{"method":"POST","url":"http://192.168.0.9:8425/v1/update","bearerToken":"…","description":"deploy latest images on node-u2"}}
- *
- * Returns an empty map when unset; throws on malformed input so a config typo
- * fails loudly at startup instead of silently disabling the tool.
- */
-export function parseRestActions(raw: string | undefined): Record<string, RestAction> {
-    if (!raw || raw.trim() === '') {
-        return {};
-    }
-
-    let json: unknown;
-    try {
-        json = JSON.parse(raw);
-    } catch {
-        throw new Error(
-            'MCP_REST_ACTIONS must be valid JSON: {"name":{"method":"POST","url":"http://host/path","bearerToken":"..."}}'
-        );
-    }
-
-    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
-        throw new Error('MCP_REST_ACTIONS must be a JSON object keyed by action name');
-    }
-
-    // Null-prototype output: even a hostile config key can never shadow or reach
-    // Object.prototype members, and runtime lookups stay own-property-only.
-    const actions: Record<string, RestAction> = Object.create(null) as Record<string, RestAction>;
-
-    for (const [name, value] of Object.entries(json)) {
-        if (!ACTION_NAME_PATTERN.test(name)) {
-            throw new Error(
-                `Invalid MCP_REST_ACTIONS action name '${name}': must match ${ACTION_NAME_PATTERN.source}`
-            );
-        }
-        const parsed = actionSchema.safeParse(value);
-        if (!parsed.success) {
-            const messages = parsed.error.issues.map((issue) => issue.message);
-            throw new Error(`Invalid MCP_REST_ACTIONS entry '${name}':\n${messages.join('\n')}`);
-        }
-        const url = new URL(parsed.data.url);
-        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-            throw new Error(`Invalid MCP_REST_ACTIONS entry '${name}': only http(s) urls are allowed`);
-        }
-        actions[name] = parsed.data;
-    }
-
-    return actions;
-}

package/src/tools/infra/index.ts

@@ -1,138 +0,0 @@
-/**
- * Infra tools — pre-registered REST actions ("actuator rails for HTTP").
- *
- * Design rules:
- *  - The healer lives OUTSIDE the patient (2026-07-10 v1.5.5 outage lesson):
- *    this server never holds a docker socket or update logic; it only pokes
- *    separately-running endpoints (watchtower HTTP API, webhooks) that keep
- *    their own privileges.
- *  - The model can only NAME an action, never shape a request: exact-match,
- *    own-property lookup into operator config. No model string reaches the
- *    URL, method, headers, or body. Redirects are refused; responses are
- *    truncated before they re-enter the context window.
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-
-import { toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { logger } from '../../utils/logger.js';
-
-import type { RestAction } from './actions.js';
-
-export type { RestAction } from './actions.js';
-export { parseRestActions } from './actions.js';
-
-/** Default per-action timeout; watchtower update cycles pull images. */
-const DEFAULT_TIMEOUT_MS = 120_000;
-/** Cap on response bytes surfaced to the caller (anti context-flooding). */
-const MAX_RESPONSE_CHARS = 500;
-/** Default per-action cooldown (override per action via `cooldownMs`; 0 disables). */
-const DEFAULT_COOLDOWN_MS = 60_000;
-
-/**
- * Last-fired timestamps per action name — the rate limiter's whole state.
- *
- * MODULE-level on purpose: the HTTP server registers tools per SESSION, so a
- * closure-scoped map would give every new session a fresh cooldown (trivially
- * bypassed by reconnecting). One process = one store. In-memory is correct for
- * this single-process server; the check-and-claim below runs synchronously
- * before any await, so two racing calls cannot both pass (no TOCTOU on the
- * event loop). Resets on restart — acceptable: a restart itself takes longer
- * than the default cooldown.
- */
-const lastFired = new Map<string, number>();
-
-/** Test hook: clear the process-wide cooldown state between test cases. */
-export function resetActionCooldowns(): void {
-    lastFired.clear();
-}
-
-export function registerInfraTools(server: McpServer, actions: Record<string, RestAction>): number {
-    const names = Object.keys(actions);
-    if (names.length === 0) {
-        return 0;
-    }
-
-    const catalogue = names
-        .map((n) => {
-            const description = actions[n].description;
-            return description ? `${n} (${description})` : n;
-        })
-        .join('; ');
-
-    const inputSchema = z.object({
-        action: z
-            .string()
-            .min(1)
-            .max(64, 'action names are at most 64 chars')
-            .describe(`Name of the pre-registered action to invoke — one of: ${names.join(', ')}`),
-    });
-
-    server.registerTool(
-        'invokeAction',
-        {
-            description:
-                'Invoke a pre-registered REST action by name. Actions are fixed, operator-configured HTTP calls ' +
-                '(method, URL, and credentials come from server config — only the name is chosen here). ' +
-                `Available actions: ${catalogue}. ` +
-                'Actions have real-world effects (deploys, restarts, webhooks) - confirm with the user before applying.',
-            inputSchema: inputSchema,
-        },
-        wrapToolHandler('invokeAction', async ({ action }) => {
-            // Own-property, exact-match lookup. The registry has a null prototype,
-            // so names like 'constructor' or '__proto__' can never resolve to
-            // anything but a genuinely configured action.
-            if (!Object.hasOwn(actions, action)) {
-                throw new Error(`Unknown action '${action}'. Available actions: ${names.join(', ')}`);
-            }
-            const spec = actions[action];
-
-            // Rate limit: check-and-CLAIM synchronously before the fetch, so the
-            // slot is consumed even when the call fails (no hammering a dying
-            // endpoint), and two racing calls can't both pass.
-            const cooldownMs = spec.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-            if (cooldownMs > 0) {
-                const now = Date.now();
-                const elapsed = now - (lastFired.get(action) ?? Number.NEGATIVE_INFINITY);
-                if (elapsed < cooldownMs) {
-                    const retryInS = Math.ceil((cooldownMs - elapsed) / 1000);
-                    throw new Error(
-                        `Action '${action}' is cooling down — try again in ~${String(retryInS)}s. ` +
-                        'Repeated firing of infrastructure actions is rate-limited by design.'
-                    );
-                }
-                lastFired.set(action, now);
-            }
-
-            logger.info('Invoking registered REST action', { action, method: spec.method, url: spec.url });
-
-            const response = await fetch(spec.url, {
-                method: spec.method,
-                headers: spec.bearerToken ? { Authorization: `Bearer ${spec.bearerToken}` } : undefined,
-                // A registered endpoint that suddenly redirects is a surprise, not
-                // a convenience — fail closed rather than follow.
-                redirect: 'error',
-                signal: AbortSignal.timeout(spec.timeoutMs ?? DEFAULT_TIMEOUT_MS),
-            });
-
-            const body = (await response.text().catch(() => '')).slice(0, MAX_RESPONSE_CHARS);
-
-            if (!response.ok) {
-                throw new Error(`Action '${action}' returned HTTP ${String(response.status)}${body ? `: ${body}` : ''}`);
-            }
-
-            return toToolResult({
-                action,
-                status: 'completed',
-                httpStatus: response.status,
-                response: body || undefined,
-            });
-        },
-            Permission.ADMIN
-        )
-    );
-
-    logger.info('Infra tools registered', { toolCount: 1, actions: names });
-    return 1;
-}

package/src/tools/omada/blockClient.ts

@@ -1,28 +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';
-
-export function registerBlockClientTool(server: McpServer, client: OmadaClient): void {
-    const inputSchema = z.object({
-        clientMac: z.string().min(1, 'clientMac (MAC address) is required'),
-        siteId: z.string().min(1).optional(),
-    });
-
-    server.registerTool(
-        'omada_blockClient',
-        {
-            description:
-                'Block a client from the network by MAC address. The client is denied all network access until unblocked. ' +
-                'Use omada_listClients first to find the exact MAC. This affects real network connectivity - confirm with the user before applying. ' +
-                "Caution: a blocked device cannot reconnect, and once the controller stops treating it as current, Omada's API can no longer unblock it. " +
-                'For recurring schedules (e.g. a curfew) prefer an Omada time-range access rule on the controller over daily block/unblock calls.',
-            inputSchema: inputSchema,
-        },
-        wrapToolHandler('omada_blockClient', async ({ clientMac, siteId }) =>
-            toToolResult(await client.blockClient(clientMac, siteId)),
-            Permission.CONTROL
-        )
-    );
-}

package/src/tools/omada/cyclePoePort.ts

@@ -1,32 +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';
-
-export function registerCyclePoePortTool(server: McpServer, client: OmadaClient): void {
-    const inputSchema = z.object({
-        switchMac: z.string().min(1, 'switchMac (MAC address of the Omada switch) is required'),
-        ports: z.array(z.number().int().positive()).min(1, 'at least one port number is required'),
-        siteId: z.string().min(1).optional(),
-    });
-
-    server.registerTool(
-        'omada_cyclePoePort',
-        {
-            description:
-                'Power-cycle PoE on one or more switch ports — a remote hard-reboot for whatever the ports power ' +
-                '(access points, cameras, PoE sensors). The switch briefly cuts and restores power on ONLY the given ' +
-                'ports; the switch itself and other ports are unaffected. Use omada_listDevices to find the switch MAC ' +
-                'and identify which port powers which device first. The powered device goes down for the cycle - ' +
-                'confirm with the user before applying.',
-            inputSchema: inputSchema,
-        },
-        wrapToolHandler('omada_cyclePoePort', async ({ switchMac, ports, siteId }) => {
-            await client.cyclePoePorts(switchMac, ports, siteId);
-            return toToolResult({ switchMac, ports, status: 'poe-recovery triggered' });
-        },
-            Permission.CONTROL
-        )
-    );
-}

package/src/tools/omada/deleteClient.ts

@@ -1,27 +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';
-
-export function registerDeleteClientTool(server: McpServer, client: OmadaClient): void {
-    const inputSchema = z.object({
-        clientMac: z.string().min(1, 'clientMac (MAC address) is required'),
-        siteId: z.string().min(1).optional(),
-    });
-
-    server.registerTool(
-        'omada_deleteClient',
-        {
-            description:
-                "Delete the controller's record of a client by MAC: its name, history and block state. " +
-                'Use it to clear a block that omada_unblockClient can no longer reach (the device stays refused by the access points although Omada lists nothing). ' +
-                'The device is treated as new when it reconnects. Irreversible for that history - confirm with the user before applying.',
-            inputSchema,
-        },
-        wrapToolHandler('omada_deleteClient', async ({ clientMac, siteId }: z.infer<typeof inputSchema>) =>
-            toToolResult(await client.deleteClient(clientMac, siteId)),
-            Permission.CONFIGURE
-        )
-    );
-}

package/src/tools/omada/disableClientRateLimit.ts

@@ -1,23 +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';
-
-export function registerDisableClientRateLimitTool(server: McpServer, client: OmadaClient): void {
-    const inputSchema = z.object({
-        clientMac: z.string().min(1, 'clientMac (MAC address) is required'),
-        siteId: z.string().min(1).optional(),
-    });
-
-    server.registerTool(
-        'omada_disableClientRateLimit',
-        {
-            description: 'Remove bandwidth limits from a client',
-            inputSchema: inputSchema,
-        },
-        wrapToolHandler('omada_disableClientRateLimit', async ({ clientMac, siteId }) =>
-            toToolResult(await client.disableClientRateLimit(clientMac, siteId)),
-            Permission.CONTROL
-        )
-    );
-}

package/src/tools/omada/getClient.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { clientIdSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerGetClientTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getClient',
-        {
-            description: 'Get detailed information about a specific connected client',
-            inputSchema: clientIdSchema,
-        },
-        wrapToolHandler('omada_getClient', async ({ clientId, siteId }) => toToolResult(await client.getClient(clientId, siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getDevice.ts

@@ -1,14 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { OmadaClient } from '../../omadaClient/index.js';
-import { deviceIdSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerGetDeviceTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getDevice',
-        {
-            description: 'Get detailed information about a specific network device',
-            inputSchema: deviceIdSchema,
-        },
-        wrapToolHandler('omada_getDevice', async ({ deviceId, siteId }) => toToolResult(await client.getDevice(deviceId, siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getFirewallSetting.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 registerGetFirewallSettingTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getFirewallSetting',
-        {
-            description: 'Get firewall configuration for a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getFirewallSetting', async ({ siteId }) => toToolResult(await client.getFirewallSetting(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getInternetInfo.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 registerGetInternetInfoTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getInternetInfo',
-        {
-            description: 'Get internet connection configuration for a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getInternetInfo', async ({ siteId }) => toToolResult(await client.getInternetInfo(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getLanNetworkList.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 registerGetLanNetworkListTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getLanNetworkList',
-        {
-            description: 'Get LAN network configuration list',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getLanNetworkList', async ({ siteId }) => toToolResult(await client.getLanNetworkList(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getLanProfileList.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 registerGetLanProfileListTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getLanProfileList',
-        {
-            description: 'Get LAN profile configuration list',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getLanProfileList', async ({ siteId }) => toToolResult(await client.getLanProfileList(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getPortForwardingStatus.ts

@@ -1,26 +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 portForwardingSchema = z.object({
-    type: z.enum(['User', 'UPnP']).describe('Port forwarding type: User (manually configured) or UPnP (automatically configured)'),
-    siteId: z.string().min(1).describe('Site ID (required)'),
-    ...createPaginationSchema(10),
-});
-
-export function registerGetPortForwardingStatusTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getPortForwardingStatus',
-        {
-            description: 'Get port forwarding rules (User or UPnP)',
-            inputSchema: portForwardingSchema,
-        },
-        wrapToolHandler('omada_getPortForwardingStatus', async ({ type, siteId, page = 1, pageSize = 10 }) =>
-            toToolResult(await client.getPortForwardingStatus(type, siteId, page, pageSize)),
-            Permission.QUERY
-        )
-    );
-}

package/src/tools/omada/getRateLimitProfiles.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 registerGetRateLimitProfilesTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getRateLimitProfiles',
-        {
-            description: 'Get available rate limit profiles for a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getRateLimitProfiles', async ({ siteId }) => toToolResult(await client.getRateLimitProfiles(siteId)), Permission.QUERY)
-    );
-}

package/src/tools/omada/getSiteNtpStatus.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 registerGetSiteNtpStatusTool(server: McpServer, client: OmadaClient): void {
-    server.registerTool(
-        'omada_getSiteNtpStatus',
-        {
-            description: 'Get the NTP (network time) server configuration and status for a site',
-            inputSchema: siteInputSchema,
-        },
-        wrapToolHandler('omada_getSiteNtpStatus', async ({ siteId }) => toToolResult(await client.getSiteNtpStatus(siteId)), Permission.QUERY)
-    );
-}