fa-mcp-sdk 0.2.249 → 0.2.258

package/cli-template/FA-MCP-SDK-DOC/00-FA-MCP-SDK-index.md

@@ -1,50 +1,6 @@
 # FA-MCP-SDK Documentation Index
 
-## Overview
-
-The FA-MCP-SDK is a comprehensive TypeScript framework for building Model Context
-Protocol (MCP) servers. This is the documentation index - read the relevant
-sections based on your task.
-
-## Using with Claude Code
-
-This project includes a specialized agent `.claude/agents/fa-mcp-sdk.md` for
-Claude Code. The agent automatically reads relevant documentation sections and
-follows SDK patterns.
-
-### Example Prompts
-
-**Creating tools:**
-```
-Use the fa-mcp-sdk subagent to add a tool "get_user" that fetches user data by ID from the database
-```
-
-**Adding REST API:**
-```
-Use the fa-mcp-sdk subagent to create REST endpoint POST /api/users for user registration with validation
-```
-
-**Setting up authentication:**
-```
-Use the fa-mcp-sdk subagent to configure JWT authentication with 1 hour token expiration
-```
-
-**Database integration:**
-```
-Use the fa-mcp-sdk subagent to add PostgreSQL integration and create a tool to query orders table
-```
-
-**Complex tasks:**
-```
-Use the fa-mcp-sdk subagent to create an MCP server for managing TODO lists with:
-- tools: add_todo, list_todos, complete_todo, delete_todo
-- PostgreSQL storage
-- JWT authentication
-- REST API for web client
-```
-
-The agent will read the appropriate documentation files and implement the
-functionality following SDK conventions.
+TypeScript framework for building MCP servers.
 
 ## Quick Start
 
@@ -54,104 +10,43 @@ npm install fa-mcp-sdk
 
 ## Documentation Structure
 
-| File                                                           | Content | Read When |
-|----------------------------------------------------------------|---------|-----------|
-| [01-getting-started.md](01-getting-started.md)                 | Installation, project structure, `initMcpServer()`, core types (`McpServerData`, `IPromptData`, `IResourceData`), Configuration API (`AppConfig`, `getProjectData`, `getSafeAppConfig`) | Starting a new project, understanding project structure |
-| [02-1-tools-and-api.md](02-1-tools-and-api.md)                 | Tool definitions, `toolHandler`, HTTP headers, REST API with tsoa decorators, OpenAPI/Swagger (`configureOpenAPI`, `OpenAPISpecResponse`, `SwaggerUIConfig`) | Creating MCP tools, adding REST endpoints, configuring Swagger |
-| [02-2-prompts-and-resources.md](02-2-prompts-and-resources.md) | Standard prompts (agent-brief, agent-prompt), custom prompts, standard resources, custom resources, `requireAuth` | Configuring prompts and resources |
-| [03-configuration.md](03-configuration.md)                     | `appConfig`, YAML configuration, cache management, database integration (PostgreSQL) | Configuring the server, using cache or database |
-| [04-authentication.md](04-authentication.md)                   | Multi-auth system, JWT tokens (`TTokenType`), Basic auth, server tokens, custom validators, `createAuthMW()`, Token Generator (`generateTokenApp`) | Setting up authentication, generating tokens |
-| [05-ad-authorization.md](05-ad-authorization.md)               | AD configuration types (`IADConfig`, `IDcConfig`), AD group-based authorization examples: HTTP level, all tools, per-tool | Implementing AD group restrictions |
-| [06-utilities.md](06-utilities.md)                             | Error handling (`ServerError`), utility functions (`normalizeHeaders`, `getTools`), constants (`ROOT_PROJECT_DIR`), logging, events, Consul integration, graceful shutdown | Error handling, logging, service discovery |
-| [07-testing-and-operations.md](07-testing-and-operations.md)   | Test clients (STDIO, HTTP, SSE, Streamable HTTP - `McpStreamableHttpClient`), transport types, best practices | Testing, deployment, operations |
-
-## Common Tasks Quick Reference
-
-### Create a new MCP server
-Read: `01-getting-started.md` → `02-1-tools-and-api.md`
-
-### Add MCP tools
-Read: `02-1-tools-and-api.md` (Tool Development section)
-
-### Add REST API endpoints
-Read: `02-1-tools-and-api.md` (REST API Endpoints section)
-- Use tsoa decorators (`@Route`, `@Get`, `@Post`, `@Tags`)
-- Swagger generates automatically if `swagger/openapi.yaml` doesn't exist
-
-### Configure prompts
-Read: `02-2-prompts-and-resources.md`
-- Standard: `agent-brief.ts` (short description), `agent-prompt.ts` (full instructions)
-- Custom: add to `customPrompts` array in `src/prompts/custom-prompts.ts`
-- Use `requireAuth: true` to protect prompts
-
-### Configure resources
-Read: `02-2-prompts-and-resources.md`
-- Standard: `project://id`, `project://name`, `doc://readme`, `required://http-headers`
-- Custom: add to `customResources` array in `src/custom-resources.ts`
-- Use `requireAuth: true` to protect resources
-
-### Configure authentication
-Read: `04-authentication.md`
-- Enable in `config/default.yaml` under `webServer.auth`
-- Options: `permanentServerTokens`, `jwtToken`, `basic`, custom validator
-
-### Add AD group authorization
-Read: `05-ad-authorization.md`
-- HTTP level (block at entry)
-- Tool level (restrict all or specific tools)
-
-### Use database
-Read: `03-configuration.md` (Database Integration section)
-- Set `db.postgres.dbs.main.host` in config
-- Use `queryMAIN()`, `execMAIN()`, `oneRowMAIN()`
-
-### Use caching
-Read: `03-configuration.md` (Cache Management section)
-- `getCache()` → `cache.get()`, `cache.set()`, `cache.getOrSet()`
-
-### Write tests
-Read: `07-testing-and-operations.md`
-- Use `McpHttpClient`, `McpStdioClient`, `McpSseClient`
-- Use `getAuthHeadersForTests()` for auth headers
-
-## Key Exports from fa-mcp-sdk
+| File | Content | Read When |
+|------|---------|-----------|
+| [01-getting-started](01-getting-started.md) | `initMcpServer()`, `McpServerData`, `IPromptData`, `IResourceData`, `AppConfig` | Starting new project |
+| [02-1-tools-and-api](02-1-tools-and-api.md) | Tool definitions, `toolHandler`, REST API with tsoa, OpenAPI/Swagger | Creating tools, REST endpoints |
+| [02-2-prompts-and-resources](02-2-prompts-and-resources.md) | Standard/custom prompts, resources, `requireAuth` | Configuring prompts/resources |
+| [03-configuration](03-configuration.md) | `appConfig`, YAML config, cache, PostgreSQL | Server configuration, DB |
+| [04-authentication](04-authentication.md) | JWT, Basic auth, server tokens, `createAuthMW()`, Token Generator | Authentication setup |
+| [05-ad-authorization](05-ad-authorization.md) | AD group authorization at HTTP/tool levels | AD group restrictions |
+| [06-utilities](06-utilities.md) | `ServerError`, `normalizeHeaders`, logging, Consul, graceful shutdown | Error handling, utilities |
+| [07-testing-and-operations](07-testing-and-operations.md) | Test clients (STDIO, HTTP, SSE, Streamable HTTP) | Testing, deployment |
 
-```typescript
-// Initialization
-import { initMcpServer, McpServerData } from 'fa-mcp-sdk';
+## Key Exports
 
-// Configuration
-import { appConfig, AppConfig, getProjectData, getSafeAppConfig, ROOT_PROJECT_DIR } from 'fa-mcp-sdk';
+```typescript
+// Core
+import { initMcpServer, McpServerData, appConfig, getProjectData, getSafeAppConfig, ROOT_PROJECT_DIR } from 'fa-mcp-sdk';
 
-// Authentication
+// Auth
 import { createAuthMW, generateToken, getAuthHeadersForTests, TTokenType, generateTokenApp } from 'fa-mcp-sdk';
 
-// Tools
-import { formatToolResult, ToolExecutionError, getTools } from 'fa-mcp-sdk';
-
-// Errors
-import { ServerError, BaseMcpError, ValidationError } from 'fa-mcp-sdk';
-
-// Database
-import { queryMAIN, execMAIN, oneRowMAIN, checkMainDB } from 'fa-mcp-sdk';
+// Tools & Errors
+import { formatToolResult, ToolExecutionError, ServerError, BaseMcpError, ValidationError, getTools } from 'fa-mcp-sdk';
 
-// Cache
-import { getCache } from 'fa-mcp-sdk';
-
-// Logging
-import { logger, fileLogger } from 'fa-mcp-sdk';
+// Database & Cache
+import { queryMAIN, execMAIN, oneRowMAIN, checkMainDB, getCache } from 'fa-mcp-sdk';
 
 // Utilities
-import { trim, ppj, toError, toStr, normalizeHeaders } from 'fa-mcp-sdk';
+import { logger, fileLogger, trim, ppj, toError, toStr, normalizeHeaders } from 'fa-mcp-sdk';
 
-// Test clients
+// Test Clients
 import { McpHttpClient, McpStdioClient, McpSseClient, McpStreamableHttpClient } from 'fa-mcp-sdk';
 
 // AD Groups
 import { initADGroupChecker, IADConfig, IDcConfig } from 'fa-mcp-sdk';
 
-// OpenAPI/Swagger
-import { configureOpenAPI, createSwaggerUIAssetsMiddleware, OpenAPISpecResponse, SwaggerUIConfig } from 'fa-mcp-sdk';
+// OpenAPI
+import { configureOpenAPI, OpenAPISpecResponse, SwaggerUIConfig } from 'fa-mcp-sdk';
 ```
 
 ## Project Structure
@@ -159,33 +54,27 @@ import { configureOpenAPI, createSwaggerUIAssetsMiddleware, OpenAPISpecResponse,
 ```
 my-mcp-server/
 ├── config/
-│   ├── default.yaml             # Base configuration
-│   ├── development.yaml         # Development overrides
-│   ├── local.yaml               # Local secrets (gitignored)
-│   └── production.yaml          # Production overrides
+│   ├── default.yaml        # Base configuration
+│   ├── development.yaml    # Dev overrides
+│   ├── local.yaml          # Local secrets (gitignored)
+│   └── production.yaml     # Prod overrides
 ├── src/
 │   ├── _types_/
-│   │   ├── common.d.ts          # Common type declarations
-│   │   └── custom-config.ts     # Custom config interface
+│   │   └── custom-config.ts    # Custom config interface
 │   ├── api/
-│   │   └── router.ts            # REST endpoints with tsoa decorators
-│   ├── asset/
-│   │   └── logo.svg             # Static assets
+│   │   └── router.ts           # REST endpoints (tsoa)
 │   ├── prompts/
-│   │   ├── agent-brief.ts       # Short agent description
-│   │   ├── agent-prompt.ts      # Full agent system prompt
-│   │   └── custom-prompts.ts    # Additional prompts
+│   │   ├── agent-brief.ts      # Short agent description
+│   │   ├── agent-prompt.ts     # Full agent prompt
+│   │   └── custom-prompts.ts   # Additional prompts
 │   ├── tools/
-│   │   ├── handle-tool-call.ts  # Tool execution logic
-│   │   └── tools.ts             # Tool definitions
-│   ├── custom-resources.ts      # Custom MCP resources
-│   └── start.ts                 # Entry point
-├── swagger/
-│   └── openapi.yaml             # Auto-generated (gitignored)
+│   │   ├── handle-tool-call.ts # Tool execution
+│   │   └── tools.ts            # Tool definitions
+│   ├── custom-resources.ts     # Custom MCP resources
+│   └── start.ts                # Entry point
 └── tests/
 ```
 
-
 ## Minimal Example
 
 **`src/start.ts`:**
@@ -208,19 +97,15 @@ await initMcpServer(serverData);
 ```typescript
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 
-export const tools: Tool[] = [
-  {
-    name: 'hello',
-    description: 'Say hello',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Name to greet' }
-      },
-      required: ['name']
-    }
+export const tools: Tool[] = [{
+  name: 'hello',
+  description: 'Say hello',
+  inputSchema: {
+    type: 'object',
+    properties: { name: { type: 'string', description: 'Name to greet' } },
+    required: ['name']
   }
-];
+}];
 ```
 
 **`src/tools/handle-tool-call.ts`:**
@@ -229,7 +114,6 @@ import { formatToolResult, ToolExecutionError } from 'fa-mcp-sdk';
 
 export const handleToolCall = async (params: { name: string; arguments?: any }): Promise<any> => {
   const { name, arguments: args } = params;
-
   switch (name) {
     case 'hello':
       return formatToolResult({ message: `Hello, ${args.name}!` });

package/cli-template/FA-MCP-SDK-DOC/01-getting-started.md

@@ -1,295 +1,140 @@
-# Getting Started with FA-MCP-SDK
+# Getting Started
 
-## Overview
+## initMcpServer(data: McpServerData): Promise<void>
 
-The FA-MCP-SDK is a comprehensive TypeScript framework for building Model Context
-Protocol (MCP) servers. This documentation covers how to use the SDK
-to create your own MCP server project.
-
-## Installation
-
-```bash
-npm install fa-mcp-sdk
-```
-
-## Project Structure
-
-When creating a new MCP server, your project structure should follow this pattern:
-
-```
-my-mcp-server/
-├── config/                      # Environment configurations
-│   ├── default.yaml             # Base configuration
-│   ├── development.yaml         # Development settings
-│   ├── production.yaml          # Production settings
-│   └── test.yaml                # Test environment
-├── src/                         # Source code
-│   ├── _types_/                 # TypeScript type definitions
-│   ├── api/                     # REST API routes (HTTP transport)
-│   │   └── router.ts            # Express router with tsoa controllers
-│   ├── prompts/                 # Agent prompts
-│   │   ├── agent-brief.ts       # Agent brief
-│   │   ├── agent-prompt.ts      # Main agent prompt
-│   │   └── custom-prompts.ts    # Custom prompts
-│   ├── tools/                   # MCP tool implementations
-│   │   ├── handle-tool-call.ts  # Tool execution handler
-│   │   └── tools.ts             # Tool definitions
-│   ├── custom-resources.ts      # Custom MCP resources
-│   └── start.ts                 # Application entry point
-├── tests/                       # Test suites
-│   ├── mcp/                     # MCP protocol tests
-│   └── utils.ts                 # Test utilities
-├── .env                         # Environment variables
-├── package.json                 # NPM package configuration
-└── tsconfig.json                # TypeScript configuration
-```
-
-## Main Initialization Function
-
-### `initMcpServer(data: McpServerData): Promise<void>`
-
-The primary function for starting your MCP server.
-
-**Example Usage in `src/start.ts`:**
+Primary function for starting your MCP server.
 
 ```typescript
 import { initMcpServer, McpServerData, CustomAuthValidator } from 'fa-mcp-sdk';
 import { tools } from './tools/tools.js';
 import { handleToolCall } from './tools/handle-tool-call.js';
-import { AGENT_BRIEF } from './prompts/agent-brief.js';
-import { AGENT_PROMPT } from './prompts/agent-prompt.js';
-
-// Optional: Custom Authentication validator (black box function)
-const customAuthValidator: CustomAuthValidator = async (req): Promise<AuthResult> => {
-  // Your custom authentication logic here - full request object available
-  // Can access headers, IP, user-agent, etc.
-  const authHeader = req.headers.authorization;
-  const userID = req.headers['x-user-id'];
-  const clientIP = req.headers['x-real-ip'] || req.connection?.remoteAddress;
-
-  // Implement any authentication logic (database, LDAP, API, custom rules, etc.)
-  const isAuthenticated = await authenticateRequest(req);
-
-  if (isAuthenticated) {
-    return {
-      success: true,
-      authType: 'basic',
-      username: userID || 'unknown',
-    };
-  } else {
-    return {
-      success: false,
-      error: 'Custom authentication failed',
-    };
-  }
-};
 
 const serverData: McpServerData = {
   tools,
   toolHandler: handleToolCall,
-  agentBrief: AGENT_BRIEF,
-  agentPrompt: AGENT_PROMPT,
-
-  // Optional: Provide custom authentication function
-  customAuthValidator: customAuthValidator,
-
-  // ... other configuration
+  agentBrief: 'My agent description',
+  agentPrompt: 'Full agent instructions',
+  customAuthValidator: async (req) => { /* custom auth logic */ },
 };
 
 await initMcpServer(serverData);
 ```
 
-## Core Types and Interfaces
-
-### `McpServerData`
+## Core Types
 
-Main configuration interface for your MCP server.
+### McpServerData
 
 ```typescript
 interface McpServerData {
-  // MCP Core Components
-  tools: Tool[] | (() => Promise<Tool[]>);         // Your tool definitions (static array or async function)
-  toolHandler: (params: IToolHandlerParams) => Promise<any>; // Tool execution function
-
-  // Agent Configuration
-  agentBrief: string;                              // Brief description of your agent
-  agentPrompt: string;                             // System prompt for your agent
-  customPrompts?: IPromptData[];                   // Additional custom prompts
-
-  // Resources
-  requiredHttpHeaders?: IRequiredHttpHeader[] | null; // HTTP headers for authentication
-  customResources?: IResourceData[] | null;        // Custom resource definitions
-
-  // Authentication
-  customAuthValidator?: CustomAuthValidator;       // Custom authentication validator function
-  tokenGenAuthHandler?: TokenGenAuthHandler;       // Custom authorization for Token Generator admin page
-
-  // HTTP Server Components (for HTTP transport)
-  httpComponents?: {
-    apiRouter?: Router | null;                     // Express router for additional endpoints
-  };
-
-  // UI Assets
-  assets?: {
-    logoSvg?: string;                              // SVG content for logo/favicon
-    maintainerHtml?: string;                       // Support contact HTML snippet
-  };
-
-  // Consul Integration
-  getConsulUIAddress?: (serviceId: string) => string; // Function to generate Consul UI URLs
+  tools: Tool[] | (() => Promise<Tool[]>);           // Tool definitions
+  toolHandler: (params: IToolHandlerParams) => Promise<any>;
+  agentBrief: string;                                 // Brief description
+  agentPrompt: string;                                // System prompt
+  customPrompts?: IPromptData[];                      // Additional prompts
+  usedHttpHeaders?: IUsedHttpHeader[] | null;         // HTTP headers for auth
+  customResources?: IResourceData[] | null;           // Custom resources
+  customAuthValidator?: CustomAuthValidator;          // Custom auth function
+  tokenGenAuthHandler?: TokenGenAuthHandler;          // Token Generator auth
+  httpComponents?: { apiRouter?: Router | null };     // Express router
+  assets?: { logoSvg?: string; maintainerHtml?: string };
+  getConsulUIAddress?: (serviceId: string) => string;
 }
 
 interface IToolHandlerParams {
   name: string;
   arguments?: any;
   headers?: Record<string, string>;
-  payload?: { user: string; [key: string]: any } | undefined; // JWT payload if authenticated
+  payload?: { user: string; [key: string]: any };     // JWT payload if authenticated
+  transport?: 'stdio' | 'sse' | 'http';
 }
 ```
 
-### `IPromptData`
+### IPromptData
 
-Configuration for custom prompts in `src/prompts/custom-prompts.ts`.
+For custom prompts in `src/prompts/custom-prompts.ts`:
 
 ```typescript
 interface IPromptData {
-  name: string;                                    // Unique prompt identifier
-  description: string;                             // Human-readable description
-  arguments: [];                                   // Expected arguments (currently empty array)
-  content: IPromptContent;                         // Static string or dynamic function
-  requireAuth?: boolean;                           // Whether authentication is required
+  name: string;
+  description: string;
+  arguments: [];
+  content: string | ((request: IGetPromptRequest) => string | Promise<string>);
+  requireAuth?: boolean;
 }
 
-type IPromptContent = string | TPromptContentFunction;
-type TPromptContentFunction = (request: IGetPromptRequest) => string | Promise<string>;
+// Example:
+export const customPrompts: IPromptData[] = [{
+  name: 'custom_prompt',
+  description: 'A custom prompt',
+  arguments: [],
+  content: (request) => `Content with param: ${request.params.arguments?.sample}`,
+}];
 ```
 
-Example `src/prompts/custom-prompts.ts`:
-```typescript
-import { IPromptData } from 'fa-mcp-sdk';
+### IResourceData
 
-export const customPrompts: IPromptData[] = [
-  {
-    name: 'custom_prompt',
-    description: 'A custom prompt for specific tasks',
-    arguments: [],
-    content: (request) => {
-      const { sample } = request.params.arguments || {};
-      return `Custom prompt content with parameter: ${sample}`;
-    },
-  },
-];
-```
-
-### `IResourceData`
-
-Configuration for custom resources in `src/custom-resources.ts`.
+For custom resources in `src/custom-resources.ts`:
 
 ```typescript
 interface IResourceData {
-  uri: string;                                     // Unique resource URI (e.g., "custom-resource://data1")
-  name: string;                                    // Resource name
-  title?: string;                                  // Optional display title
-  description: string;                             // Human-readable description
-  mimeType: string;                                // MIME type (e.g., "text/plain", "application/json")
-  content: IResourceContent;                       // Static string, object, or dynamic function
-  requireAuth?: boolean;                           // Whether authentication is required
+  uri: string;            // e.g., "custom-resource://data1"
+  name: string;
+  title?: string;
+  description: string;
+  mimeType: string;       // e.g., "text/plain", "application/json"
+  content: string | object | ((uri: string) => string | Promise<string>);
+  requireAuth?: boolean;
 }
 
-// Content types for resources
-type IResourceContent = string | object | TResourceContentFunction;
-type TResourceContentFunction = (uri: string) => string | Promise<string>;
-```
-
-Example `src/custom-resources.ts`:
-```typescript
-import { IResourceData } from 'fa-mcp-sdk';
-
-export const customResources: IResourceData[] = [
-  {
-    uri: 'custom-resource://resource1',
-    name: 'resource1',
-    description: 'Example resource with dynamic content',
-    mimeType: 'text/plain',
-    content: (uri) => {
-      return `Dynamic content for ${uri} at ${new Date().toISOString()}`;
-    },
-  },
-];
+// Example:
+export const customResources: IResourceData[] = [{
+  uri: 'custom-resource://resource1',
+  name: 'resource1',
+  description: 'Dynamic content example',
+  mimeType: 'text/plain',
+  content: (uri) => `Dynamic content for ${uri}`,
+}];
 ```
 
----
-
 ## Configuration API
 
-### `AppConfig`
+### appConfig
 
-Base configuration type for MCP server applications. Extends multiple configuration interfaces for database, logging, web server, MCP, and Active Directory settings.
+Singleton with merged configuration from YAML files and environment variables:
 
 ```typescript
 import { appConfig, AppConfig } from 'fa-mcp-sdk';
 
-// appConfig is a singleton with merged configuration from:
-// - config/default.yaml (base)
-// - config/{NODE_ENV}.yaml (environment-specific)
-// - Environment variables (highest priority)
-
-// Access configuration values
 const port = appConfig.webServer.port;
 const serviceName = appConfig.name;
 const isAuthEnabled = appConfig.webServer.auth.enabled;
 ```
 
-**Key Properties:**
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `name` | string | Package name from package.json |
-| `shortName` | string | Name without 'mcp' suffix |
-| `version` | string | Package version |
-| `description` | string | Package description |
-| `webServer` | object | HTTP server configuration (host, port, auth) |
-| `mcp` | object | MCP protocol settings (transportType, rateLimit) |
-| `logger` | object | Logging configuration (level, useFileLogger) |
-| `ad` | object | Active Directory configuration |
-| `consul` | object | Consul service discovery settings |
+| Property | Description |
+|----------|-------------|
+| `name` | Package name from package.json |
+| `shortName` | Name without 'mcp' suffix |
+| `version` | Package version |
+| `webServer` | HTTP server config (host, port, auth) |
+| `mcp` | MCP settings (transportType, rateLimit) |
+| `logger` | Logging config |
+| `ad` | Active Directory config |
+| `consul` | Service discovery settings |
 
-### `getProjectData()`
+### getProjectData(): McpServerData
 
-Retrieves the MCP server project data that was passed to `initMcpServer()`.
+Returns the data passed to `initMcpServer()`.
 
 ```typescript
-import { getProjectData, McpServerData } from 'fa-mcp-sdk';
-
-// Function Signature:
-function getProjectData(): McpServerData;
-
-// Example - Access project data from anywhere in your application:
 const projectData = getProjectData();
-console.log('Agent brief:', projectData.agentBrief);
-console.log('Tools count:', projectData.tools.length);
+console.log(projectData.agentBrief, projectData.tools.length);
 ```
 
-### `getSafeAppConfig()`
+### getSafeAppConfig(): any
 
-Returns a deep clone of the application configuration with sensitive data masked. Use this for logging configuration without exposing secrets.
+Returns config clone with sensitive data masked. Use for logging:
 
 ```typescript
-import { getSafeAppConfig } from 'fa-mcp-sdk';
-
-// Function Signature:
-function getSafeAppConfig(): any;
-
-// Example - Log configuration safely:
 const safeConfig = getSafeAppConfig();
-console.log('Current configuration:', JSON.stringify(safeConfig, null, 2));
-
-// Sensitive values are masked:
-// - Database passwords: '[MASKED]'
-// - JWT keys, API tokens, etc.
+console.log(JSON.stringify(safeConfig, null, 2)); // passwords masked
 ```
-
-**Typical Use Cases:**
-- Debugging configuration issues
-- Audit logging of startup parameters
-- Displaying configuration in admin interfaces