@serve.zone/dcrouter 15.2.4 → 15.3.0

package/dist_ts/plugins.js

@@ -34,6 +34,7 @@ import * as smartguard from '@push.rocks/smartguard';
 import * as smartjwt from '@push.rocks/smartjwt';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartmetrics from '@push.rocks/smartmetrics';
+import * as smartmcp from '@push.rocks/smartmcp';
 import * as smartmta from '@push.rocks/smartmta';
 import * as smartdb from '@push.rocks/smartdb';
 import * as smartnetwork from '@push.rocks/smartnetwork';
@@ -46,7 +47,7 @@ import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartrx from '@push.rocks/smartrx';
 import * as smartunique from '@push.rocks/smartunique';
 import * as taskbuffer from '@push.rocks/taskbuffer';
-export { projectinfo, qenv, smartacme, smartchallenge, smartdata, smartdns, smartfs, smartguard, smartjwt, smartlog, smartmetrics, smartdb, smartmta, smartnetwork, smartpath, smartproxy, smartpromise, smartradius, smartrequest, smartrx, smartunique, smartvpn, taskbuffer };
+export { projectinfo, qenv, smartacme, smartchallenge, smartdata, smartdns, smartfs, smartguard, smartjwt, smartlog, smartmetrics, smartmcp, smartdb, smartmta, smartnetwork, smartpath, smartproxy, smartpromise, smartradius, smartrequest, smartrx, smartunique, smartvpn, taskbuffer };
 // apiclient.xyz scope
 import * as cloudflare from '@apiclient.xyz/cloudflare';
 export { cloudflare, };
@@ -117,4 +118,4 @@ export const fsUtils = {
         return JSON.parse(content);
     },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBRWxDLE9BQU8sRUFDTCxHQUFHLEVBQ0gsRUFBRSxFQUNGLE1BQU0sRUFDTixJQUFJLEVBQ0osR0FBRyxFQUNILE1BQU0sRUFDTixFQUFFLEVBQ0YsSUFBSSxFQUNKLEdBQUcsRUFDSCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssbUJBQW1CLE1BQU0sd0JBQXdCLENBQUM7QUFDOUQsT0FBTyxLQUFLLGFBQWEsTUFBTSwyQkFBMkIsQ0FBQztBQUUzRCxPQUFPLEVBQ0wsbUJBQW1CLEVBQ25CLGFBQWEsR0FDZCxDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBRXZELE9BQU8sRUFDTCxZQUFZLEVBQ1osV0FBVyxFQUNYLFdBQVcsR0FDWixDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sd0JBQXdCLENBQUM7QUFFdkQsT0FBTyxFQUNMLFlBQVksR0FDYixDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLElBQUksTUFBTSxrQkFBa0IsQ0FBQztBQUN6QyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxjQUFjLE1BQU0sNEJBQTRCLENBQUM7QUFDN0QsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBS2pSLHNCQUFzQjtBQUN0QixPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBRXhELE9BQU8sRUFDTCxVQUFVLEdBQ1gsQ0FBQTtBQUVELGdCQUFnQjtBQUNoQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFDTCxPQUFPLEdBQ1IsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUU3QixPQUFPLEVBQ0wsSUFBSSxHQUNMLENBQUE7QUFFRCx1QkFBdUI7QUFDdkIsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHO0lBQ3JCOztPQUVHO0lBQ0gsYUFBYSxFQUFFLENBQUMsT0FBZSxFQUFRLEVBQUU7UUFDdkMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxTQUFTLEVBQUUsS0FBSyxFQUFFLE9BQWUsRUFBaUIsRUFBRTtRQUNsRCxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFRDs7T0FFRztJQUNILFFBQVEsRUFBRSxDQUFDLE9BQVksRUFBRSxRQUFnQixFQUFRLEVBQUU7UUFDakQsTUFBTSxJQUFJLEdBQUcsT0FBTyxPQUFPLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztRQUN0RixFQUFFLENBQUMsYUFBYSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLEVBQUUsS0FBSyxFQUFFLE9BQVksRUFBRSxRQUFnQixFQUFpQixFQUFFO1FBQzVELE1BQU0sSUFBSSxHQUFHLE9BQU8sT0FBTyxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDdEYsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsY0FBYyxFQUFFLENBQUMsUUFBZ0IsRUFBVyxFQUFFO1FBQzVDLE9BQU8sRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVLEVBQUUsS0FBSyxFQUFFLFFBQWdCLEVBQW9CLEVBQUU7UUFDdkQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUNuQyxPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxZQUFZLEVBQUUsQ0FBVSxRQUFnQixFQUFLLEVBQUU7UUFDN0MsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDbEQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBTSxDQUFDO0lBQ2xDLENBQUM7SUFFRDs7T0FFRztJQUNILFFBQVEsRUFBRSxLQUFLLEVBQVcsUUFBZ0IsRUFBYyxFQUFFO1FBQ3hELE1BQU0sT0FBTyxHQUFHLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQzdELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQU0sQ0FBQztJQUNsQyxDQUFDO0NBQ0YsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_oci_container/index.js

@@ -92,16 +92,17 @@ export function getOciContainerConfig() {
     const maxConnectionsPerIP = process.env.DCROUTER_MAX_CONNECTIONS_PER_IP;
     const connectionRateLimit = process.env.DCROUTER_CONNECTION_RATE_LIMIT;
     if (maxConnections || maxConnectionsPerIP || connectionRateLimit) {
-        options.smartProxyConfig = {
-            ...options.smartProxyConfig,
-            routes: options.smartProxyConfig?.routes || [],
+        const currentProxyConfig = options.coreTrafficConfig || options.smartProxyConfig;
+        options.coreTrafficConfig = {
+            ...currentProxyConfig,
+            routes: currentProxyConfig?.routes || [],
             ...(maxConnectionsPerIP ? { maxConnectionsPerIP: parseInt(maxConnectionsPerIP, 10) } : {}),
             ...(connectionRateLimit ? { connectionRateLimitPerMinute: parseInt(connectionRateLimit, 10) } : {}),
             ...(maxConnections ? {
                 defaults: {
-                    ...options.smartProxyConfig?.defaults,
+                    ...currentProxyConfig?.defaults,
                     security: {
-                        ...options.smartProxyConfig?.defaults?.security,
+                        ...currentProxyConfig?.defaults?.security,
                         maxConnections: parseInt(maxConnections, 10),
                     },
                 },
@@ -110,4 +111,4 @@ export function getOciContainerConfig() {
     }
     return options;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/dcrouter',
-    version: '15.2.4',
+    version: '15.3.0',
     description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSwwRUFBMEU7Q0FDeEYsQ0FBQSJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "15.2.4",
+  "version": "15.3.0",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "bin": {
@@ -45,13 +45,14 @@
     "@push.rocks/smartguard": "^3.1.0",
     "@push.rocks/smartjwt": "^2.2.2",
     "@push.rocks/smartlog": "^3.2.2",
+    "@push.rocks/smartmcp": "^0.2.0",
     "@push.rocks/smartmetrics": "^3.0.3",
     "@push.rocks/smartmigration": "1.4.1",
     "@push.rocks/smartmta": "^6.1.0",
     "@push.rocks/smartnetwork": "^4.7.2",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.4",
-    "@push.rocks/smartproxy": "^27.17.3",
+    "@push.rocks/smartproxy": "^27.17.4",
     "@push.rocks/smartradius": "^1.3.0",
     "@push.rocks/smartrequest": "^5.0.3",
     "@push.rocks/smartrx": "^3.0.10",

package/readme.md

@@ -61,7 +61,7 @@ This starts the gateway on unprivileged ports and stores data under the default
 import { DcRouter } from '@serve.zone/dcrouter';
 
 const router = new DcRouter({
-  smartProxyConfig: {
+  coreTrafficConfig: {
     routes: [
       {
         name: 'local-app',
@@ -111,7 +111,7 @@ Bootstrap behavior:
 | Option | Purpose |
 | --- | --- |
 | `baseDir` | Root directory for dcrouter runtime data. Defaults to `~/.serve.zone/dcrouter`. |
-| `smartProxyConfig` | Main SmartProxy route configuration for HTTP/HTTPS/TCP/SNI traffic. |
+| `coreTrafficConfig` | Main CoreTraffic route configuration for HTTP/HTTPS/TCP/SNI traffic. `smartProxyConfig` remains accepted as a legacy alias. |
 | `emailConfig` | UnifiedEmailServer configuration: hostname, ports, domains, and mail routes. |
 | `emailPortConfig` | External-to-internal email port mapping and received-email storage path. |
 | `tls` | Legacy/static TLS and ACME contact settings used to seed certificate config. |
@@ -140,7 +140,7 @@ dcrouter keeps generated and operator-created routes separate so automation can
 
 | Origin | Source | Mutability |
 | --- | --- | --- |
-| `config` | Constructor `smartProxyConfig.routes` and seed data | Toggle only |
+| `config` | Constructor `coreTrafficConfig.routes` and seed data | Toggle only |
 | `email` | Email listener and email-domain generated routes | Toggle only |
 | `dns` | Generated DNS-over-HTTPS and DNS-related routes | Toggle only |
 | `api` | Ops UI or API client | Full CRUD |
@@ -288,7 +288,7 @@ import { DcRouter } from '@serve.zone/dcrouter';
 
 const router = new DcRouter({
   baseDir: '/var/lib/dcrouter',
-  smartProxyConfig: {
+  coreTrafficConfig: {
     routes: [
       {
         name: 'web-app',
@@ -362,6 +362,8 @@ const targetProfile = {
 
 The OpsServer exposes TypedRequest handlers at `/typedrequest`. You can use raw contracts or the object-oriented API client.
 
+It also exposes an admin-JWT authenticated read-only MCP endpoint at `/mcp`. The MCP tools return safe summaries for runtime status, routes, source and target profiles, network targets, DNS, email domains, RemoteIngress edges, and VPN clients without API tokens, logs, certificates, private keys, or provider credentials.
+
 ```bash
 pnpm add @serve.zone/dcrouter-apiclient
 ```
@@ -384,7 +386,7 @@ const route = await client.routes.build()
 await route.toggle(true);
 ```
 
-Use `@serve.zone/dcrouter/interfaces` or `@serve.zone/dcrouter-interfaces` when you want the raw TypedRequest contracts instead of resource managers.
+Use `@serve.zone/dcrouter/interfaces` or `@serve.zone/dcrouter-interfaces` when you want dcrouter-local raw TypedRequest contracts instead of resource managers. Use `@serve.zone/interfaces` for the canonical machine-facing gateway client route, DNS, and domain contracts shared with Onebox and Cloudly.
 
 ## OCI / Container Bootstrap
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '15.2.4',
+  version: '15.3.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

package/ts/classes.dcrouter.ts

@@ -48,9 +48,12 @@ export interface IDcRouterOptions {
   baseDir?: string;
 
   /**
-   * Direct SmartProxy configuration - gives full control over HTTP/HTTPS and TCP/SNI traffic
+   * Direct CoreTraffic configuration - gives full control over HTTP/HTTPS and TCP/SNI traffic
    * This is the preferred way to configure HTTP/HTTPS and general TCP/SNI traffic
    */
+  coreTrafficConfig?: plugins.smartproxy.ISmartProxyOptions;
+
+  /** Legacy name for coreTrafficConfig. */
   smartProxyConfig?: plugins.smartproxy.ISmartProxyOptions;
   
   /**
@@ -347,9 +350,13 @@ export class DcRouter {
   private qenv = new plugins.qenv.Qenv('./', '.nogit/');
   
   constructor(optionsArg: IDcRouterOptions) {
+    const coreTrafficConfig = optionsArg.coreTrafficConfig || optionsArg.smartProxyConfig;
+
     // Set defaults in options
     this.options = {
-      ...optionsArg
+      ...optionsArg,
+      coreTrafficConfig,
+      smartProxyConfig: coreTrafficConfig,
     };
 
     // Resolve all data paths from baseDir
@@ -1544,6 +1551,7 @@ export class DcRouter {
     }
 
     // Update configuration
+    this.options.coreTrafficConfig = config;
     this.options.smartProxyConfig = config;
 
     // Start new SmartProxy with updated configuration (rebuilds seed routes)

package/ts/opsserver/classes.mcpmanager.ts

@@ -0,0 +1,393 @@
+import * as plugins from '../plugins.js';
+import type { OpsServer } from './classes.opsserver.js';
+import type * as interfaces from '../../ts_interfaces/index.js';
+
+type TRouteTarget = NonNullable<interfaces.data.IDcRouterRouteConfig['action']['targets']>[number];
+type TRouteTargetValue = TRouteTarget['host'] | TRouteTarget['port'];
+
+interface IDnsRecordSummary {
+  id: string;
+  domainId: string;
+  domainName?: string;
+  name: string;
+  type: interfaces.data.TDnsRecordType;
+  value: string;
+  ttl: number;
+  proxied?: boolean;
+  source: interfaces.data.TDnsRecordSource;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export class McpManager {
+  private handler: plugins.smartmcp.ISmartMcpHttpHandler;
+
+  constructor(private opsServerRef: OpsServer) {
+    this.handler = plugins.smartmcp.createSmartMcpHttpHandler({
+      name: 'dcrouter-mcp',
+      version: '1.0.0',
+      validateRequest: ({ request }) => this.validateRequest(request),
+      authorize: async ({ request }) => this.authorizeRequest(request),
+      tools: [
+        {
+          name: 'dcrouter_get_status',
+          description: 'Get dcrouter runtime inventory counts without logs, tokens, certificates, or credentials.',
+          handler: async () => ({
+            status: await this.getStatusSummary(),
+          }),
+        },
+        {
+          name: 'dcrouter_list_routes',
+          description: 'List dcrouter route summaries without raw route secrets, logs, or certificates.',
+          handler: async () => ({
+            routes: this.getMergedRoutes().map((routeArg) => this.summarizeRoute(routeArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_source_profiles',
+          description: 'List source profile summaries without embedded credentials.',
+          handler: async () => ({
+            sourceProfiles: (this.opsServerRef.dcRouterRef.referenceResolver?.listProfiles() || []).map((profileArg) => this.summarizeSourceProfile(profileArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_target_profiles',
+          description: 'List target profile summaries for VPN and private access routing.',
+          handler: async () => ({
+            targetProfiles: (this.opsServerRef.dcRouterRef.targetProfileManager?.listProfiles() || []).map((profileArg) => this.summarizeTargetProfile(profileArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_network_targets',
+          description: 'List reusable network target summaries.',
+          handler: async () => ({
+            networkTargets: (this.opsServerRef.dcRouterRef.referenceResolver?.listTargets() || []).map((targetArg) => this.summarizeNetworkTarget(targetArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_domains',
+          description: 'List managed DNS domains without provider zone IDs or provider credentials.',
+          handler: async () => ({
+            domains: (await this.opsServerRef.dcRouterRef.dnsManager?.listDomains() || []).map((domainArg) => this.summarizeDomain(domainArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_dns_records',
+          description: 'List managed DNS record summaries without provider record IDs or provider credentials.',
+          handler: async () => ({
+            dnsRecords: await this.getDnsRecords(),
+          }),
+        },
+        {
+          name: 'dcrouter_list_email_domains',
+          description: 'List email domain summaries without DKIM private keys, mailboxes, or message contents.',
+          handler: async () => ({
+            emailSettings: this.opsServerRef.dcRouterRef.emailSettingsManager?.getPublicSettings(),
+            emailDomains: (await this.opsServerRef.dcRouterRef.emailDomainManager?.getAll() || []).map((domainArg) => this.summarizeEmailDomain(domainArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_remote_ingress_edges',
+          description: 'List RemoteIngress edge summaries without edge secrets.',
+          handler: async () => ({
+            hubSettings: this.summarizeRemoteIngressHubSettings(this.opsServerRef.dcRouterRef.remoteIngressManager?.getHubSettings()),
+            edges: (this.opsServerRef.dcRouterRef.remoteIngressManager?.getAllEdges() || []).map((edgeArg) => this.summarizeRemoteIngressEdge(edgeArg)),
+          }),
+        },
+        {
+          name: 'dcrouter_list_vpn_clients',
+          description: 'List VPN client summaries without private keys or exported configs.',
+          handler: async () => ({
+            running: this.opsServerRef.dcRouterRef.vpnManager?.running ?? false,
+            clients: (this.opsServerRef.dcRouterRef.vpnManager?.listClients() || []).map((clientArg) => this.summarizeVpnClient(clientArg)),
+          }),
+        },
+      ],
+    });
+  }
+
+  public async handleRequest(requestArg: Request): Promise<Response> {
+    return this.handler.handleRequest(requestArg);
+  }
+
+  public getHandler(): plugins.smartmcp.ISmartMcpHttpHandler {
+    return this.handler;
+  }
+
+  private validateRequest(requestArg: Request): Response | undefined {
+    const origin = requestArg.headers.get('origin');
+    if (origin && origin !== new URL(requestArg.url).origin) {
+      return new Response('Forbidden', { status: 403 });
+    }
+  }
+
+  private async authorizeRequest(requestArg: Request): Promise<Response | { token: string; clientId: string; scopes: string[] }> {
+    const jwt = this.extractBearerToken(requestArg);
+    if (!jwt) {
+      return new Response('Unauthorized', { status: 401 });
+    }
+
+    try {
+      const identity = await this.opsServerRef.adminHandler.getVerifiedAdminIdentityFromJwt(jwt);
+      return {
+        token: jwt,
+        clientId: identity.userId,
+        scopes: ['admin', 'mcp', 'dcrouter:read'],
+      };
+    } catch {
+      return new Response('Unauthorized', { status: 401 });
+    }
+  }
+
+  private extractBearerToken(requestArg: Request): string | undefined {
+    const authHeader = requestArg.headers.get('authorization');
+    if (!authHeader) {
+      return undefined;
+    }
+    const [scheme, token] = authHeader.split(' ');
+    if (scheme?.toLowerCase() !== 'bearer' || !token) {
+      return undefined;
+    }
+    return token.trim() || undefined;
+  }
+
+  private async getStatusSummary() {
+    const routes = this.getMergedRoutes();
+    const domains = await this.opsServerRef.dcRouterRef.dnsManager?.listDomains().catch(() => []) || [];
+    const emailDomains = await this.opsServerRef.dcRouterRef.emailDomainManager?.getAll().catch(() => []) || [];
+    const edges = this.opsServerRef.dcRouterRef.remoteIngressManager?.getAllEdges() || [];
+    const vpnClients = this.opsServerRef.dcRouterRef.vpnManager?.listClients() || [];
+
+    return {
+      smartProxyRunning: Boolean(this.opsServerRef.dcRouterRef.smartProxy),
+      emailEnabled: this.opsServerRef.dcRouterRef.emailSettingsManager?.getPublicSettings?.()?.enabled ?? Boolean(this.opsServerRef.dcRouterRef.emailServer),
+      dnsEnabled: Boolean(this.opsServerRef.dcRouterRef.dnsServer),
+      radiusEnabled: Boolean(this.opsServerRef.dcRouterRef.radiusServer),
+      remoteIngressEnabled: this.opsServerRef.dcRouterRef.remoteIngressManager?.getHubSettings?.()?.enabled ?? false,
+      vpnRunning: this.opsServerRef.dcRouterRef.vpnManager?.running ?? false,
+      routeCount: routes.length,
+      enabledRouteCount: routes.filter((routeArg) => routeArg.enabled !== false).length,
+      domainCount: domains.length,
+      emailDomainCount: emailDomains.length,
+      remoteIngressEdgeCount: edges.length,
+      vpnClientCount: vpnClients.length,
+    };
+  }
+
+  private getMergedRoutes(): interfaces.data.IMergedRoute[] {
+    return this.opsServerRef.dcRouterRef.routeConfigManager?.getMergedRoutes()?.routes || [];
+  }
+
+  private async getDnsRecords(): Promise<IDnsRecordSummary[]> {
+    const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
+    if (!dnsManager?.listDomains || !dnsManager?.listRecordsForDomain) {
+      return [];
+    }
+
+    const domains = await dnsManager.listDomains();
+    const records: IDnsRecordSummary[] = [];
+    for (const domain of domains) {
+      const domainRecords = await dnsManager.listRecordsForDomain(domain.id);
+      records.push(...domainRecords.map((recordArg) => this.summarizeDnsRecord(recordArg, domain.name)));
+    }
+    return records;
+  }
+
+  private summarizeRoute(routeArg: interfaces.data.IMergedRoute) {
+    const route = routeArg.route || {};
+    const targets = route.action?.targets || [];
+    return {
+      id: routeArg.id,
+      name: route.name,
+      enabled: routeArg.enabled,
+      origin: routeArg.origin,
+      systemKey: routeArg.systemKey,
+      match: {
+        ports: route.match?.ports,
+        domains: route.match?.domains,
+        protocol: route.match?.protocol,
+        transport: route.match?.transport,
+        path: route.match?.path,
+      },
+      action: {
+        targetCount: targets.length,
+        targets: targets.map((targetArg) => this.summarizeRouteTarget(targetArg)),
+      },
+      remoteIngress: route.remoteIngress ? {
+        enabled: route.remoteIngress.enabled,
+        edgeFilter: route.remoteIngress.edgeFilter,
+      } : undefined,
+      vpnOnly: route.vpnOnly,
+      metadata: routeArg.metadata ? {
+        ownerType: routeArg.metadata.ownerType,
+        gatewayClientType: routeArg.metadata.gatewayClientType,
+        networkTargetName: routeArg.metadata.networkTargetName,
+        sourceBindingCount: routeArg.metadata.sourceBindings?.length || 0,
+        pathPolicyCount: routeArg.metadata.sourceBindings?.reduce((countArg, bindingArg) => countArg + (bindingArg.pathPolicies?.length || 0), 0) || 0,
+      } : undefined,
+      createdAt: routeArg.createdAt,
+      updatedAt: routeArg.updatedAt,
+    };
+  }
+
+  private summarizeRouteTarget(targetArg: TRouteTarget) {
+    return {
+      host: this.summarizeRouteTargetValue(targetArg.host),
+      port: this.summarizeRouteTargetValue(targetArg.port),
+    };
+  }
+
+  private summarizeRouteTargetValue(valueArg: TRouteTargetValue) {
+    return typeof valueArg === 'function' ? '[dynamic]' : valueArg;
+  }
+
+  private summarizeSourceProfile(profileArg: interfaces.data.ISourceProfile) {
+    return {
+      id: profileArg.id,
+      name: profileArg.name,
+      description: profileArg.description,
+      extendsProfiles: profileArg.extendsProfiles,
+      security: this.summarizeSecurity(profileArg.security),
+      createdAt: profileArg.createdAt,
+      updatedAt: profileArg.updatedAt,
+    };
+  }
+
+  private summarizeSecurity(securityArg: interfaces.data.IRouteSecurity) {
+    if (!securityArg) return undefined;
+    return {
+      ipAllowListCount: securityArg.ipAllowList?.length || 0,
+      ipBlockListCount: securityArg.ipBlockList?.length || 0,
+      rateLimitEnabled: Boolean(securityArg.rateLimit),
+      challengeEnabled: Boolean(securityArg.challenge),
+      maxConnections: securityArg.maxConnections,
+      requireVpnClient: securityArg.vpn?.required,
+    };
+  }
+
+  private summarizeTargetProfile(profileArg: interfaces.data.ITargetProfile) {
+    return {
+      id: profileArg.id,
+      name: profileArg.name,
+      description: profileArg.description,
+      domainCount: profileArg.domains?.length || 0,
+      domains: profileArg.domains,
+      targetCount: profileArg.targets?.length || 0,
+      routeRefCount: profileArg.routeRefs?.length || 0,
+      allowRoutesByClientSourceIp: profileArg.allowRoutesByClientSourceIp,
+      createdAt: profileArg.createdAt,
+      updatedAt: profileArg.updatedAt,
+    };
+  }
+
+  private summarizeNetworkTarget(targetArg: interfaces.data.INetworkTarget) {
+    return {
+      id: targetArg.id,
+      name: targetArg.name,
+      description: targetArg.description,
+      host: targetArg.host,
+      port: targetArg.port,
+      createdAt: targetArg.createdAt,
+      updatedAt: targetArg.updatedAt,
+    };
+  }
+
+  private summarizeDomain(domainArg: interfaces.data.IDomain) {
+    return {
+      id: domainArg.id,
+      name: domainArg.name,
+      source: domainArg.source,
+      providerId: domainArg.providerId,
+      authoritative: domainArg.authoritative,
+      nameservers: domainArg.nameservers,
+      lastSyncedAt: domainArg.lastSyncedAt,
+      description: domainArg.description,
+      createdAt: domainArg.createdAt,
+      updatedAt: domainArg.updatedAt,
+    };
+  }
+
+  private summarizeDnsRecord(recordArg: interfaces.data.IDnsRecord, domainNameArg?: string): IDnsRecordSummary {
+    return {
+      id: recordArg.id,
+      domainId: recordArg.domainId,
+      domainName: domainNameArg,
+      name: recordArg.name,
+      type: recordArg.type,
+      value: recordArg.value,
+      ttl: recordArg.ttl,
+      proxied: recordArg.proxied,
+      source: recordArg.source,
+      createdAt: recordArg.createdAt,
+      updatedAt: recordArg.updatedAt,
+    };
+  }
+
+  private summarizeEmailDomain(domainArg: interfaces.data.IEmailDomain) {
+    return {
+      id: domainArg.id,
+      domain: domainArg.domain,
+      linkedDomainId: domainArg.linkedDomainId,
+      subdomain: domainArg.subdomain,
+      dkim: domainArg.dkim ? {
+        selector: domainArg.dkim.selector,
+        keySize: domainArg.dkim.keySize,
+        rotateKeys: domainArg.dkim.rotateKeys,
+        rotationIntervalDays: domainArg.dkim.rotationIntervalDays,
+        lastRotatedAt: domainArg.dkim.lastRotatedAt,
+      } : undefined,
+      dnsStatus: domainArg.dnsStatus,
+      rateLimits: domainArg.rateLimits,
+      createdAt: domainArg.createdAt,
+      updatedAt: domainArg.updatedAt,
+    };
+  }
+
+  private summarizeRemoteIngressHubSettings(settingsArg: interfaces.data.IRemoteIngressHubSettings | undefined) {
+    if (!settingsArg) return undefined;
+    return {
+      enabled: settingsArg.enabled,
+      tunnelPort: settingsArg.tunnelPort,
+      hubDomain: settingsArg.hubDomain,
+      performance: settingsArg.performance,
+      updatedAt: settingsArg.updatedAt,
+    };
+  }
+
+  private summarizeRemoteIngressEdge(edgeArg: interfaces.data.IRemoteIngress) {
+    const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+    return {
+      id: edgeArg.id,
+      name: edgeArg.name,
+      enabled: edgeArg.enabled,
+      listenPorts: edgeArg.listenPorts,
+      listenPortsUdp: edgeArg.listenPortsUdp,
+      effectiveListenPorts: manager?.getEffectiveListenPorts(edgeArg),
+      effectiveListenPortsUdp: manager?.getEffectiveListenPortsUdp(edgeArg),
+      autoDerivePorts: edgeArg.autoDerivePorts,
+      tags: edgeArg.tags,
+      performance: edgeArg.performance,
+      createdAt: edgeArg.createdAt,
+      updatedAt: edgeArg.updatedAt,
+    };
+  }
+
+  private summarizeVpnClient(clientArg: interfaces.data.IVpnClient) {
+    return {
+      clientId: clientArg.clientId,
+      enabled: clientArg.enabled,
+      assignedIp: clientArg.assignedIp,
+      description: clientArg.description,
+      targetProfileIds: clientArg.targetProfileIds,
+      expiresAt: clientArg.expiresAt,
+      useHostIp: clientArg.useHostIp,
+      useDhcp: clientArg.useDhcp,
+      staticIp: clientArg.staticIp,
+      forceVlan: clientArg.forceVlan,
+      vlanId: clientArg.vlanId,
+      sourceIp: this.opsServerRef.dcRouterRef.vpnManager?.getClientSourceIp?.(clientArg.clientId),
+      createdAt: clientArg.createdAt,
+      updatedAt: clientArg.updatedAt,
+    };
+  }
+}

package/ts/opsserver/classes.opsserver.ts

@@ -3,6 +3,7 @@ import * as plugins from '../plugins.js';
 import * as paths from '../paths.js';
 import * as handlers from './handlers/index.js';
 import * as interfaces from '../../ts_interfaces/index.js';
+import { McpManager } from './classes.mcpmanager.js';
 
 export class OpsServer {
   public dcRouterRef: DcRouter;
@@ -52,6 +53,7 @@ export class OpsServer {
       domain: 'localhost',
       feedMetadata: undefined,
       serveDir: paths.distServe,
+      addCustomRoutes: async (typedserver) => this.registerCustomRoutes(typedserver),
     });
     
     // The server has a built-in typedrouter at /typedrequest
@@ -103,6 +105,15 @@ export class OpsServer {
     console.log('✅ OpsServer TypedRequest handlers initialized');
   }
 
+  private registerCustomRoutes(typedserver: plugins.typedserver.TypedServer): void {
+    const mcpManager = new McpManager(this);
+    typedserver.addRoute(
+      '/mcp',
+      'ALL',
+      async (ctx) => mcpManager.handleRequest(ctx.request),
+    );
+  }
+
   public async stop() {
     if (this.adminHandler) {
       await this.adminHandler.stop();